From 0554dc062b7120a36a646f3ee97894f46351d4b5 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Mon, 10 Feb 2014 18:14:14 +0200
Subject: [PATCH 001/422] initial commit

---
 .gitignore                                    |   1 +
 rxjava-contrib/rxjava-quasar/README.md        |  35 +++++
 rxjava-contrib/rxjava-quasar/build.gradle     |  40 +++++
 .../java/rx/quasar/ChannelObservable.java     | 103 +++++++++++++
 .../java/rx/quasar/NewFiberScheduler.java     | 145 ++++++++++++++++++
 .../rx/quasar/OnSubscribeFromChannel.java     |  61 ++++++++
 .../resources/META-INF/suspendable-supers     |   2 +
 .../java/rx/quasar/ChannelObservableTest.java |  86 +++++++++++
 .../java/rx/quasar/NewFiberSchedulerTest.java |  32 ++++
 settings.gradle                               |   3 +-
 10 files changed, 507 insertions(+), 1 deletion(-)
 create mode 100644 rxjava-contrib/rxjava-quasar/README.md
 create mode 100644 rxjava-contrib/rxjava-quasar/build.gradle
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
 create mode 100644 rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
 create mode 100644 rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java

diff --git a/.gitignore b/.gitignore
index f69630c23c..606575380d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -62,6 +62,7 @@ bin/
 
 # NetBeans specific files/directories
 .nbattrs
+/.nb-gradle/profiles/private/
 
 # Scala build
 *.cache
diff --git a/rxjava-contrib/rxjava-quasar/README.md b/rxjava-contrib/rxjava-quasar/README.md
new file mode 100644
index 0000000000..ab031fcda3
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/README.md
@@ -0,0 +1,35 @@
+# rxjava-quasar
+
+Integrates RxJava with [Quasar](https://github.com/puniverse/quasar).
+Includes a fiber (lightweight-thread) based scheduler, and an Observable API for Quasar channels.
+
+Main Classes:
+
+- [NewFiberScheduler](https://github.com/Netflix/RxJava/blob/master/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java)
+- [ChannelObservable](https://github.com/Netflix/RxJava/blob/master/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java)
+
+
+# Binaries
+
+Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ccom.netflix.rxjava).
+
+Example for [Maven](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-apache-http%22):
+
+```xml
+<dependency>
+    <groupId>com.netflix.rxjava</groupId>
+    <artifactId>rxjava-quasar</artifactId>
+    <version>x.y.z</version>
+</dependency>
+```
+
+and for Ivy:
+
+```xml
+<dependency org="com.netflix.rxjava" name="rxjava-quasar" rev="x.y.z" />
+```
+
+# Sample Usage
+
+
+
diff --git a/rxjava-contrib/rxjava-quasar/build.gradle b/rxjava-contrib/rxjava-quasar/build.gradle
new file mode 100644
index 0000000000..72586db6a1
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/build.gradle
@@ -0,0 +1,40 @@
+apply plugin: 'osgi'
+
+sourceCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_7
+
+configurations {
+    quasar
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+    maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
+}
+
+dependencies {
+    compile project(':rxjava-core')
+    compile 'co.paralleluniverse:quasar-core:0.5.0-SNAPSHOT'
+    quasar  'co.paralleluniverse:quasar-core:0.5.0-SNAPSHOT'
+    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-quasar'
+        instruction 'Bundle-Vendor', 'Netflix'
+        instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
+        instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+    }
+}
+
+tasks.withType(Test) {
+    jvmArgs "-javaagent:${configurations.quasar.iterator().next()}" // =vdmc (verbose, debug, allow monitors, check class)
+}
+
+tasks.withType(JavaExec) {
+    jvmArgs "-javaagent:${configurations.quasar.iterator().next()}" // =vdmc (verbose, debug, allow monitors, check class)
+}
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
new file mode 100644
index 0000000000..17b8201887
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -0,0 +1,103 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in 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.quasar;
+
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.fibers.Suspendable;
+import co.paralleluniverse.strands.Strand;
+import co.paralleluniverse.strands.channels.ReceivePort;
+import co.paralleluniverse.strands.channels.SendPort;
+import rx.Observable;
+import rx.Observer;
+import rx.Scheduler;
+
+/**
+ *
+ */
+public class ChannelObservable {
+
+    /**
+     * Converts an {@link Iterable} sequence into an Observable that emits each message received on the channel.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * <p>
+     * @param channel
+     *                the source {@link ReceivePort}
+     * @param <T>
+     *                the type of messages on the channel and the type of items to be
+     *                emitted by the resulting Observable
+     * @return an Observable that emits each message received on the source {@link ReceivePort}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    public final static <T> Observable<T> from(ReceivePort<T> channel) {
+        return Observable.create(new OnSubscribeFromChannel<T>(channel));
+    }
+
+    /**
+     * Converts an {@link Iterable} sequence into an Observable that operates on the specified
+     * scheduler, emitting each message received on the channel.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.s.png">
+     * <p>
+     * @param channel
+     *                  the source {@link ReceivePort}
+     * @param scheduler
+     *                  the scheduler on which the Observable is to emit the messages received on the channel
+     * @param <T>
+     *                  the type of messages on the channel and the type of items to be
+     *                  emitted by the resulting Observable
+     * @return an Observable that emits each message received on the source {@link ReceivePort}, on the
+     *         specified scheduler
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212140.aspx">MSDN: Observable.ToObservable</a>
+     */
+    public final static <T> Observable<T> from(ReceivePort<T> channel, Scheduler scheduler) {
+        return Observable.create(new OnSubscribeFromChannel<T>(channel)).subscribeOn(scheduler);
+    }
+
+    /**
+     * Converts a {@link SendPort} channel into an {@link Observer}.
+     * <p>
+     * @param <T>     the type of messages that can be sent to the channel and the type of items to be
+     *                received by the Observer
+     * @param channel the target {@link SendPort}
+     * @return
+     */
+    public final static <T> Observer<T> to(final SendPort<T> channel) {
+        return new Observer<T>() {
+
+            @Override
+            @Suspendable
+            public void onNext(T t) {
+                try {
+                    channel.send(t);
+                } catch (InterruptedException ex) {
+                    Strand.interrupted();
+                } catch (SuspendExecution ex) {
+                    throw new AssertionError(ex);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                channel.close();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+            }
+        };
+    }
+}
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
new file mode 100644
index 0000000000..ec6720d4b2
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
@@ -0,0 +1,145 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in 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.quasar;
+
+import co.paralleluniverse.fibers.DefaultFiberScheduler;
+import co.paralleluniverse.fibers.Fiber;
+import co.paralleluniverse.fibers.FiberScheduler;
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.strands.SuspendableRunnable;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action1;
+
+/**
+ * Schedules work on a new fiber.
+ */
+public class NewFiberScheduler extends Scheduler {
+    private final static NewFiberScheduler DEFAULT_INSTANCE = new NewFiberScheduler();
+
+    public static NewFiberScheduler getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+    }
+
+    private final FiberScheduler fiberScheduler;
+
+    public NewFiberScheduler(FiberScheduler fiberScheduler) {
+        if(fiberScheduler == null)
+            throw new IllegalArgumentException("Fiber scheduler is null");
+        if(fiberScheduler == DefaultFiberScheduler.getInstance() && DEFAULT_INSTANCE != null)
+            throw new IllegalArgumentException("Fiber scheduler is the default FiberScheduler; use getDefaultInstance()");
+        this.fiberScheduler = fiberScheduler;
+    }
+
+    private NewFiberScheduler() {
+        this(DefaultFiberScheduler.getInstance());
+    }
+
+    @Override
+    public Subscription schedule(Action1<Scheduler.Inner> action) {
+        EventLoopScheduler innerScheduler = new EventLoopScheduler();
+        innerScheduler.schedule(action);
+        return innerScheduler.innerSubscription;
+    }
+
+    @Override
+    public Subscription schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit) {
+        EventLoopScheduler innerScheduler = new EventLoopScheduler();
+        innerScheduler.schedule(action, delayTime, unit);
+        return innerScheduler.innerSubscription;
+    }
+
+    private class EventLoopScheduler extends Scheduler.Inner implements Subscription {
+        private final CompositeSubscription innerSubscription = new CompositeSubscription();
+
+        private EventLoopScheduler() {
+        }
+
+        @Override
+        public void schedule(final Action1<Scheduler.Inner> action) {
+            if (innerSubscription.isUnsubscribed()) {
+                // don't schedule, we are unsubscribed
+                return;
+            }
+
+            final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
+            Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
+
+                @Override
+                public void run() throws SuspendExecution {
+                    try {
+                        if (innerSubscription.isUnsubscribed()) {
+                            return;
+                        }
+                        action.call(EventLoopScheduler.this);
+                    } finally {
+                        // remove the subscription now that we're completed
+                        Subscription s = sf.get();
+                        if (s != null) {
+                            innerSubscription.remove(s);
+                        }
+                    }
+                }
+            }).start());
+
+            sf.set(s);
+            innerSubscription.add(s);
+        }
+
+        @Override
+        public void schedule(final Action1<Scheduler.Inner> action, final long delayTime, final TimeUnit unit) {
+            final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
+
+            Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
+
+                @Override
+                public void run() throws InterruptedException, SuspendExecution  {
+                    Fiber.sleep(delayTime, unit);
+                    try {
+                        if (innerSubscription.isUnsubscribed()) {
+                            return;
+                        }
+                        // now that the delay is past schedule the work to be done for real on the UI thread
+                        action.call(EventLoopScheduler.this);
+                    } finally {
+                        // remove the subscription now that we're completed
+                        Subscription s = sf.get();
+                        if (s != null) {
+                            innerSubscription.remove(s);
+                        }
+                    }
+                }
+            }).start());
+
+            sf.set(s);
+            innerSubscription.add(s);
+        }
+
+        @Override
+        public void unsubscribe() {
+            innerSubscription.unsubscribe();
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return innerSubscription.isUnsubscribed();
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
new file mode 100644
index 0000000000..77275213a1
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
@@ -0,0 +1,61 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in 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.quasar;
+
+import co.paralleluniverse.fibers.Suspendable;
+import co.paralleluniverse.strands.channels.ReceivePort;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+
+/**
+ * Converts a {@link ReceivePort} into an Observable that emits each message received on the channel.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-Observers/toObservable.png">
+ */
+public final class OnSubscribeFromChannel<T> implements OnSubscribe<T> {
+
+    final ReceivePort<? extends T> channel;
+
+    public OnSubscribeFromChannel(ReceivePort<? extends T> channel) {
+        this.channel = channel;
+    }
+
+    @Override
+    @Suspendable
+    public void call(Subscriber<? super T> o) {
+        for (;;) {
+            T m;
+
+            try {
+                m = channel.receive();
+                if (m == null)
+                    break;
+                if (o.isUnsubscribed()) {
+                    return;
+                }
+            } catch (InterruptedException e) {
+                break;
+            } catch (Exception e) {
+                o.onError(e);
+                continue;
+            }
+
+            o.onNext(m);
+        }
+        
+        o.onCompleted();
+    }
+}
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
new file mode 100644
index 0000000000..290b476b46
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
@@ -0,0 +1,2 @@
+rx.util.functions.Action1.call
+rx.Observer.onNext
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
new file mode 100644
index 0000000000..c66f4ba6b8
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
@@ -0,0 +1,86 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in 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.quasar;
+
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.fibers.Suspendable;
+import co.paralleluniverse.strands.Strand;
+import co.paralleluniverse.strands.channels.Channel;
+import co.paralleluniverse.strands.channels.Channels;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import org.junit.Test;
+import rx.Observer;
+
+public class ChannelObservableTest {
+    private static final int BUFFER_SIZE = 0;
+    private static final Channels.OverflowPolicy OVERFLOW_POLICY = Channels.OverflowPolicy.BLOCK;
+
+    @Test
+    public void testObservableFromChannel() throws Exception {
+        final Channel<String> c = Channels.newChannel(BUFFER_SIZE, OVERFLOW_POLICY);
+
+        final Queue<String> result = new ConcurrentLinkedQueue<String>();
+        final AtomicBoolean completed = new AtomicBoolean();
+        
+        ChannelObservable.from(c).subscribeOn(NewFiberScheduler.getDefaultInstance()).subscribe(new Observer<String>() {
+            @Override
+            @Suspendable
+            public void onNext(String t) {
+//                try {
+                    System.out.println("GOT: " + t);
+                    assertTrue(Strand.isCurrentFiber());
+                    System.out.println("GOT2: " + t);
+                    //Strand.sleep(100);
+                    System.out.println("GOT3: " + t);
+                    result.add(t);
+                    System.out.println("GOT4: " + t);
+//                } catch(InterruptedException e) {
+//                    
+//                } catch (SuspendExecution e) {
+//                    System.err.println("WHA????? " + e);
+//                    throw new AssertionError(e);
+//                }
+            }
+
+            @Override
+            public void onCompleted() {
+                completed.set(true);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                
+            }
+        });
+        
+        c.send("a");
+        c.send("b");
+        c.send("c");
+        c.close();
+        
+        Thread.sleep(500);
+        
+        assertThat(new ArrayList<String>(result), equalTo(Arrays.asList("a", "b", "c")));
+        assertThat(completed.get(), is(true));
+    }
+}
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java
new file mode 100644
index 0000000000..93ef9d73b9
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java
@@ -0,0 +1,32 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in 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.quasar;
+
+import org.junit.Rule;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
+import rx.Scheduler;
+import rx.schedulers.AbstractSchedulerConcurrencyTests;
+
+public class NewFiberSchedulerTest extends AbstractSchedulerConcurrencyTests {
+//    @Rule
+//    public TestRule globalTimeout = new Timeout(20000);
+
+    @Override
+    protected Scheduler getScheduler() {
+        return NewFiberScheduler.getDefaultInstance();
+    }
+}
diff --git a/settings.gradle b/settings.gradle
index 2122bb8ff6..807fc32a13 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -10,4 +10,5 @@ include 'rxjava-core', \
 'rxjava-contrib:rxjava-apache-http', \
 'rxjava-contrib:rxjava-string', \
 'rxjava-contrib:rxjava-async-util', \
-'rxjava-contrib:rxjava-computation-expressions'
+'rxjava-contrib:rxjava-computation-expressions',\
+'rxjava-contrib:rxjava-quasar'

From 6c7ac7f81f6be7a6dc4383a959d00647d97306ee Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Mon, 10 Feb 2014 18:50:23 +0200
Subject: [PATCH 002/422] tests pass

---
 .../java/rx/quasar/ChannelObservable.java     |  2 +
 .../src/main/resources/META-INF/suspendables  |  2 +
 .../java/rx/quasar/ChannelObservableTest.java | 52 +++++++++++--------
 3 files changed, 34 insertions(+), 22 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables

diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index 17b8201887..072733982f 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -22,6 +22,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
+import rx.util.OnErrorNotImplementedException;
 
 /**
  *
@@ -97,6 +98,7 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
+                throw new OnErrorNotImplementedException(e);
             }
         };
     }
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
new file mode 100644
index 0000000000..7ce00d743a
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
@@ -0,0 +1,2 @@
+rx.Observable.subscribe
+rx.observers.SafeSubscriber.onNext
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
index c66f4ba6b8..c7af56da2d 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
@@ -22,44 +22,38 @@
 import co.paralleluniverse.strands.channels.Channels;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
 import org.junit.Test;
+import rx.Observable;
 import rx.Observer;
 
 public class ChannelObservableTest {
-    private static final int BUFFER_SIZE = 0;
-    private static final Channels.OverflowPolicy OVERFLOW_POLICY = Channels.OverflowPolicy.BLOCK;
-
     @Test
     public void testObservableFromChannel() throws Exception {
-        final Channel<String> c = Channels.newChannel(BUFFER_SIZE, OVERFLOW_POLICY);
+        final Channel<String> c = Channels.newChannel(0);
+
+        System.out.println("===== " + c);
 
         final Queue<String> result = new ConcurrentLinkedQueue<String>();
         final AtomicBoolean completed = new AtomicBoolean();
-        
-        ChannelObservable.from(c).subscribeOn(NewFiberScheduler.getDefaultInstance()).subscribe(new Observer<String>() {
+
+        ChannelObservable.from(c, NewFiberScheduler.getDefaultInstance()).subscribe(new Observer<String>() {
             @Override
             @Suspendable
             public void onNext(String t) {
-//                try {
+                try {
                     System.out.println("GOT: " + t);
                     assertTrue(Strand.isCurrentFiber());
-                    System.out.println("GOT2: " + t);
-                    //Strand.sleep(100);
-                    System.out.println("GOT3: " + t);
+                    Strand.sleep(100);
                     result.add(t);
-                    System.out.println("GOT4: " + t);
-//                } catch(InterruptedException e) {
-//                    
-//                } catch (SuspendExecution e) {
-//                    System.err.println("WHA????? " + e);
-//                    throw new AssertionError(e);
-//                }
+                } catch (InterruptedException e) {
+                } catch (SuspendExecution e) {
+                    throw new AssertionError(e);
+                }
             }
 
             @Override
@@ -69,18 +63,32 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                
+
             }
         });
-        
+
         c.send("a");
         c.send("b");
         c.send("c");
         c.close();
-        
+
         Thread.sleep(500);
-        
+
         assertThat(new ArrayList<String>(result), equalTo(Arrays.asList("a", "b", "c")));
         assertThat(completed.get(), is(true));
     }
+
+    @Test
+    public void testObserverChannel() throws Exception {
+        final Channel<String> c = Channels.newChannel(10); // must use a buffer, otherwise will block on subscribe
+
+        System.out.println("===== " + c);
+
+        Observable.from(Arrays.asList("a", "b", "c")).subscribe(ChannelObservable.to(c));
+
+        assertThat(c.receive(), equalTo("a"));
+        assertThat(c.receive(), equalTo("b"));
+        assertThat(c.receive(), equalTo("c"));
+        assertThat(c.receive(), is(nullValue()));
+    }
 }

From dd94e7b6a188ba2adeb6fe5b87d311be59e1fcc3 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Tue, 11 Feb 2014 01:04:11 +0200
Subject: [PATCH 003/422] Added ChannelObservable.subscribe

---
 rxjava-contrib/rxjava-quasar/README.md        |  13 +-
 .../java/rx/quasar/ChannelObservable.java     | 159 +++++++++++++++++-
 .../rx/quasar/OnSubscribeFromChannel.java     |   2 +-
 .../resources/META-INF/suspendable-supers     |  25 ++-
 .../src/main/resources/META-INF/suspendables  |  33 +++-
 .../java/rx/quasar/ChannelObservableTest.java |  35 ++++
 6 files changed, 261 insertions(+), 6 deletions(-)

diff --git a/rxjava-contrib/rxjava-quasar/README.md b/rxjava-contrib/rxjava-quasar/README.md
index ab031fcda3..5c67aaee2b 100644
--- a/rxjava-contrib/rxjava-quasar/README.md
+++ b/rxjava-contrib/rxjava-quasar/README.md
@@ -29,7 +29,18 @@ and for Ivy:
 <dependency org="com.netflix.rxjava" name="rxjava-quasar" rev="x.y.z" />
 ```
 
-# Sample Usage
+# Usage
 
+As always when using Quasar, the java agent has to be started by adding the following JVM option:
 
+```
+-javaagent:path-to-quasar-jar.jar
+```
+
+Alternatively, you can use AOT instrumentation (see [the Quasar documentation](http://docs.paralleluniverse.co/quasar/#instrumentation)).
+
+Or, if you're running in Tomcat, you can use the Quasar class loader (see [the Comsat documentation](http://docs.paralleluniverse.co/comsat/#enabling-comsat)).
+
+`Observer`, `Function` or `Action` method implementations can call fiber-blocking operations when using the `NewFiberScheduler` if the method is annotated with `@Suspendable`.
+(rx-core `Observer`s, `Function`s or `Action`s that manipulate, transform or delegate to other `Observer`s, `Function`s or `Action`s are automatically instrumented).
 
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index 072733982f..bdfed38b7c 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -17,17 +17,24 @@
 import co.paralleluniverse.fibers.SuspendExecution;
 import co.paralleluniverse.fibers.Suspendable;
 import co.paralleluniverse.strands.Strand;
+import co.paralleluniverse.strands.Timeout;
+import co.paralleluniverse.strands.channels.Channel;
+import co.paralleluniverse.strands.channels.Channels;
 import co.paralleluniverse.strands.channels.ReceivePort;
 import co.paralleluniverse.strands.channels.SendPort;
+import java.util.concurrent.TimeUnit;
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
+import rx.util.Exceptions;
 import rx.util.OnErrorNotImplementedException;
 
 /**
- *
+ * This class contains static methods that connect {@link Observable}s and {@link Channel}s.
  */
-public class ChannelObservable {
+public final class ChannelObservable {
+    private ChannelObservable() {
+    }
 
     /**
      * Converts an {@link Iterable} sequence into an Observable that emits each message received on the channel.
@@ -102,4 +109,152 @@ public void onError(Throwable e) {
             }
         };
     }
+
+    /**
+     * Creates a {@link ReceivePort} subscribed to an {@link Observable}.
+     * <p>
+     * @param <T>        the type of messages emitted by the observable and received on the channel.
+     * @param bufferSize the channel's buffer size
+     * @param policy     the channel's {@link Channels.OverflowPolicy OverflowPolicy}
+     * @param o          the observable
+     * @return A new channel with the given buffer size and overflow policy that will receive all events emitted by the observable.
+     */
+    public final static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o) {
+        final ChannelWithErrors<T> channel = new ChannelWithErrors<T>(Channels.newChannel(bufferSize, policy));
+
+        o.subscribe(new Observer<T>() {
+            @Override
+            @Suspendable
+            public void onNext(T t) {
+                try {
+                    channel.sendPort().send(t);
+                } catch (InterruptedException ex) {
+                    Strand.interrupted();
+                } catch (SuspendExecution ex) {
+                    throw new AssertionError(ex);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                channel.sendPort().close();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                channel.error(e);
+            }
+        });
+        return channel.receivePort();
+    }
+
+    /**
+     * Creates a {@link ReceivePort} subscribed to an {@link Observable}.
+     * <p>
+     * @param <T>        the type of messages emitted by the observable and received on the channel.
+     * @param bufferSize the channel's buffer size
+     * @param policy     the channel's {@link Channels.OverflowPolicy OverflowPolicy}
+     * @param o          the observable
+     * @param scheduler  the scheduler used to emit the observable's events
+     * @return A new channel with the given buffer size and overflow policy that will receive all events emitted by the observable.
+     */
+    public final static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o, Scheduler scheduler) {
+        final ChannelWithErrors<T> channel = new ChannelWithErrors<T>(Channels.newChannel(bufferSize, policy));
+
+        o.subscribe(new Observer<T>() {
+            @Override
+            @Suspendable
+            public void onNext(T t) {
+                try {
+                    channel.sendPort().send(t);
+                } catch (InterruptedException ex) {
+                    Strand.interrupted();
+                } catch (SuspendExecution ex) {
+                    throw new AssertionError(ex);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                channel.sendPort().close();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                channel.error(e);
+            }
+        }, scheduler);
+        return channel.receivePort();
+    }
+
+    private static class ChannelWithErrors<T> {
+        private final Channel<Object> ch;
+
+        public ChannelWithErrors(Channel<Object> ch) {
+            this.ch = ch;
+        }
+
+        @Suspendable
+        public void error(Throwable t) {
+            try {
+                ch.send(new ThrowableWrapper(t));
+                ch.close();
+            } catch (InterruptedException e) {
+            } catch (SuspendExecution e) {
+                throw new AssertionError(e);
+            }
+        }
+
+        public ReceivePort<T> receivePort() {
+            return new ReceivePort<T>() {
+                @Override
+                public T receive() throws SuspendExecution, InterruptedException {
+                    return get(ch.receive());
+                }
+
+                @Override
+                public T receive(long timeout, TimeUnit unit) throws SuspendExecution, InterruptedException {
+                    return get(ch.receive(timeout, unit));
+                }
+
+                @Override
+                public T receive(Timeout timeout) throws SuspendExecution, InterruptedException {
+                    return get(ch.receive(timeout));
+                }
+
+                @Override
+                public T tryReceive() {
+                    return get(ch.tryReceive());
+                }
+
+                @Override
+                public void close() {
+                    ch.close();
+                }
+
+                @Override
+                public boolean isClosed() {
+                    return ch.isClosed();
+                }
+            };
+        }
+
+        public SendPort<T> sendPort() {
+            return (SendPort<T>) ch;
+        }
+
+        private T get(Object m) {
+            if (m instanceof ThrowableWrapper)
+                throw Exceptions.propagate(((ThrowableWrapper) m).t);
+            return (T) m;
+        }
+
+        private static class ThrowableWrapper {
+            final Throwable t;
+
+            public ThrowableWrapper(Throwable t) {
+                this.t = t;
+            }
+        }
+    }
 }
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
index 77275213a1..9644828947 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
@@ -50,7 +50,7 @@ public void call(Subscriber<? super T> o) {
                 break;
             } catch (Exception e) {
                 o.onError(e);
-                continue;
+                return;
             }
 
             o.onNext(m);
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
index 290b476b46..e547d95ce6 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
@@ -1,2 +1,25 @@
-rx.util.functions.Action1.call
 rx.Observer.onNext
+rx.Observer.onError
+rx.Observer.onCompleted
+rx.util.functions.Action0.call
+rx.util.functions.Action1.call
+rx.util.functions.Action2.call
+rx.util.functions.Action3.call
+rx.util.functions.Action4.call
+rx.util.functions.Action5.call
+rx.util.functions.Action6.call
+rx.util.functions.Action7.call
+rx.util.functions.Action8.call
+rx.util.functions.Action9.call
+rx.util.functions.ActionN.call
+rx.util.functions.Func0.call
+rx.util.functions.Func1.call
+rx.util.functions.Func2.call
+rx.util.functions.Func3.call
+rx.util.functions.Func4.call
+rx.util.functions.Func5.call
+rx.util.functions.Func6.call
+rx.util.functions.Func7.call
+rx.util.functions.Func8.call
+rx.util.functions.Func9.call
+rx.util.functions.FuncN.call
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
index 7ce00d743a..9a93b3572f 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
@@ -1,2 +1,33 @@
+rx.Observer.onNext
+rx.Observer.onError
+rx.Observer.onCompleted
 rx.Observable.subscribe
-rx.observers.SafeSubscriber.onNext
+rx.util.functions.Actions.Actions$1.call
+rx.util.functions.Actions.Actions$2.call
+rx.util.functions.Actions.Actions$3.call
+rx.util.functions.Actions.Actions$4.call
+rx.util.functions.Actions.Actions$5.call
+rx.util.functions.Actions.Actions$6.call
+rx.util.functions.Actions.Actions$7.call
+rx.util.functions.Actions.Actions$8.call
+rx.util.functions.Actions.Actions$9.call
+rx.util.functions.Actions.Actions$10.call
+rx.util.functions.Actions.Actions$11.call
+rx.util.functions.Actions.Actions$12.call
+rx.util.functions.Actions.Actions$13.call
+rx.util.functions.Actions.Actions$14.call
+rx.util.functions.Actions.Functions$1.call
+rx.util.functions.Actions.Functions$2.call
+rx.util.functions.Actions.Functions$3.call
+rx.util.functions.Actions.Functions$4.call
+rx.util.functions.Actions.Functions$5.call
+rx.util.functions.Actions.Functions$6.call
+rx.util.functions.Actions.Functions$7.call
+rx.util.functions.Actions.Functions$8.call
+rx.util.functions.Actions.Functions$9.call
+rx.util.functions.Actions.Functions$10.call
+rx.util.functions.Actions.Functions$11.call
+rx.util.functions.Actions.Functions$12.call
+rx.util.functions.Actions.Functions$13.call
+rx.util.functions.Actions.Functions$14.call
+rx.util.functions.Actions.Functions$15.call
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
index c7af56da2d..d2d2f11065 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
@@ -20,6 +20,7 @@
 import co.paralleluniverse.strands.Strand;
 import co.paralleluniverse.strands.channels.Channel;
 import co.paralleluniverse.strands.channels.Channels;
+import co.paralleluniverse.strands.channels.ReceivePort;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Queue;
@@ -30,6 +31,7 @@
 import org.junit.Test;
 import rx.Observable;
 import rx.Observer;
+import rx.subjects.PublishSubject;
 
 public class ChannelObservableTest {
     @Test
@@ -91,4 +93,37 @@ public void testObserverChannel() throws Exception {
         assertThat(c.receive(), equalTo("c"));
         assertThat(c.receive(), is(nullValue()));
     }
+
+    @Test
+    public void testObserverChannel2() throws Exception {
+        ReceivePort<String> c = ChannelObservable.subscribe(10, Channels.OverflowPolicy.BLOCK, Observable.from(Arrays.asList("a", "b", "c")));
+
+        assertThat(c.receive(), equalTo("a"));
+        assertThat(c.receive(), equalTo("b"));
+        assertThat(c.receive(), equalTo("c"));
+        assertThat(c.receive(), is(nullValue()));
+    }
+
+    @Test
+    public void testObserverChannelWithError() throws Exception {
+        PublishSubject<String> o = PublishSubject.create();
+        ReceivePort<String> c = ChannelObservable.subscribe(10, Channels.OverflowPolicy.BLOCK, o);
+
+        o.onNext("a");
+        o.onError(new MyException());
+        o.onNext("c");
+        
+        assertThat(c.receive(), equalTo("a"));
+        try {
+            c.receive();
+            fail();
+        } catch(MyException e) {
+            
+        }
+        assertThat(c.receive(), is(nullValue()));
+    }
+    
+    static class MyException extends RuntimeException {
+        
+    }
 }

From a2ac4aa8058455ed47626c430e94bef9fa32263d Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Tue, 11 Feb 2014 16:43:38 +0200
Subject: [PATCH 004/422] Use a custom SuspendableClassifier

---
 .../java/rx/quasar/ChannelObservable.java     | 48 ++++-------
 .../rx/quasar/RxSuspendableClassifier.java    | 79 +++++++++++++++++++
 ...se.fibers.instrument.SuspendableClassifier |  1 +
 .../src/main/resources/META-INF/suspendables  | 32 --------
 4 files changed, 94 insertions(+), 66 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/services/co.paralleluniverse.fibers.instrument.SuspendableClassifier

diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index bdfed38b7c..605eb04dc8 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -28,6 +28,10 @@
 import rx.Scheduler;
 import rx.util.Exceptions;
 import rx.util.OnErrorNotImplementedException;
+import rx.util.functions.Action2;
+import rx.util.functions.Actions;
+import rx.util.functions.Func1;
+import rx.util.functions.Functions;
 
 /**
  * This class contains static methods that connect {@link Observable}s and {@link Channel}s.
@@ -122,45 +126,21 @@ public void onError(Throwable e) {
     public final static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o) {
         final ChannelWithErrors<T> channel = new ChannelWithErrors<T>(Channels.newChannel(bufferSize, policy));
 
-        o.subscribe(new Observer<T>() {
-            @Override
-            @Suspendable
-            public void onNext(T t) {
-                try {
-                    channel.sendPort().send(t);
-                } catch (InterruptedException ex) {
-                    Strand.interrupted();
-                } catch (SuspendExecution ex) {
-                    throw new AssertionError(ex);
-                }
-            }
+        System.out.println(Functions.fromFunc(new Func1<String, String>() {
 
             @Override
-            public void onCompleted() {
-                channel.sendPort().close();
+            public String call(String t1) {
+                throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
             }
+        }));
+        System.out.println(Actions.toFunc(new Action2<String, String>() {
 
             @Override
-            public void onError(Throwable e) {
-                channel.error(e);
+            public void call(String t1, String t2) {
+                throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
             }
-        });
-        return channel.receivePort();
-    }
-
-    /**
-     * Creates a {@link ReceivePort} subscribed to an {@link Observable}.
-     * <p>
-     * @param <T>        the type of messages emitted by the observable and received on the channel.
-     * @param bufferSize the channel's buffer size
-     * @param policy     the channel's {@link Channels.OverflowPolicy OverflowPolicy}
-     * @param o          the observable
-     * @param scheduler  the scheduler used to emit the observable's events
-     * @return A new channel with the given buffer size and overflow policy that will receive all events emitted by the observable.
-     */
-    public final static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o, Scheduler scheduler) {
-        final ChannelWithErrors<T> channel = new ChannelWithErrors<T>(Channels.newChannel(bufferSize, policy));
-
+        }));
+        
         o.subscribe(new Observer<T>() {
             @Override
             @Suspendable
@@ -183,7 +163,7 @@ public void onCompleted() {
             public void onError(Throwable e) {
                 channel.error(e);
             }
-        }, scheduler);
+        });
         return channel.receivePort();
     }
 
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
new file mode 100644
index 0000000000..8a985cbfdb
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
@@ -0,0 +1,79 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in 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.quasar;
+
+import co.paralleluniverse.fibers.instrument.MethodDatabase;
+import co.paralleluniverse.fibers.instrument.SimpleSuspendableClassifier;
+import co.paralleluniverse.fibers.instrument.SuspendableClassifier;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class RxSuspendableClassifier implements SuspendableClassifier {
+    private static final Set<String> CORE_PACKAGES = new HashSet<String>(Arrays.asList(new String[]{
+        "rx", "rx.joins", "rx.observables", "rx.observers", "rx.operators", "rx.plugins", "rx.schedulers",
+        "rx.subjects", "rx.subscriptions", "rx.util", "rx.util.functions"
+    }));
+
+    private static final Set<String> EXCEPTIONS = new HashSet<String>(Arrays.asList(new String[]{
+        "rx/observers/SynchronizedObserver",
+        "rx/schedulers/AbstractSchedulerTests$ConcurrentObserverValidator",}));
+
+    private static final Set<String> OBSERVER_METHODS = new HashSet<String>(Arrays.asList(new String[]{
+        "onNext(Ljava/lang/Object;)V", "onCompleted()V", "onError(Ljava/lang/Throwable;)V"
+    }));
+
+    private static final String FUNCTION_METHOD = "call";
+
+    @Override
+    public MethodDatabase.SuspendableType isSuspendable(MethodDatabase db, String className, String superClassName, String[] interfaces, String methodName, String methodDesc, String methodSignature, String[] methodExceptions) {
+        MethodDatabase.SuspendableType s = null;
+        if (isCoreRx(className) && !EXCEPTIONS.contains(className)) {
+            if (isObserverImplementation(db, className, superClassName, interfaces, methodName, methodDesc))
+                s = MethodDatabase.SuspendableType.SUSPENDABLE;
+            else if (isUtilFunction(db, className, superClassName, interfaces, methodName, methodDesc))
+                s = MethodDatabase.SuspendableType.SUSPENDABLE;
+        }
+        // System.out.println("-- " + className + "." + methodName + ": " + s);
+        return s;
+    }
+
+    private boolean isCoreRx(String className) {
+        return CORE_PACKAGES.contains(packageOf(className));
+    }
+
+    private static boolean isObserverImplementation(MethodDatabase db, String className, String superClassName, String[] interfaces, String methodName, String methodDesc) {
+        return !className.equals("rx/Observer")
+                && OBSERVER_METHODS.contains(methodName + methodDesc)
+                && SimpleSuspendableClassifier.extendsOrImplements("rx/Observer", db, className, superClassName, interfaces);
+    }
+
+    private static boolean isUtilFunction(MethodDatabase db, String className, String superClassName, String[] interfaces, String methodName, String methodDesc) {
+        return (className.startsWith("rx/util/functions/Functions") || className.startsWith("rx/util/functions/Actions"))
+                && methodName.equals(FUNCTION_METHOD)
+                && (SimpleSuspendableClassifier.extendsOrImplements("rx/util/functions/Function", db, className, superClassName, interfaces)
+                || SimpleSuspendableClassifier.extendsOrImplements("rx/util/functions/Action", db, className, superClassName, interfaces));
+    }
+
+    private static String packageOf(String className) {
+        try {
+            return className.substring(0, className.lastIndexOf('/')).replace('/', '.');
+        } catch (RuntimeException e) {
+            System.err.println("???? " + className);
+            throw e;
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/services/co.paralleluniverse.fibers.instrument.SuspendableClassifier b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/services/co.paralleluniverse.fibers.instrument.SuspendableClassifier
new file mode 100644
index 0000000000..72a1acf3c9
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/services/co.paralleluniverse.fibers.instrument.SuspendableClassifier
@@ -0,0 +1 @@
+rx.quasar.RxSuspendableClassifier
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
index 9a93b3572f..d364ba2406 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
@@ -1,33 +1 @@
-rx.Observer.onNext
-rx.Observer.onError
-rx.Observer.onCompleted
 rx.Observable.subscribe
-rx.util.functions.Actions.Actions$1.call
-rx.util.functions.Actions.Actions$2.call
-rx.util.functions.Actions.Actions$3.call
-rx.util.functions.Actions.Actions$4.call
-rx.util.functions.Actions.Actions$5.call
-rx.util.functions.Actions.Actions$6.call
-rx.util.functions.Actions.Actions$7.call
-rx.util.functions.Actions.Actions$8.call
-rx.util.functions.Actions.Actions$9.call
-rx.util.functions.Actions.Actions$10.call
-rx.util.functions.Actions.Actions$11.call
-rx.util.functions.Actions.Actions$12.call
-rx.util.functions.Actions.Actions$13.call
-rx.util.functions.Actions.Actions$14.call
-rx.util.functions.Actions.Functions$1.call
-rx.util.functions.Actions.Functions$2.call
-rx.util.functions.Actions.Functions$3.call
-rx.util.functions.Actions.Functions$4.call
-rx.util.functions.Actions.Functions$5.call
-rx.util.functions.Actions.Functions$6.call
-rx.util.functions.Actions.Functions$7.call
-rx.util.functions.Actions.Functions$8.call
-rx.util.functions.Actions.Functions$9.call
-rx.util.functions.Actions.Functions$10.call
-rx.util.functions.Actions.Functions$11.call
-rx.util.functions.Actions.Functions$12.call
-rx.util.functions.Actions.Functions$13.call
-rx.util.functions.Actions.Functions$14.call
-rx.util.functions.Actions.Functions$15.call

From f4ea0737c846a0a441eb2dbab27b6d69a099d064 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Wed, 12 Feb 2014 13:51:07 +0200
Subject: [PATCH 005/422] minor fix in classifier

---
 .../src/main/java/rx/quasar/RxSuspendableClassifier.java   | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
index 8a985cbfdb..14b24f294d 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
@@ -69,11 +69,6 @@ private static boolean isUtilFunction(MethodDatabase db, String className, Strin
     }
 
     private static String packageOf(String className) {
-        try {
-            return className.substring(0, className.lastIndexOf('/')).replace('/', '.');
-        } catch (RuntimeException e) {
-            System.err.println("???? " + className);
-            throw e;
-        }
+        return className.substring(0, Math.max(0, className.lastIndexOf('/'))).replace('/', '.');
     }
 }

From 53fb292f3a6130c91e320ee5721f6affee0cd460 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Mon, 17 Feb 2014 19:48:38 +0200
Subject: [PATCH 006/422] map Observable.onError(Throwable) to
 SendPort.close(Throwable) in

---
 .../java/rx/quasar/ChannelObservable.java     | 87 ++-----------------
 .../java/rx/quasar/ChannelObservableTest.java |  7 +-
 2 files changed, 10 insertions(+), 84 deletions(-)

diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index 605eb04dc8..67d09dde4a 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -17,17 +17,13 @@
 import co.paralleluniverse.fibers.SuspendExecution;
 import co.paralleluniverse.fibers.Suspendable;
 import co.paralleluniverse.strands.Strand;
-import co.paralleluniverse.strands.Timeout;
 import co.paralleluniverse.strands.channels.Channel;
 import co.paralleluniverse.strands.channels.Channels;
 import co.paralleluniverse.strands.channels.ReceivePort;
 import co.paralleluniverse.strands.channels.SendPort;
-import java.util.concurrent.TimeUnit;
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
-import rx.util.Exceptions;
-import rx.util.OnErrorNotImplementedException;
 import rx.util.functions.Action2;
 import rx.util.functions.Actions;
 import rx.util.functions.Func1;
@@ -109,7 +105,7 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                throw new OnErrorNotImplementedException(e);
+                channel.close(e);
             }
         };
     }
@@ -124,7 +120,7 @@ public void onError(Throwable e) {
      * @return A new channel with the given buffer size and overflow policy that will receive all events emitted by the observable.
      */
     public final static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o) {
-        final ChannelWithErrors<T> channel = new ChannelWithErrors<T>(Channels.newChannel(bufferSize, policy));
+        final Channel<T> channel = Channels.newChannel(bufferSize, policy);
 
         System.out.println(Functions.fromFunc(new Func1<String, String>() {
 
@@ -146,7 +142,7 @@ public void call(String t1, String t2) {
             @Suspendable
             public void onNext(T t) {
                 try {
-                    channel.sendPort().send(t);
+                    channel.send(t);
                 } catch (InterruptedException ex) {
                     Strand.interrupted();
                 } catch (SuspendExecution ex) {
@@ -156,85 +152,14 @@ public void onNext(T t) {
 
             @Override
             public void onCompleted() {
-                channel.sendPort().close();
+                channel.close();
             }
 
             @Override
             public void onError(Throwable e) {
-                channel.error(e);
+                channel.close(e);
             }
         });
-        return channel.receivePort();
-    }
-
-    private static class ChannelWithErrors<T> {
-        private final Channel<Object> ch;
-
-        public ChannelWithErrors(Channel<Object> ch) {
-            this.ch = ch;
-        }
-
-        @Suspendable
-        public void error(Throwable t) {
-            try {
-                ch.send(new ThrowableWrapper(t));
-                ch.close();
-            } catch (InterruptedException e) {
-            } catch (SuspendExecution e) {
-                throw new AssertionError(e);
-            }
-        }
-
-        public ReceivePort<T> receivePort() {
-            return new ReceivePort<T>() {
-                @Override
-                public T receive() throws SuspendExecution, InterruptedException {
-                    return get(ch.receive());
-                }
-
-                @Override
-                public T receive(long timeout, TimeUnit unit) throws SuspendExecution, InterruptedException {
-                    return get(ch.receive(timeout, unit));
-                }
-
-                @Override
-                public T receive(Timeout timeout) throws SuspendExecution, InterruptedException {
-                    return get(ch.receive(timeout));
-                }
-
-                @Override
-                public T tryReceive() {
-                    return get(ch.tryReceive());
-                }
-
-                @Override
-                public void close() {
-                    ch.close();
-                }
-
-                @Override
-                public boolean isClosed() {
-                    return ch.isClosed();
-                }
-            };
-        }
-
-        public SendPort<T> sendPort() {
-            return (SendPort<T>) ch;
-        }
-
-        private T get(Object m) {
-            if (m instanceof ThrowableWrapper)
-                throw Exceptions.propagate(((ThrowableWrapper) m).t);
-            return (T) m;
-        }
-
-        private static class ThrowableWrapper {
-            final Throwable t;
-
-            public ThrowableWrapper(Throwable t) {
-                this.t = t;
-            }
-        }
+        return channel;
     }
 }
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
index d2d2f11065..cce90923de 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
@@ -20,6 +20,7 @@
 import co.paralleluniverse.strands.Strand;
 import co.paralleluniverse.strands.channels.Channel;
 import co.paralleluniverse.strands.channels.Channels;
+import co.paralleluniverse.strands.channels.ProducerException;
 import co.paralleluniverse.strands.channels.ReceivePort;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -117,10 +118,10 @@ public void testObserverChannelWithError() throws Exception {
         try {
             c.receive();
             fail();
-        } catch(MyException e) {
-            
+        } catch(ProducerException e) {
+            assertThat(e.getCause(), instanceOf(MyException.class));
         }
-        assertThat(c.receive(), is(nullValue()));
+        assertThat(c.isClosed(), is(true));
     }
     
     static class MyException extends RuntimeException {

From 43719c7dfd29922dd45a007923405958aa540f2d Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Mon, 17 Feb 2014 20:08:01 +0200
Subject: [PATCH 007/422] -

---
 .../java/rx/quasar/ChannelObservable.java     | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index 67d09dde4a..45bcaa01c6 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -24,10 +24,6 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
-import rx.util.functions.Action2;
-import rx.util.functions.Actions;
-import rx.util.functions.Func1;
-import rx.util.functions.Functions;
 
 /**
  * This class contains static methods that connect {@link Observable}s and {@link Channel}s.
@@ -121,21 +117,6 @@ public void onError(Throwable e) {
      */
     public final static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o) {
         final Channel<T> channel = Channels.newChannel(bufferSize, policy);
-
-        System.out.println(Functions.fromFunc(new Func1<String, String>() {
-
-            @Override
-            public String call(String t1) {
-                throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-            }
-        }));
-        System.out.println(Actions.toFunc(new Action2<String, String>() {
-
-            @Override
-            public void call(String t1, String t2) {
-                throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-            }
-        }));
         
         o.subscribe(new Observer<T>() {
             @Override

From 6bece88c6941a754a8cc054bbe9946f1e7c0c615 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Thu, 20 Feb 2014 20:08:46 +0200
Subject: [PATCH 008/422] Added ChannelObservable.get

---
 .../java/rx/quasar/ChannelObservable.java     | 82 ++++++++++++++++--
 .../java/rx/quasar/ChannelObservableTest.java | 84 ++++++++++++++++++-
 2 files changed, 157 insertions(+), 9 deletions(-)

diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index 45bcaa01c6..97e9af950b 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -14,6 +14,7 @@
  * limitations under the License.
  */package rx.quasar;
 
+import co.paralleluniverse.fibers.FiberAsync;
 import co.paralleluniverse.fibers.SuspendExecution;
 import co.paralleluniverse.fibers.Suspendable;
 import co.paralleluniverse.strands.Strand;
@@ -21,6 +22,9 @@
 import co.paralleluniverse.strands.channels.Channels;
 import co.paralleluniverse.strands.channels.ReceivePort;
 import co.paralleluniverse.strands.channels.SendPort;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
@@ -45,7 +49,7 @@ private ChannelObservable() {
      * @return an Observable that emits each message received on the source {@link ReceivePort}
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      */
-    public final static <T> Observable<T> from(ReceivePort<T> channel) {
+    public static <T> Observable<T> from(ReceivePort<T> channel) {
         return Observable.create(new OnSubscribeFromChannel<T>(channel));
     }
 
@@ -67,7 +71,7 @@ public final static <T> Observable<T> from(ReceivePort<T> channel) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212140.aspx">MSDN: Observable.ToObservable</a>
      */
-    public final static <T> Observable<T> from(ReceivePort<T> channel, Scheduler scheduler) {
+    public static <T> Observable<T> from(ReceivePort<T> channel, Scheduler scheduler) {
         return Observable.create(new OnSubscribeFromChannel<T>(channel)).subscribeOn(scheduler);
     }
 
@@ -79,7 +83,7 @@ public final static <T> Observable<T> from(ReceivePort<T> channel, Scheduler sch
      * @param channel the target {@link SendPort}
      * @return
      */
-    public final static <T> Observer<T> to(final SendPort<T> channel) {
+    public static <T> Observer<T> to(final SendPort<T> channel) {
         return new Observer<T>() {
 
             @Override
@@ -115,9 +119,9 @@ public void onError(Throwable e) {
      * @param o          the observable
      * @return A new channel with the given buffer size and overflow policy that will receive all events emitted by the observable.
      */
-    public final static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o) {
+    public static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o) {
         final Channel<T> channel = Channels.newChannel(bufferSize, policy);
-        
+
         o.subscribe(new Observer<T>() {
             @Override
             @Suspendable
@@ -143,4 +147,72 @@ public void onError(Throwable e) {
         });
         return channel;
     }
+
+    /**
+     * Takes an observable that generates <i>at most one value</i>, blocks until it completes and returns the result.
+     * If the observable completes before a value has been emitted, this method returns {@code null}.
+     * It the observable fails, this function throws an {@link ExecutionException} that wraps the observable's exception.
+     *
+     * @param o the observable
+     * @return the observable's result, or {@code null} if the observable completes before a value is emitted.
+     * @throws ExecutionException if the observable fails
+     */
+    public static <T> T get(final Observable<T> o) throws ExecutionException, SuspendExecution, InterruptedException {
+        return new AsyncObservable<T>(o).run();
+    }
+
+    /**
+     * Takes an observable that generates <i>at most one value</i>, blocks until it completes or the timeout expires, and returns the result.
+     * If the observable completes before a value has been emitted, this method returns {@code null}.
+     * It the observable fails, this function throws an {@link ExecutionException} that wraps the observable's exception.
+     *
+     * @param o       the observable
+     * @param timeout the maximum time this method will blcok
+     * @param unit    the timeout's time unit
+     * @return the observable's result, or {@code null} if the observable completes before a value is emitted.
+     * @throws ExecutionException if the observable fails
+     * @throws TimeoutException   if the timeout expires before the observable completes
+     */
+    public static <T> T get(final Observable<T> o, long timeout, TimeUnit unit) throws ExecutionException, SuspendExecution, InterruptedException, TimeoutException {
+        return new AsyncObservable<T>(o).run(timeout, unit);
+    }
+
+    private static class AsyncObservable<T> extends FiberAsync<T, Void, ExecutionException> implements Observer<T> {
+        private final Observable<T> o;
+
+        public AsyncObservable(Observable<T> o) {
+            this.o = o;
+        }
+
+        @Override
+        protected Void requestAsync() {
+            o.subscribe(this);
+            return null;
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (isCompleted())
+                throw new IllegalStateException("Operation already completed");
+            asyncCompleted(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (isCompleted())
+                throw new IllegalStateException("Operation already completed");
+            asyncFailed(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (!isCompleted())
+                asyncCompleted(null);
+        }
+
+        @Override
+        protected ExecutionException wrapException(Throwable t) {
+            return new ExecutionException(t);
+        }
+    }
 }
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
index cce90923de..63ef447af3 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
@@ -15,9 +15,11 @@
  */
 package rx.quasar;
 
+import co.paralleluniverse.fibers.Fiber;
 import co.paralleluniverse.fibers.SuspendExecution;
 import co.paralleluniverse.fibers.Suspendable;
 import co.paralleluniverse.strands.Strand;
+import co.paralleluniverse.strands.SuspendableCallable;
 import co.paralleluniverse.strands.channels.Channel;
 import co.paralleluniverse.strands.channels.Channels;
 import co.paralleluniverse.strands.channels.ProducerException;
@@ -26,6 +28,7 @@
 import java.util.Arrays;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
@@ -113,18 +116,91 @@ public void testObserverChannelWithError() throws Exception {
         o.onNext("a");
         o.onError(new MyException());
         o.onNext("c");
-        
+
         assertThat(c.receive(), equalTo("a"));
         try {
             c.receive();
             fail();
-        } catch(ProducerException e) {
+        } catch (ProducerException e) {
             assertThat(e.getCause(), instanceOf(MyException.class));
         }
         assertThat(c.isClosed(), is(true));
     }
-    
+
+    @Test
+    public void whenGetThenBlockAndReturnResult() throws Exception {
+        final PublishSubject<String> o = PublishSubject.create();
+
+        Fiber<String> f = new Fiber<String>(new SuspendableCallable<String>() {
+
+            @Override
+            public String run() throws SuspendExecution, InterruptedException {
+                try {
+                    return ChannelObservable.get(o);
+                } catch (ExecutionException e) {
+                    throw new AssertionError();
+                }
+            }
+        }).start();
+
+        Thread.sleep(100);
+
+        o.onNext("foo");
+        o.onCompleted();
+
+        assertThat(f.get(), equalTo("foo"));
+    }
+
+    @Test
+    public void whenGetAndObservableFailsThenThrowExecutionException() throws Exception {
+        final PublishSubject<String> o = PublishSubject.create();
+
+        Fiber<String> f = new Fiber<String>(new SuspendableCallable<String>() {
+
+            @Override
+            public String run() throws SuspendExecution, InterruptedException {
+                try {
+                    return ChannelObservable.get(o);
+                } catch (ExecutionException e) {
+                    return e.getCause().getMessage();
+                }
+            }
+        }).start();
+
+        Thread.sleep(100);
+
+        o.onError(new Exception("ohoh"));
+
+        assertThat(f.get(), equalTo("ohoh"));
+    }
+
+    @Test
+    public void whenGetAndObservableEmitsTwoValuesThenBlowup() throws Exception {
+        final PublishSubject<String> o = PublishSubject.create();
+
+        Fiber<String> f = new Fiber<String>(new SuspendableCallable<String>() {
+
+            @Override
+            public String run() throws SuspendExecution, InterruptedException {
+                try {
+                    return ChannelObservable.get(o);
+                } catch (ExecutionException e) {
+                    throw new AssertionError();
+                }
+            }
+        }).start();
+
+        Thread.sleep(100);
+
+        o.onNext("foo");
+        try {
+            o.onNext("bar");
+            fail();
+        } catch (Exception e) {
+        }
+    }
+
     static class MyException extends RuntimeException {
-        
+
     }
 }

From a1f7c029b0bd2e0b6883eff481fc7a74eb014d58 Mon Sep 17 00:00:00 2001
From: Samuel Gruetter <samuel.gruetter@epfl.ch>
Date: Fri, 21 Feb 2014 18:59:42 +0100
Subject: [PATCH 009/422] Observable.sample(Observable) in Scala

---
 .../src/main/scala/rx/lang/scala/Observable.scala | 15 +++++++++++++++
 1 file changed, 15 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 9243ec3e6c..f120d72900 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
@@ -1132,6 +1132,21 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.sample(duration.length, duration.unit, scheduler))
   }
 
+  /**
+   * Return an Observable that emits the results of sampling the items emitted by the source Observable
+   * whenever the specified sampler Observable emits an item or completes.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.o.png">
+   *
+   * @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
+   */
+  def sample(sampler: Observable[Any]): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.sample(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

From 045d4f9d22f234bfdac4912a90dde79054ccc4f1 Mon Sep 17 00:00:00 2001
From: Samuel Gruetter <samuel.gruetter@epfl.ch>
Date: Fri, 21 Feb 2014 19:00:14 +0100
Subject: [PATCH 010/422] tweak RxScalaDemo (and Olympics example)

---
 .../rx/lang/scala/examples/Olympics.scala     | 28 +++++++++++++----
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 30 +++++++++++--------
 2 files changed, 39 insertions(+), 19 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 e91de4b51d..dba0019cdb 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
@@ -22,6 +22,7 @@ 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.items(
+    duration(100 millis), // a short delay because medals are only awarded some time after the Games began
     Observable.items(
       Medal(1996, "Atlanta 1996", "cross-country men", "Gold", "Bart BRENTJENS", "Netherlands"),
       Medal(1996, "Atlanta 1996", "cross-country women", "Gold", "Paola PEZZO", "Italy"),
@@ -69,18 +70,33 @@ object Olympics {
   ).concat
 
   // speed it up :D
-  val fourYears = 4000.millis
+  val oneYear = 1000.millis
 
-  val neverUsedDummyMedal = Medal(3333, "?", "?", "?", "?", "?")
+  //val neverUsedDummyMedal = Medal(3333, "?", "?", "?", "?", "?")
 
-  def fourYearsEmpty: Observable[Medal] = {
+  /** runs an infinite loop, and returns Bottom type (Nothing) */
+  def getNothing: Nothing = {
+    println("You shouldn't have called this method ;-)")
+    getNothing
+  }
+  
+  /** returns an Observable which emits no elements and completes after a duration of d */
+  def duration(d: Duration): Observable[Nothing] = Observable.interval(d).take(1).filter(_ => false).map(_ => getNothing)
+  
+  def fourYearsEmpty: Observable[Medal] = duration(4*oneYear)
+
+  def yearTicks: Observable[Int] = 
+    (Observable.from(1996 to 2014) zip (Observable.items(-1) ++ Observable.interval(oneYear))).map(_._1)
+  
+  /*
+  def fourYearsEmptyOld: Observable[Medal] = {
     // TODO this should return an observable which emits nothing during fourYears and then completes
     // Because of https://github.com/Netflix/RxJava/issues/388, we get non-terminating tests
     // And this https://github.com/Netflix/RxJava/pull/289#issuecomment-24738668 also causes problems
     // So we don't use this:
-    // Observable.interval(fourYears).take(1).map(i => neverUsedDummyMedal).filter(m => false)
+    Observable.interval(fourYears).take(1).map(i => neverUsedDummyMedal).filter(m => false)
     // But we just return empty, which completes immediately
-    Observable.empty
-  }
+    // Observable.empty
+  }*/
 
 }
\ 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 6b6faf4f7d..c75ad9ea57 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
@@ -32,7 +32,7 @@ import org.scalatest.junit.JUnitSuite
 import rx.lang.scala._
 import rx.lang.scala.schedulers._
 
-@Ignore // Since this doesn't do automatic testing, don't increase build time unnecessarily
+//@Ignore // Since this doesn't do automatic testing, don't increase build time unnecessarily
 class RxScalaDemo extends JUnitSuite {
 
   @Test def intervalExample() {
@@ -78,13 +78,9 @@ class RxScalaDemo extends JUnitSuite {
     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)
+    val b = (first zip second) forall { case (a, b) => a == b }
 
-    val equality = (a: Any, b: Any) => a == b
-    val b2 = (first zip second) map (p => equality(p._1, p._2)) forall (b => b)
-
-    assertTrue(b1.toBlockingObservable.single)
-    assertTrue(b2.toBlockingObservable.single)
+    assertTrue(b.toBlockingObservable.single)
   }
 
   @Test def testObservableComparisonWithForComprehension() {
@@ -93,7 +89,7 @@ class RxScalaDemo extends JUnitSuite {
 
     val booleans = for ((n1, n2) <- (first zip second)) yield (n1 == n2)
 
-    val b1 = booleans.forall(_ == true) // without `== true`, b1 is assigned the forall function
+    val b1 = booleans.forall(identity)
 
     assertTrue(b1.toBlockingObservable.single)
   }
@@ -216,7 +212,6 @@ class RxScalaDemo extends JUnitSuite {
     }).flatten.toBlockingObservable.foreach(println(_))
   }
 
-  @Ignore // TODO something's bad here
   @Test def timingTest1() {
     val numbersByModulo3 = Observable.interval(1000 millis).take(9).groupBy(_ % 3)
 
@@ -224,10 +219,14 @@ class RxScalaDemo extends JUnitSuite {
 
     (for ((modulo, numbers) <- numbersByModulo3) yield {
       println("Observable for modulo" + modulo + " started at t = " + (System.currentTimeMillis - t0))
-      numbers.take(1) // <- TODO very unexpected
-      //numbers
+      numbers.map(n => s"${n} is in the modulo-$modulo group")
     }).flatten.toBlockingObservable.foreach(println(_))
   }
+  
+  @Test def testOlympicYearTicks() {
+    Olympics.yearTicks.subscribe(println(_))
+    waitFor(Olympics.yearTicks)
+  }
 
   @Test def groupByExample() {
     val medalsByCountry = Olympics.mountainBikeMedals.groupBy(medal => medal.country)
@@ -238,8 +237,10 @@ class RxScalaDemo extends JUnitSuite {
     firstMedalOfEachCountry.subscribe(medal => {
       println(s"${medal.country} wins its first medal in ${medal.year}")
     })
+    
+    Olympics.yearTicks.subscribe(year => println(s"\nYear $year starts."))
 
-    waitFor(firstMedalOfEachCountry)
+    waitFor(Olympics.yearTicks)
   }
 
   @Test def groupByUntilExample() {
@@ -469,7 +470,10 @@ class RxScalaDemo extends JUnitSuite {
 
   def output(s: String): Unit = println(s)
 
-  // blocks until obs has completed
+  /** Subscribes to obs and waits until obs has completed. Note that if you subscribe to
+   *  obs yourself and also call waitFor(obs), all side-effects of subscribing to obs
+   *  will happen twice.
+   */
   def waitFor[T](obs: Observable[T]): Unit = {
     obs.toBlockingObservable.toIterable.last
   }

From 54adc1ed1a31549219412b7d4cee133b84239252 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 21 Feb 2014 14:09:51 -0800
Subject: [PATCH 011/422] Operator: doOnTerminate

Like finallyDo but before emitting the terminal state instead of after.
---
 rxjava-core/src/main/java/rx/Observable.java | 39 ++++++++++++++++++--
 1 file changed, 36 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2224fa3c8e..dc47e9175f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4293,17 +4293,17 @@ public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNot
         Observer<T> observer = new Observer<T>() {
             @Override
             public final void onCompleted() {
-                onNotification.call(new Notification<T>());
+                onNotification.call(Notification.createOnCompleted());
             }
 
             @Override
             public final void onError(Throwable e) {
-                onNotification.call(new Notification<T>(e));
+                onNotification.call(Notification.createOnError(e));
             }
 
             @Override
             public final void onNext(T v) {
-                onNotification.call(new Notification<T>(v));
+                onNotification.call(Notification.createOnNext(v));
             }
 
         };
@@ -4387,6 +4387,39 @@ public final void onNext(T args) {
 
         return lift(new OperatorDoOnEach<T>(observer));
     }
+    
+    /**
+     * Modifies an Observable so that it invokes an action when it calls {@code onCompleted} or {@code onError} <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnCompleted.png">
+     * <p>
+     * This differs from {@code finallyDo} in that this happens BEFORE onCompleted/onError are emitted.
+     * 
+     * @param onTerminate
+     *            the action to invoke when the source Observable calls {@code onCompleted} or {@code onError}
+     * @return the source Observable with the side-effecting behavior applied
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooncompleted">RxJava Wiki: doOnCompleted()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
+     */
+    public final Observable<T> doOnTerminate(final Action0 onTerminate) {
+        Observer<T> observer = new Observer<T>() {
+            @Override
+            public final void onCompleted() {
+                onTerminate.call();
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                onTerminate.call();
+            }
+
+            @Override
+            public final void onNext(T args) {
+            }
+
+        };
+
+        return lift(new OperatorDoOnEach<T>(observer));
+    }
 
     /**
      * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a

From c7f7d5787dcff1019ba9e411b1353a9be2f1faf2 Mon Sep 17 00:00:00 2001
From: Todd Nine <tnine@apigee.com>
Date: Wed, 12 Feb 2014 20:33:37 -0700
Subject: [PATCH 012/422] Added additional test to prove issue

---
 rxjava-core/src/test/java/rx/ZipTests.java | 27 ++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/ZipTests.java b/rxjava-core/src/test/java/rx/ZipTests.java
index 97928a5092..262f7dcb74 100644
--- a/rxjava-core/src/test/java/rx/ZipTests.java
+++ b/rxjava-core/src/test/java/rx/ZipTests.java
@@ -15,6 +15,10 @@
  */
 package rx;
 
+import static org.junit.Assert.*;
+
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -31,6 +35,7 @@
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.functions.Func2;
+import rx.functions.FuncN;
 import rx.observables.GroupedObservable;
 
 public class ZipTests {
@@ -91,6 +96,28 @@ public void testCovarianceOfZip() {
         Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine);
     }
 
+    /**
+     * Occasionally zip may be invoked with 0 observables. This blocks indefinitely instead
+     * of immediately invoking zip with 0 argument.
+     */
+    @Test(timeout = 5000)
+    public void nonBlockingObservable() {
+
+        final Object invoked = new Object();
+
+        Collection<Observable<Object>> observables = Collections.emptyList();
+
+        Observable<Object> result = Observable.zip(observables, new FuncN<Object>() {
+            @Override
+            public Object call(final Object... args) {
+                assertEquals("No argument should have been passed", 0, args.length);
+                return invoked;
+            }
+        });
+
+        assertSame(invoked, result.toBlockingObservable().last());
+    }
+
     Func2<Media, Rating, ExtendedResult> combine = new Func2<Media, Rating, ExtendedResult>() {
         @Override
         public ExtendedResult call(Media m, Rating r) {

From 243bd3a68b1e478ffa38b603c2b5d18845772860 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 21 Feb 2014 14:30:10 -0800
Subject: [PATCH 013/422] BugFix: Zip with 0 Observables

Fixes bug reported at https://github.com/Netflix/RxJava/pull/868
---
 .../main/java/rx/operators/OperatorZip.java   | 14 +++-
 rxjava-core/src/test/java/rx/ZipTests.java    |  7 +-
 .../java/rx/operators/OperatorZipTest.java    | 68 +++++++++++++++++++
 3 files changed, 85 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index f211e42815..21da75d417 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -106,9 +106,14 @@ public OperatorZip(Func9 f) {
     public Subscriber<? super Observable[]> call(final Subscriber<? super R> observer) {
         return new Subscriber<Observable[]>(observer) {
 
+            boolean started = false;
+
             @Override
             public void onCompleted() {
-                // we only complete once a child Observable completes or errors
+                if (!started) {
+                    // this means we have not received a valid onNext before termination so we emit the onCompleted
+                    observer.onCompleted();
+                }
             }
 
             @Override
@@ -118,7 +123,12 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(Observable[] observables) {
-                new Zip<R>(observables, observer, zipFunction).zip();
+                if (observables == null || observables.length == 0) {
+                    observer.onCompleted();
+                } else {
+                    started = true;
+                    new Zip<R>(observables, observer, zipFunction).zip();
+                }
             }
 
         };
diff --git a/rxjava-core/src/test/java/rx/ZipTests.java b/rxjava-core/src/test/java/rx/ZipTests.java
index 262f7dcb74..8735cb2e66 100644
--- a/rxjava-core/src/test/java/rx/ZipTests.java
+++ b/rxjava-core/src/test/java/rx/ZipTests.java
@@ -97,10 +97,12 @@ public void testCovarianceOfZip() {
     }
 
     /**
-     * Occasionally zip may be invoked with 0 observables. This blocks indefinitely instead
+     * Occasionally zip may be invoked with 0 observables. Test that we don't block indefinitely instead
      * of immediately invoking zip with 0 argument.
+     * 
+     * We now expect an IllegalArgumentException since last() requires at least one value and nothing will be emitted.
      */
-    @Test(timeout = 5000)
+    @Test(expected = IllegalArgumentException.class)
     public void nonBlockingObservable() {
 
         final Object invoked = new Object();
@@ -110,6 +112,7 @@ public void nonBlockingObservable() {
         Observable<Object> result = Observable.zip(observables, new FuncN<Object>() {
             @Override
             public Object call(final Object... args) {
+                System.out.println("received: " + args);
                 assertEquals("No argument should have been passed", 0, args.length);
                 return invoked;
             }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
index e96c8b84b0..7862c9f49a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -22,6 +22,7 @@
 import java.util.ArrayList;
 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.TimeUnit;
@@ -42,6 +43,7 @@
 import rx.functions.Func3;
 import rx.functions.FuncN;
 import rx.functions.Functions;
+import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 
@@ -986,6 +988,72 @@ public void call(String s) {
         assertEquals("OnCompleted_null-OnCompleted_null", list.get(3));
     }
 
+    @Test
+    public void testZipEmptyObservables() {
+
+        Observable<String> o = Observable.zip(Observable.<Integer> empty(), Observable.<String> empty(), new Func2<Integer, String, String>() {
+
+            @Override
+            public String call(Integer t1, String t2) {
+                return t1 + "-" + t2;
+            }
+
+        });
+
+        final ArrayList<String> list = new ArrayList<String>();
+        o.subscribe(new Action1<String>() {
+
+            @Override
+            public void call(String s) {
+                System.out.println(s);
+                list.add(s);
+            }
+        });
+
+        assertEquals(0, list.size());
+    }
+
+    @Test
+    public void testZipEmptyList() {
+
+        final Object invoked = new Object();
+        Collection<Observable<Object>> observables = Collections.emptyList();
+
+        Observable<Object> o = Observable.zip(observables, new FuncN<Object>() {
+            @Override
+            public Object call(final Object... args) {
+                assertEquals("No argument should have been passed", 0, args.length);
+                return invoked;
+            }
+        });
+
+        TestSubscriber<Object> ts = new TestSubscriber<Object>();
+        o.subscribe(ts);
+        ts.awaitTerminalEvent(200, TimeUnit.MILLISECONDS);
+        ts.assertReceivedOnNext(Collections.emptyList());
+    }
+
+    /**
+     * Expect IllegalArgumentException instead of blocking forever as zip should emit onCompleted and no onNext
+     * and last() expects at least a single response.
+     */
+    @Test(expected = IllegalArgumentException.class)
+    public void testZipEmptyListBlocking() {
+
+        final Object invoked = new Object();
+        Collection<Observable<Object>> observables = Collections.emptyList();
+
+        Observable<Object> o = Observable.zip(observables, new FuncN<Object>() {
+            @Override
+            public Object call(final Object... args) {
+                assertEquals("No argument should have been passed", 0, args.length);
+                return invoked;
+            }
+        });
+
+        o.toBlockingObservable().last();
+    }
+
     Observable<Integer> OBSERVABLE_OF_5_INTEGERS = OBSERVABLE_OF_5_INTEGERS(new AtomicInteger());
 
     Observable<Integer> OBSERVABLE_OF_5_INTEGERS(final AtomicInteger numEmitted) {

From afc4da1aaee94fb724271dfce3fb2e0ee98a31c0 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 21 Feb 2014 14:48:06 -0800
Subject: [PATCH 014/422] Delete Deprecated onSubscribeStart That Doesn't Work

- It's messy to make this work so deleting it instead.
- Better to move forward in the 0.17 release than try and make this work for the very small percentage (probably only Netflix) that uses it.
---
 .../main/java/rx/plugins/RxJavaObservableExecutionHook.java | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 5668a1b416..01e6c97507 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -49,12 +49,6 @@ public abstract class RxJavaObservableExecutionHook {
      *            original {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}> to be executed
      * @return {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}> function that can be modified, decorated, replaced or just returned as a pass-thru.
      */
-    @Deprecated
-    public <T> OnSubscribeFunc<T> onSubscribeStart(Observable<? extends T> observableInstance, OnSubscribeFunc<T> onSubscribe) {
-        // pass-thru by default
-        return onSubscribe;
-    }
-
     public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> onSubscribe) {
         // pass-thru by default
         return onSubscribe;

From 7162d8bff019f1473537a0d3b8a9b7b4240109bf Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Fri, 21 Feb 2014 23:00:11 +0000
Subject: [PATCH 015/422] [Gradle Release Plugin] - pre tag commit: 
 '0.17.0-RC4'.

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

diff --git a/gradle.properties b/gradle.properties
index 80d3fa81f1..91a402ea6d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC4-SNAPSHOT
+version=0.17.0-RC4

From 3a1c5f51cf645a4c4134e19e3d178935482a3284 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Fri, 21 Feb 2014 23:00:15 +0000
Subject: [PATCH 016/422] [Gradle Release Plugin] - new version commit: 
 '0.17.0-RC5-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index 91a402ea6d..2f793be8d8 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC4
+version=0.17.0-RC5-SNAPSHOT

From 747f97ed6fd67d25ee22600475d71ca74bf289a6 Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Fri, 21 Feb 2014 16:58:51 -0800
Subject: [PATCH 017/422] customize diagram/javadocs for doOnTerminate()

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index dc47e9175f..2226e6c798 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4389,15 +4389,16 @@ public final void onNext(T args) {
     }
     
     /**
-     * Modifies an Observable so that it invokes an action when it calls {@code onCompleted} or {@code onError} <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnCompleted.png">
+     * Modifies an Observable so that it invokes an action when it calls {@code onCompleted} or {@code onError}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnTerminate.png">
      * <p>
      * This differs from {@code finallyDo} in that this happens BEFORE onCompleted/onError are emitted.
      * 
      * @param onTerminate
      *            the action to invoke when the source Observable calls {@code onCompleted} or {@code onError}
      * @return the source Observable with the side-effecting behavior applied
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooncompleted">RxJava Wiki: doOnCompleted()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-doonterminate">RxJava Wiki: doOnTerminate()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
      */
     public final Observable<T> doOnTerminate(final Action0 onTerminate) {

From ed983eef3fc2c82509404c03770f2948b73fee41 Mon Sep 17 00:00:00 2001
From: Samuel Gruetter <samuel.gruetter@epfl.ch>
Date: Mon, 24 Feb 2014 10:31:50 +0100
Subject: [PATCH 018/422] some RxScalaDemo tweaks

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 48 +++++++++++--------
 1 file changed, 27 insertions(+), 21 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 c75ad9ea57..21ea16ee0f 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
@@ -32,7 +32,16 @@ import org.scalatest.junit.JUnitSuite
 import rx.lang.scala._
 import rx.lang.scala.schedulers._
 
-//@Ignore // Since this doesn't do automatic testing, don't increase build time unnecessarily
+/**
+ * Demo how the different operators can be used. In Eclipse, you can right-click
+ * a test and choose "Run As" > "Scala JUnit Test".
+ * 
+ * For each operator added to Observable.java, we add a little usage demo here.
+ * It does not need to test the functionality (that's already done by the tests in
+ * RxJava core), but it should demonstrate how it can be used, to make sure that
+ * the method signature makes sense.
+ */
+@Ignore // Since this doesn't do automatic testing, don't increase build time unnecessarily
 class RxScalaDemo extends JUnitSuite {
 
   @Test def intervalExample() {
@@ -251,30 +260,36 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def combineLatestExample() {
-    val first_counter = Observable.interval(250 millis)
-    val second_counter = Observable.interval(550 millis)
-    val combined_counter = first_counter.combineLatest(second_counter,
+    val firstCounter = Observable.interval(250 millis)
+    val secondCounter = Observable.interval(550 millis)
+    val combinedCounter = firstCounter.combineLatest(secondCounter,
       (x: Long, y: Long) => List(x,y)) take 10
 
-    combined_counter subscribe {x => println(s"Emitted group: $x")}
+    combinedCounter subscribe {x => println(s"Emitted group: $x")}
+    waitFor(combinedCounter)
   }
 
+  @Test def olympicsExampleWithoutPublish() {
+    val medals = Olympics.mountainBikeMedals.doOnEach(_ => println("onNext"))
+    medals.subscribe(println(_)) // triggers an execution of medals Observable
+    waitFor(medals) // triggers another execution of medals Observable
+  }
 
-  @Test def olympicsExample() {
-    val medals = Olympics.mountainBikeMedals.publish
-    medals.subscribe(println(_))
+  @Test def olympicsExampleWithPublish() {
+    val medals = Olympics.mountainBikeMedals.doOnEach(_ => println("onNext")).publish
+    medals.subscribe(println(_)) // triggers an execution of medals Observable
     medals.connect
-    //waitFor(medals)
+    waitFor(medals) // triggers another execution of medals Observable
   }
 
   @Test def exampleWithoutPublish() {
-    val unshared = List(1 to 4).toObservable
+    val unshared = Observable.from(1 to 4)
     unshared.subscribe(n => println(s"subscriber 1 gets $n"))
     unshared.subscribe(n => println(s"subscriber 2 gets $n"))
   }
 
   @Test def exampleWithPublish() {
-    val unshared = List(1 to 4).toObservable
+    val unshared = Observable.from(1 to 4)
     val shared = unshared.publish
     shared.subscribe(n => println(s"subscriber 1 gets $n"))
     shared.subscribe(n => println(s"subscriber 2 gets $n"))
@@ -403,7 +418,7 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def timestampExample() {
-    val timestamped = Observable.interval(100 millis).take(3).timestamp.toBlockingObservable
+    val timestamped = Observable.interval(100 millis).take(6).timestamp.toBlockingObservable
     for ((millis, value) <- timestamped if value > 0) {
       println(value + " at t = " + millis)
     }
@@ -442,15 +457,6 @@ class RxScalaDemo extends JUnitSuite {
     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)
-  }
-
-  @Test def elementAtOrDefaultReplacement() {
-    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

From 4258d776b0bceabef67285a8c48ca527ddf61514 Mon Sep 17 00:00:00 2001
From: George Campbell <gscampbell@netflix.com>
Date: Tue, 11 Feb 2014 21:44:26 -0800
Subject: [PATCH 019/422] Changes made while integrating it with our internal
 system

---
 .../java/rx/operators/DebugSubscriber.java    |  53 ++++++---
 .../java/rx/operators/DebugSubscription.java  |  25 ++++-
 .../src/main/java/rx/plugins/DebugHook.java   |  57 +++++++---
 .../java/rx/plugins/DebugNotification.java    | 102 ++++++++++--------
 .../src/test/java/rx/debug/DebugHookTest.java |  74 +++++++++----
 5 files changed, 211 insertions(+), 100 deletions(-)

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 276e245e74..f75c6b5662 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
@@ -4,47 +4,72 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Action1;
+import rx.functions.Action2;
 import rx.functions.Func1;
 import rx.plugins.DebugNotification;
 
-public final class DebugSubscriber<T> extends Subscriber<T> {
+public final class DebugSubscriber<T, C> extends Subscriber<T> {
     private final Func1<T, T> onNextHook;
-    final Action1<DebugNotification> events;
-    final Observer<? super T> o;
-    Operator<? extends T, ?> from = null;
-    Operator<?, ? super T> to = null;
+    private final Func1<DebugNotification, C> start;
+    private final Action1<C> complete;
+    private final Action2<C, Throwable> error;
+    private final Observer<? super T> o;
+    private Operator<? extends T, ?> from = null;
+    private Operator<?, ? super T> to = null;
 
     public DebugSubscriber(
             Func1<T, T> onNextHook,
-            Action1<DebugNotification> _events,
+            Func1<DebugNotification, C> start,
+            Action1<C> complete,
+            Action2<C, Throwable> error,
             Subscriber<? super T> _o,
             Operator<? extends T, ?> _out,
             Operator<?, ? super T> _in) {
         super(_o);
-        this.events = _events;
+        this.start = start;
+        this.complete = complete;
+        this.error = error;
         this.o = _o;
         this.onNextHook = onNextHook;
         this.from = _out;
         this.to = _in;
-        this.add(new DebugSubscription<T>(this));
+        this.add(new DebugSubscription<T, C>(this, start, complete, error));
     }
 
     @Override
     public void onCompleted() {
-        events.call(DebugNotification.createOnCompleted(o, from, to));
-        o.onCompleted();
+        final DebugNotification<T, C> n = DebugNotification.createOnCompleted(o, from, to);
+        C context = start.call(n);
+        try {
+            o.onCompleted();
+            complete.call(context);
+        } catch (Throwable e) {
+            error.call(context, e);
+        }
     }
 
     @Override
     public void onError(Throwable e) {
-        events.call(DebugNotification.createOnError(o, from, e, to));
-        o.onError(e);
+        final DebugNotification<T, C> n = DebugNotification.createOnError(o, from, e, to);
+        C context = start.call(n);
+        try {
+            o.onError(e);
+            complete.call(context);
+        } catch (Throwable e2) {
+            error.call(context, e2);
+        }
     }
 
     @Override
     public void onNext(T t) {
-        events.call(DebugNotification.createOnNext(o, from, t, to));
-        o.onNext(onNextHook.call(t));
+        final DebugNotification<T, C> n = DebugNotification.createOnNext(o, from, t, to);
+        C context = start.call(n);
+        try {
+            o.onNext(onNextHook.call(t));
+            complete.call(context);
+        } catch (Throwable e) {
+            error.call(context, e);
+        }
     }
 
     public Operator<? extends T, ?> getFrom() {
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
index e82960d5fe..256fd8798a 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java
@@ -1,19 +1,34 @@
 package rx.operators;
 
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.functions.Action2;
+import rx.functions.Func1;
 import rx.plugins.DebugNotification;
 
-final class DebugSubscription<T> implements Subscription {
-    private final DebugSubscriber<T> debugObserver;
+final class DebugSubscription<T, C> implements Subscription {
+    private final DebugSubscriber<T, C> debugObserver;
+    private final Func1<DebugNotification, C> start;
+    private final Action1<C> complete;
+    private final Action2<C, Throwable> error;
 
-    DebugSubscription(DebugSubscriber<T> debugObserver) {
+    DebugSubscription(DebugSubscriber<T, C> debugObserver, Func1<DebugNotification, C> start, Action1<C> complete, Action2<C, Throwable> error) {
         this.debugObserver = debugObserver;
+        this.start = start;
+        this.complete = complete;
+        this.error = error;
     }
 
     @Override
     public void unsubscribe() {
-        debugObserver.events.call(DebugNotification.<T> createUnsubscribe(debugObserver.o, debugObserver.from, debugObserver.to));
-        debugObserver.unsubscribe();
+        final DebugNotification<T, C> n = DebugNotification.<T, C> createUnsubscribe(debugObserver.getActual(), debugObserver.getFrom(), debugObserver.getTo());
+        C context = start.call(n);
+        try {
+            debugObserver.unsubscribe();
+            complete.call(context);
+        } catch (Throwable e) {
+            error.call(context, e);
+        }
     }
 
     @Override
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 31d54d87ce..3e5d5eba9a 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
@@ -6,6 +6,7 @@
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
+import rx.functions.Action2;
 import rx.functions.Actions;
 import rx.functions.Func1;
 import rx.functions.Functions;
@@ -17,9 +18,11 @@
  * 
  * @author gscampbell
  */
-public class DebugHook extends RxJavaObservableExecutionHook {
+public class DebugHook<C> extends RxJavaObservableExecutionHook {
     private final Func1 onNextHook;
-    private final Action1<DebugNotification> events;
+    private final Func1<DebugNotification, C> start;
+    private final Action1<C> complete;
+    private final Action2<C, Throwable> error;
 
     /**
      * Creates a new instance of the DebugHook RxJava plug-in that can be passed into
@@ -31,18 +34,26 @@ public class DebugHook extends RxJavaObservableExecutionHook {
      * @param events
      *            This action is invoked as each notification is generated
      */
-    public DebugHook(Func1 onNextDataHook, Action1<DebugNotification> events) {
+    public DebugHook(Func1 onNextDataHook, Func1<DebugNotification, C> start, Action1<C> complete, Action2<C, Throwable> error) {
+        this.complete = complete;
+        this.error = error;
         this.onNextHook = onNextDataHook == null ? Functions.identity() : onNextDataHook;
-        this.events = events == null ? Actions.empty() : events;
+        this.start = (Func1<DebugNotification, C>) (start == null ? Actions.empty() : start);
     }
 
     @Override
-    public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> f) {
+    public <T> OnSubscribe<T> onSubscribeStart(final Observable<? extends T> observableInstance, final OnSubscribe<T> f) {
         return new OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> o) {
-                events.call(DebugNotification.createSubscribe(o, f));
-                f.call(wrapOutbound(null, o));
+                C context = start.call(DebugNotification.createSubscribe(o, observableInstance, f));
+                try {
+                    f.call(wrapOutbound(null, o));
+                    complete.call(context);
+                }
+                catch(Throwable e) {
+                    error.call(context, e);
+                }
             }
         };
     }
@@ -54,12 +65,7 @@ public <T> Subscription onSubscribeReturn(Observable<? extends T> observableInst
 
     @Override
     public <T> OnSubscribe<T> onCreate(final OnSubscribe<T> f) {
-        return new OnSubscribe<T>() {
-            @Override
-            public void call(Subscriber<? super T> o) {
-                f.call(wrapInbound(null, o));
-            }
-        };
+        return new OnCreateWrapper<T>(f);
     }
 
     @Override
@@ -81,19 +87,36 @@ public <T> Subscription onAdd(Subscriber<T> subscriber, Subscription s) {
     private <R> Subscriber<? super R> wrapOutbound(Operator<? extends R, ?> bind, Subscriber<? super R> o) {
         if (o instanceof DebugSubscriber) {
             if (bind != null)
-                ((DebugSubscriber<R>) o).setFrom(bind);
+                ((DebugSubscriber<R, C>) o).setFrom(bind);
             return o;
         }
-        return new DebugSubscriber<R>(onNextHook, events, o, bind, null);
+        return new DebugSubscriber<R, C>(onNextHook, start, complete, error, o, bind, null);
     }
 
     @SuppressWarnings("unchecked")
     private <T> Subscriber<? super T> wrapInbound(Operator<?, ? super T> bind, Subscriber<? super T> o) {
         if (o instanceof DebugSubscriber) {
             if (bind != null)
-                ((DebugSubscriber<T>) o).setTo(bind);
+                ((DebugSubscriber<T, C>) o).setTo(bind);
             return o;
         }
-        return new DebugSubscriber<T>(onNextHook, events, o, null, bind);
+        return new DebugSubscriber<T, C>(onNextHook, start, complete, error, o, null, bind);
+    }
+
+    public final class OnCreateWrapper<T> implements OnSubscribe<T> {
+        private final OnSubscribe<T> f;
+
+        private OnCreateWrapper(OnSubscribe<T> f) {
+            this.f = f;
+        }
+
+        @Override
+        public void call(Subscriber<? super T> o) {
+            f.call(wrapInbound(null, o));
+        }
+
+        public OnSubscribe<T> getActual() {
+            return f;
+        }
     }
 }
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 f4144fb2b0..f22d4e31ef 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
@@ -1,103 +1,119 @@
 package rx.plugins;
 
-import rx.Notification;
+import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
 import rx.Observer;
 import rx.observers.SafeSubscriber;
 import rx.operators.DebugSubscriber;
 
-public class DebugNotification<T> {
+public class DebugNotification<T, C> {
     public static enum Kind {
         OnNext, OnError, OnCompleted, Subscribe, Unsubscribe
     }
 
-    private final OnSubscribe<T> source;
+    private final Observable<? extends T> source;
+    private final OnSubscribe<T> sourceFunc;
     private final Operator<? extends T, ?> from;
     private final Kind kind;
-    private final Notification<T> notification;
     private final Operator<?, ? super T> to;
-    private final long nanoTime;
-    private final long threadId;
-    private Observer o;
+    private final Throwable throwable;
+    private final T value;
+    private final Observer observer;
 
-    public static <T> DebugNotification<T> createSubscribe(Observer<? super T> o, OnSubscribe<T> source) {
+    public static <T, C> DebugNotification<T, C> createSubscribe(Observer<? super T> o, Observable<? extends T> source, OnSubscribe<T> sourceFunc) {
         Operator<?, ? super T> to = null;
         Operator<? extends T, ?> from = null;
+        if (o instanceof SafeSubscriber) {
+            o = ((SafeSubscriber) o).getActual();
+        }
         if (o instanceof DebugSubscriber) {
-            to = ((DebugSubscriber<T>) o).getTo();
-            from = ((DebugSubscriber<T>) o).getFrom();
+            to = ((DebugSubscriber<T, C>) o).getTo();
+            from = ((DebugSubscriber<T, C>) o).getFrom();
             o = ((DebugSubscriber) o).getActual();
         }
-        return new DebugNotification<T>(o, from, Kind.Subscribe, null, to, source);
+        if (sourceFunc instanceof DebugHook.OnCreateWrapper) {
+            sourceFunc = ((DebugHook.OnCreateWrapper) sourceFunc).getActual();
+        }
+        return new DebugNotification<T, C>(o, from, Kind.Subscribe, null, null, to, source, sourceFunc);
     }
 
-    public static <T> DebugNotification<T> createOnNext(Observer<? super T> o, Operator<? extends T, ?> from, T t, Operator<?, ? super T> to) {
-        return new DebugNotification<T>(o, from, Kind.OnNext, Notification.createOnNext(t), to, null);
+    public static <T, C> DebugNotification<T, C> createOnNext(Observer<? super T> o, Operator<? extends T, ?> from, T t, Operator<?, ? super T> to) {
+        return new DebugNotification<T, C>(o, from, Kind.OnNext, t, null, to, null, null);
     }
 
-    public static <T> DebugNotification<T> createOnError(Observer<? super T> o, Operator<? extends T, ?> from, Throwable e, Operator<?, ? super T> to) {
-        return new DebugNotification<T>(o, from, Kind.OnError, Notification.<T> createOnError(e), to, null);
+    public static <T, C> DebugNotification<T, C> createOnError(Observer<? super T> o, Operator<? extends T, ?> from, Throwable e, Operator<?, ? super T> to) {
+        return new DebugNotification<T, C>(o, from, Kind.OnError, null, e, to, null, null);
     }
 
-    public static <T> DebugNotification<T> createOnCompleted(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
-        return new DebugNotification<T>(o, from, Kind.OnCompleted, Notification.<T> createOnCompleted(), to, null);
+    public static <T, C> DebugNotification<T, C> createOnCompleted(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
+        return new DebugNotification<T, C>(o, from, Kind.OnCompleted, null, null, to, null, null);
     }
 
-    public static <T> DebugNotification<T> createUnsubscribe(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
-        return new DebugNotification<T>(o, from, Kind.Unsubscribe, null, to, null);
+    public static <T, C> DebugNotification<T, C> createUnsubscribe(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
+        return new DebugNotification<T, C>(o, from, Kind.Unsubscribe, null, null, to, null, null);
     }
 
-    private DebugNotification(Observer o, Operator<? extends T, ?> from, Kind kind, Notification<T> notification, Operator<?, ? super T> to, OnSubscribe<T> source) {
-        this.o = (o instanceof SafeSubscriber) ? ((SafeSubscriber) o).getActual() : o;
+    private DebugNotification(Observer o, Operator<? extends T, ?> from, Kind kind, T value, Throwable throwable, Operator<?, ? super T> to, Observable<? extends T> source, OnSubscribe<T> sourceFunc) {
+        this.observer = (o instanceof SafeSubscriber) ? ((SafeSubscriber) o).getActual() : o;
         this.from = from;
         this.kind = kind;
-        this.notification = notification;
+        this.value = value;
+        this.throwable = throwable;
         this.to = to;
         this.source = source;
-        this.nanoTime = System.nanoTime();
-        this.threadId = Thread.currentThread().getId();
+        this.sourceFunc = sourceFunc;
+    }
+
+    public Observer getObserver() {
+        return observer;
     }
 
     public Operator<? extends T, ?> getFrom() {
         return from;
     }
 
-    public Notification<T> getNotification() {
-        return notification;
+    public T getValue() {
+        return value;
     }
 
-    public Operator<?, ? super T> getTo() {
-        return to;
+    public Throwable getThrowable() {
+        return throwable;
     }
 
-    public long getNanoTime() {
-        return nanoTime;
-    }
-
-    public long getThreadId() {
-        return threadId;
+    public Operator<?, ? super T> getTo() {
+        return to;
     }
 
     public Kind getKind() {
         return kind;
     }
+    
+    public Observable<? extends T> getSource() {
+        return source;
+    }
+    
+    public OnSubscribe<T> getSourceFunc() {
+        return sourceFunc;
+    }
 
     @Override
+    /**
+     * Does a very bad job of making JSON like string.
+     */
     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("\"observer\": \"").append(observer.getClass().getName()).append("@").append(Integer.toHexString(observer.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 (kind == Kind.OnNext)
+            // not json safe
+            s.append(", \"value\": \"").append(value).append("\"");
+        if (kind == Kind.OnError)
+            s.append(", \"exception\": \"").append(throwable.getMessage().replace("\\", "\\\\").replace("\"", "\\\"")).append("\"");
         if (source != null)
             s.append(", \"source\": \"").append(source.getClass().getName()).append("@").append(Integer.toHexString(source.hashCode())).append("\"");
+        if (sourceFunc != null)
+            s.append(", \"sourceFunc\": \"").append(sourceFunc.getClass().getName()).append("@").append(Integer.toHexString(sourceFunc.hashCode())).append("\"");
         if (from != null)
             s.append(", \"from\": \"").append(from.getClass().getName()).append("@").append(Integer.toHexString(from.hashCode())).append("\"");
         if (to != null)
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 92c6cdd0dd..ea69258259 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
@@ -11,14 +11,17 @@
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 
-import rx.Notification;
 import rx.Observable;
-import rx.Observer;
+import rx.Subscriber;
 import rx.functions.Action1;
+import rx.functions.Action2;
 import rx.functions.Func1;
 import rx.plugins.DebugHook;
 import rx.plugins.DebugNotification;
+import rx.plugins.DebugNotification.Kind;
 import rx.plugins.PlugReset;
 import rx.plugins.RxJavaPlugins;
 
@@ -32,25 +35,52 @@ public void reset() {
     @Test
     @Ignore
     public void testSimple() {
-        Action1<DebugNotification> events = mock(Action1.class);
-        final DebugHook hook = new DebugHook(null, events);
+        Func1 start = mock(Func1.class);
+        Action1 complete = mock(Action1.class);
+        Action2 error = mock(Action2.class);
+        final DebugHook hook = new DebugHook(null, start, complete, error);
         RxJavaPlugins.getInstance().registerObservableExecutionHook(hook);
         Observable.empty().subscribe();
-        verify(events, times(1)).call(subscribe());
-        verify(events, times(1)).call(onCompleted());
+        verify(start, times(1)).call(subscribe());
+        verify(start, times(1)).call(onCompleted());
+
+        verify(complete, times(2)).call(any());
+
+        verify(error, never()).call(any(), any());
     }
 
     @Test
     public void testOneOp() {
-        Action1<DebugNotification> events = mock(Action1.class);
-        final DebugHook hook = new DebugHook(null, events);
+        Func1<DebugNotification<Integer, Object>, Object> start = mock(Func1.class);
+        doAnswer(new Answer() {
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                Object context = new Object();
+                System.out.println("start: " + context.hashCode() + " " + invocation.getArguments()[0]);
+                return context;
+            }
+        }).when(start).call(any(DebugNotification.class));
+        Action1<Object> complete = mock(Action1.class);
+        doAnswer(new Answer() {
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                System.out.println("complete: " + invocation.getArguments()[0].hashCode());
+                return null;
+            }
+        }).when(complete).call(any());
+        Action2<Object, Throwable> error = mock(Action2.class);
+        doAnswer(new Answer() {
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                System.out.println("error: " + invocation.getArguments()[1].hashCode());
+                return null;
+            }
+        }).when(error).call(any(), any(Throwable.class));
+        final DebugHook hook = new DebugHook(null, start, complete, error);
         RxJavaPlugins.getInstance().registerObservableExecutionHook(hook);
         Observable.from(Arrays.asList(1, 3)).flatMap(new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer it) {
                 return Observable.from(Arrays.asList(it, it + 1));
             }
-        }).take(3).subscribe(new Observer<Integer>() {
+        }).take(3).subscribe(new Subscriber<Integer>() {
             @Override
             public void onCompleted() {
             }
@@ -63,23 +93,26 @@ public void onError(Throwable e) {
             public void onNext(Integer t) {
             }
         });
-        verify(events, atLeast(3)).call(subscribe());
-        verify(events, times(4)).call(onNext(1));
+        verify(start, atLeast(3)).call(subscribe());
+        verify(start, 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));
+        verify(start, times(3)).call(onNext(2));
+        verify(start, times(4)).call(onNext(3));
         // because the take unsubscribes
-        verify(events, never()).call(onNext(4));
+        verify(start, never()).call(onNext(4));
+
+        verify(complete, atLeast(14)).call(any());
+
+        verify(error, never()).call(any(), any(Throwable.class));
     }
 
-    private static <T> DebugNotification<T> onNext(final T value) {
-        return argThat(new BaseMatcher<DebugNotification<T>>() {
+    private static <T, C> DebugNotification<T, C> onNext(final T value) {
+        return argThat(new BaseMatcher<DebugNotification<T, C>>() {
             @Override
             public boolean matches(Object item) {
                 if (item instanceof DebugNotification) {
-                    DebugNotification<T> dn = (DebugNotification<T>) item;
-                    Notification<T> n = dn.getNotification();
-                    return n != null && n.hasValue() && n.getValue().equals(value);
+                    DebugNotification<T, C> dn = (DebugNotification<T, C>) item;
+                    return dn.getKind() == Kind.OnNext && dn.getValue().equals(value);
                 }
                 return false;
             }
@@ -115,8 +148,7 @@ private static DebugNotification onCompleted() {
             public boolean matches(Object item) {
                 if (item instanceof DebugNotification) {
                     DebugNotification dn = (DebugNotification) item;
-                    Notification n = dn.getNotification();
-                    return n != null && n.isOnCompleted();
+                    return dn.getKind() == Kind.OnCompleted;
                 }
                 return false;
             }

From f92eb0e45a4fa89e4f0c9dc7b115aa30fc6c7d58 Mon Sep 17 00:00:00 2001
From: Samuel Gruetter <samuel.gruetter@epfl.ch>
Date: Mon, 24 Feb 2014 21:15:04 +0100
Subject: [PATCH 020/422] add Subscriber and Observable creation from
 `Subscriber[T] => Unit`

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 38 ++++++++++++--
 .../scala/ImplicitFunctionConversions.scala   |  9 +++-
 .../scala/rx/lang/scala/JavaConversions.scala |  4 ++
 .../main/scala/rx/lang/scala/Observable.scala | 38 ++++++++++++--
 .../main/scala/rx/lang/scala/Observer.scala   | 36 ++++++++-----
 .../main/scala/rx/lang/scala/Subscriber.scala | 52 +++++++++++++++++++
 6 files changed, 153 insertions(+), 24 deletions(-)
 create mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.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 21ea16ee0f..e7c09e769c 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
@@ -463,15 +463,43 @@ class RxScalaDemo extends JUnitSuite {
     List("a", "b").toObservable.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1)
   }
   
-  @Test def createExample() {
+  def calculateElement(index: Int): String = {
+    println("omg I'm calculating so hard")
+    index match {
+      case 0 => "a"
+      case 1 => "b"
+      case _ => throw new IllegalArgumentException
+    }
+  }
+  
+  /**
+   * This is a bad way of using Observable.create, because even if the consumer unsubscribes,
+   * all elements are calculated.
+   */
+  @Test def createExampleBad() {
     val o = Observable.create[String](observer => {
-      // this is bad because you cannot unsubscribe!
-      observer.onNext("a")
-      observer.onNext("b")
+      observer.onNext(calculateElement(0))
+      observer.onNext(calculateElement(1))
       observer.onCompleted()
       Subscription {}
     })
-    o.subscribe(println(_))
+    o.take(1).subscribe(println(_))
+  }
+  
+  /**
+   * This is the good way of doing it: If the consumer unsubscribes, no more elements are 
+   * calculated.
+   */
+  @Test def createExampleGood() {
+    val o = Observable[String](subscriber => {
+      var i = 0
+      while (i < 2 && !subscriber.isUnsubscribed) {
+        subscriber.onNext(calculateElement(i))
+        i += 1
+      }
+      if (!subscriber.isUnsubscribed) subscriber.onCompleted()
+    })
+    o.take(1).subscribe(println(_))
   }
 
   def output(s: String): Unit = println(s)
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 3c6aa5c29a..423ab119c9 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
@@ -17,10 +17,8 @@ package rx.lang.scala
 
 import java.lang.Exception
 import java.{ lang => jlang }
-
 import scala.language.implicitConversions
 import scala.collection.Seq
-
 import rx.functions._
 import rx.lang.scala.JavaConversions._
 
@@ -56,6 +54,13 @@ object ImplicitFunctionConversions {
       }
     }
 
+  implicit def scalaAction1ToOnSubscribe[T](f: Subscriber[T] => Unit) =
+    new rx.Observable.OnSubscribe[T] {
+      def call(s: rx.Subscriber[_ >: T]): Unit = {
+        f(s)
+      }
+    }
+  
   implicit def scalaByNameParamToFunc0[B](param: => B): Func0[B] =
     new Func0[B] {
       def call(): B = param
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 d003842be4..9ebd7744d7 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,6 +32,10 @@ object JavaConversions {
   
   implicit def toScalaSubscription(s: rx.Subscription): Subscription = Subscription(s)
 
+  implicit def toJavaSubscriber[T](s: Subscriber[T]): rx.Subscriber[_ >: T] = s.asJavaSubscriber
+  
+  implicit def toScalaSubscriber[T](s: rx.Subscriber[_ >: T]): Subscriber[T] = Subscriber(s)
+  
   implicit def scalaSchedulerToJavaScheduler(s: Scheduler): rx.Scheduler = s.asJavaScheduler
   implicit def javaSchedulerToScalaScheduler(s: rx.Scheduler): Scheduler = Scheduler(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 f120d72900..1466afca3c 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
@@ -2272,9 +2272,6 @@ object Observable {
    * should invoke the Observer's [[rx.lang.scala.Observer.onNext onNext]], [[rx.lang.scala.Observer.onError onError]], and [[rx.lang.scala.Observer.onCompleted onCompleted]] methods
    * appropriately.
    *
-   * A well-formed Observable must invoke either the Observer's `onCompleted` method
-   * exactly once or its `onError` method exactly once.
-   *
    * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a>
    * for detailed information.
    *
@@ -2296,6 +2293,41 @@ object Observable {
     }))
   }
 
+  /*
+  Note: It's dangerous to have two overloads where one takes an `Observer[T] => Subscription`
+  function and the other takes a `Subscriber[T] => Unit` function, because expressions like
+  `o => Subscription{}` have both of these types.
+  So we call the old create method "create", and the new create method "apply".
+  Try it out yourself here:
+  def foo[T]: Unit = { 
+    val fMeant: Observer[T] => Subscription = o => Subscription{}
+    val fWrong: Subscriber[T] => Unit = o => Subscription{}
+  }
+  */
+
+  /**
+   * Returns an Observable that will execute the specified function when a someone subscribes to it.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/create.png">
+   *
+   * Write the function you pass so that it behaves as an Observable: It should invoke the
+   * Subscriber's `onNext`, `onError`, and `onCompleted` methods appropriately.
+   *
+   * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
+   * information.
+   *
+   * @tparam T
+   *            the type of the items that this Observable emits
+   * @param f
+   *            a function that accepts a `Subscriber[T]`, and invokes its `onNext`,
+   *            `onError`, and `onCompleted` methods as appropriate
+   * @return an Observable that, when someone subscribes to it, will execute the specified
+   *         function
+   */
+  def apply[T](f: Subscriber[T] => Unit): Observable[T] = {
+    toScalaObservable(rx.Observable.create(f))
+  }
+  
   /**
    * Returns an Observable that invokes an [[rx.lang.scala.Observer]]'s [[rx.lang.scala.Observer.onError onError]]
    * method when the Observer subscribes to it.
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 6e956dd1a1..e7e9ad5bf1 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
@@ -56,7 +56,7 @@ trait Observer[-T] {
 
 }
 
-object Observer {
+object Observer extends ObserverFactoryMethods[Observer] {
 
   /**
    * Scala calls XXX; Java receives XXX.
@@ -72,17 +72,25 @@ object Observer {
 
    }
 
-  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](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] {
-         override def onNext(value: T): Unit = n(value)
-         override def onError(error: Throwable): Unit = e(error)
-         override def onCompleted(): Unit = c()
-       })
+  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] {
+      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
+}
+
+
+private [scala] trait ObserverFactoryMethods[P[_] <: Observer[_]] {
+
+  def apply[T](onNext: T => Unit, onError: Throwable => Unit, onCompleted: () => Unit): P[T]
+  
+  def apply[T](                                                                ): P[T] = apply[T]((v:T)=>(), (e: Throwable)=>(), ()=>())
+  def apply[T](onNext: T=>Unit                                                 ): P[T] = apply[T](onNext,    (e: Throwable)=>(), ()=>())
+  def apply[T](onNext: T=>Unit, onError: Throwable=>Unit                       ): P[T] = apply[T](onNext,    onError,            ()=>())
+  def apply[T](onNext: T=>Unit,                           onCompleted: ()=>Unit): P[T] = apply[T](onNext,    (e: Throwable)=>(), onCompleted)    
+}
+
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
new file mode 100644
index 0000000000..9f7091123e
--- /dev/null
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
@@ -0,0 +1,52 @@
+package rx.lang.scala
+
+trait Subscriber[-T] extends Observer[T] with Subscription {
+
+  self =>
+  
+  private [scala] override val asJavaObserver: rx.Observer[_ >: T] = asJavaSubscriber
+  private [scala] override val asJavaSubscription: rx.Subscription = asJavaSubscriber
+  
+  private [scala] val asJavaSubscriber: rx.Subscriber[_ >: T] = new rx.Subscriber[T] {
+    def onNext(value: T): Unit = self.onNext(value)
+    def onError(error: Throwable): Unit = self.onError(error)
+    def onCompleted(): Unit = self.onCompleted()
+  }
+  
+  /**
+   * Used to register an unsubscribe callback.
+   */
+  final def add(s: Subscription): Unit = {
+    asJavaSubscriber.add(s.asJavaSubscription)
+  }
+
+  override final def unsubscribe(): Unit = {
+    asJavaSubscriber.unsubscribe()
+  }
+
+  override final def isUnsubscribed: Boolean = {
+    asJavaSubscriber.isUnsubscribed()
+  }
+
+}
+
+object Subscriber extends ObserverFactoryMethods[Subscriber] {
+
+  private[scala] def apply[T](subscriber: rx.Subscriber[T]): Subscriber[T] = new Subscriber[T] {
+    override val asJavaSubscriber = subscriber
+
+    override def onNext(value: T): Unit = asJavaSubscriber.onNext(value)
+    override def onError(error: Throwable): Unit = asJavaSubscriber.onError(error)
+    override def onCompleted(): Unit = asJavaSubscriber.onCompleted()
+  }
+
+  def apply[T](onNext: T => Unit, onError: Throwable => Unit, onCompleted: () => Unit): Subscriber[T] = {
+    val n = onNext; val e = onError; val c = onCompleted
+    // Java calls XXX; Scala receives XXX.
+    Subscriber(new rx.Subscriber[T] {
+      override def onNext(value: T): Unit = n(value)
+      override def onError(error: Throwable): Unit = e(error)
+      override def onCompleted(): Unit = c()
+    })
+  }
+}

From b7cfcba520de9824267ed43c6a895ff62aa4f75e Mon Sep 17 00:00:00 2001
From: Samuel Gruetter <samuel.gruetter@epfl.ch>
Date: Mon, 24 Feb 2014 23:42:36 +0100
Subject: [PATCH 021/422] deprecate
 rx.lang.scala.Observable.create[T](Observer[T]=>Subscription)

---
 .../rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala   | 1 +
 1 file changed, 1 insertion(+)

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 1466afca3c..6794770232 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
@@ -2285,6 +2285,7 @@ object Observable {
    * @return
    *         an Observable that, when an [[rx.lang.scala.Observer]] subscribes to it, will execute the given function.
    */
+  @deprecated("Use `apply[T](Subscriber[T] => Unit)` instead", "0.17.0")
   def create[T](func: Observer[T] => Subscription): Observable[T] = {
     toScalaObservable[T](rx.Observable.create(new OnSubscribeFunc[T] {
       def onSubscribe(t1: rx.Observer[_ >: T]): rx.Subscription = {

From f18e4d2d901695070a7876f6dc9f06a71629fa5c Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Mon, 24 Feb 2014 21:42:41 -0800
Subject: [PATCH 022/422] Localized Operator Error Handling

- use the lift function rather than try/catch in subscribe since this catches at the operator level rather than for an entire sequence
- unit tests with onErrorResumeNext demonstrating the use cases
---
 rxjava-core/src/main/java/rx/Observable.java  | 12 ++-
 .../java/rx/exceptions/OnErrorThrowable.java  |  8 ++
 .../java/rx/operators/OperatorMapTest.java    | 13 ++-
 ...ratorOnErrorResumeNextViaFunctionTest.java | 83 +++++++++++++++++++
 4 files changed, 111 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index dc47e9175f..d310f3cff7 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -266,7 +266,17 @@ public <R> Observable<R> lift(final Operator<? extends R, ? super T> lift) {
         return new Observable<R>(new OnSubscribe<R>() {
             @Override
             public void call(Subscriber<? super R> o) {
-                f.call(hook.onLift(lift).call(o));
+                try {
+                    f.call(hook.onLift(lift).call(o));
+                } catch (Throwable e) {
+                    // localized capture of errors rather than it skipping all operators 
+                    // and ending up in the try/catch of the subscribe method which then
+                    // prevents onErrorResumeNext and other similar approaches to error handling
+                    if (e instanceof OnErrorNotImplementedException) {
+                        throw (OnErrorNotImplementedException) e;
+                    }
+                    o.onError(e);
+                }
             }
         });
     }
diff --git a/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
index 7044dd37ca..bf255432ea 100644
--- a/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
+++ b/rxjava-core/src/main/java/rx/exceptions/OnErrorThrowable.java
@@ -59,6 +59,14 @@ public static OnErrorThrowable from(Throwable t) {
      * @return Throwable e passed in
      */
     public static Throwable addValueAsLastCause(Throwable e, Object value) {
+        Throwable lastCause = Exceptions.getFinalCause(e);
+        if (lastCause != null && lastCause instanceof OnNextValue) {
+            // purposefully using == for object reference check
+            if (((OnNextValue) lastCause).getValue() == value) {
+                // don't add another
+                return e;
+            }
+        }
         Exceptions.addCause(e, new OnNextValue(value));
         return e;
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
index 5cf5cfd1c3..fd091bdaef 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
@@ -29,6 +29,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.OnErrorNotImplementedException;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -171,7 +172,7 @@ public String call(String s) {
             public void call(Throwable t1) {
                 t1.printStackTrace();
             }
-            
+
         });
 
         m.subscribe(stringObserver);
@@ -255,7 +256,7 @@ public Integer call(Integer i) {
         }).toBlockingObservable().single();
     }
 
-    @Test(expected = RuntimeException.class)
+    @Test(expected = OnErrorNotImplementedException.class)
     public void verifyExceptionIsThrownIfThereIsNoExceptionHandler() {
 
         Observable.OnSubscribe<Object> creator = new Observable.OnSubscribe<Object>() {
@@ -273,7 +274,6 @@ public void call(Subscriber<? super Object> observer) {
 
             @Override
             public Observable<Object> call(Object object) {
-
                 return Observable.from(object);
             }
         };
@@ -299,7 +299,12 @@ public void call(Object object) {
             }
         };
 
-        Observable.create(creator).flatMap(manyMapper).map(mapper).subscribe(onNext);
+        try {
+            Observable.create(creator).flatMap(manyMapper).map(mapper).subscribe(onNext);
+        } catch (RuntimeException e) {
+            e.printStackTrace();
+            throw e;
+        }
     }
 
     private static Map<String, String> getMap(String prefix) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index b071d863d6..7c7d7207e9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -26,7 +26,9 @@
 import org.mockito.Mockito;
 
 import rx.Observable;
+import rx.Observable.Operator;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.observers.TestSubscriber;
@@ -143,6 +145,87 @@ public Observable<String> call(Throwable t1) {
         verify(observer, times(0)).onCompleted();
     }
 
+    /**
+     * Test that we receive the onError if an exception is thrown from an operator that
+     * does not have manual try/catch handling like map does.
+     */
+    @Test
+    public void testOnErrorResumeReceivesErrorFromPreviousNonProtectedOperator() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        Observable.from(1).lift(new Operator<String, Integer>() {
+
+            @Override
+            public Subscriber<? super Integer> call(Subscriber<? super String> t1) {
+                throw new RuntimeException("failed");
+            }
+
+        }).onErrorResumeNext(new Func1<Throwable, Observable<String>>() {
+
+            @Override
+            public Observable<String> call(Throwable t1) {
+                if (t1.getMessage().equals("failed")) {
+                    return Observable.from("success");
+                } else {
+                    return Observable.error(t1);
+                }
+            }
+
+        }).subscribe(ts);
+
+        ts.assertTerminalEvent();
+        System.out.println(ts.getOnNextEvents());
+        ts.assertReceivedOnNext(Arrays.asList("success"));
+    }
+
+    /**
+     * Test that we receive the onError if an exception is thrown from an operator that
+     * does not have manual try/catch handling like map does.
+     */
+    @Test
+    public void testOnErrorResumeReceivesErrorFromPreviousNonProtectedOperatorOnNext() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        Observable.from(1).lift(new Operator<String, Integer>() {
+
+            @Override
+            public Subscriber<? super Integer> call(Subscriber<? super String> t1) {
+                return new Subscriber<Integer>() {
+
+                    @Override
+                    public void onCompleted() {
+                        throw new RuntimeException("failed");
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        throw new RuntimeException("failed");
+                    }
+
+                    @Override
+                    public void onNext(Integer t) {
+                        throw new RuntimeException("failed");
+                    }
+
+                };
+            }
+
+        }).onErrorResumeNext(new Func1<Throwable, Observable<String>>() {
+
+            @Override
+            public Observable<String> call(Throwable t1) {
+                if (t1.getMessage().equals("failed")) {
+                    return Observable.from("success");
+                } else {
+                    return Observable.error(t1);
+                }
+            }
+
+        }).subscribe(ts);
+
+        ts.assertTerminalEvent();
+        System.out.println(ts.getOnNextEvents());
+        ts.assertReceivedOnNext(Arrays.asList("success"));
+    }
+
     private static class TestObservable implements Observable.OnSubscribeFunc<String> {
 
         final Subscription s;

From 1b13e56e0155d3bf79da76e178675cb72c24d800 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Tue, 18 Feb 2014 11:33:19 -0800
Subject: [PATCH 023/422] Initial import of indigena-rx

Imported code, fixed namespaces and adusted one test for changes since
0.14.1.
---
 .../src/main/clojure/rx/lang/clojure/base.clj |  75 +++
 .../main/clojure/rx/lang/clojure/blocking.clj |  57 ++
 .../main/clojure/rx/lang/clojure/chunk.clj    |  97 ++++
 .../src/main/clojure/rx/lang/clojure/core.clj | 544 ++++++++++++++++++
 .../main/clojure/rx/lang/clojure/future.clj   |  88 +++
 .../main/clojure/rx/lang/clojure/graph.clj    | 137 +++++
 .../main/clojure/rx/lang/clojure/realized.clj | 127 ++++
 .../clojure/rx/lang/clojure/base_test.clj     |  38 ++
 .../clojure/rx/lang/clojure/blocking_test.clj |  18 +
 .../clojure/rx/lang/clojure/chunk_test.clj    |  56 ++
 .../clojure/rx/lang/clojure/core_test.clj     | 351 +++++++++++
 .../clojure/rx/lang/clojure/future_test.clj   |  37 ++
 .../clojure/rx/lang/clojure/graph_test.clj    | 118 ++++
 .../clojure/rx/lang/clojure/realized_test.clj | 130 +++++
 14 files changed, 1873 insertions(+)
 create mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
 create mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/realized_test.clj

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj
new file mode 100644
index 0000000000..0d1c181062
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj
@@ -0,0 +1,75 @@
+(ns rx.lang.clojure.base
+  "Generic, low-level rx helpers."
+  (:refer-clojure :exclude [merge])
+  (:require [rx.lang.clojure.interop :as iop])
+  (:import [rx Observable Observer Subscription]
+           [rx.observables BlockingObservable]
+           [rx.subscriptions Subscriptions]))
+
+(def ^:private -ns- *ns*)
+(set! *warn-on-reflection* true)
+
+(defn wrap-on-completed
+  "Wrap handler with code that automaticaly calls rx.Observable.onCompleted."
+  [handler]
+  (fn [^Observer observer]
+    (handler observer)
+    (.onCompleted observer)))
+
+(defn wrap-on-error
+  "Wrap handler with code that automaticaly calls (on-error) if an exception is thrown"
+  [handler]
+  (fn [^Observer observer]
+    (try
+      (handler observer)
+      (catch Exception e
+        (.onError observer e)))))
+
+(defn ^Observable merge
+  "Observable.merge, renamed because merge means something else in Clojure
+
+  os is one of:
+
+    * An Iterable of Observables to merge
+    * An Observable<Observable<T>> to merge
+  "
+  [os]
+  (cond
+    (instance? Iterable os)
+      (Observable/merge (Observable/from ^Iterable os))
+    (instance? Observable os)
+      (Observable/merge ^Observable os)
+    :else
+      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
+
+(defn ^Observable merge-delay-error
+  "Observable.mergeDelayError, renamed because merge means something else in Clojure"
+  [os]
+  (cond
+    (instance? java.util.List os)
+      (Observable/mergeDelayError ^java.util.List os)
+    (instance? Observable os)
+      (Observable/mergeDelayError ^Observable os)
+    :else
+      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
+
+(defn ^Observable zip
+  "Observable.zip. You want map."
+  ([f ^Observable a ^Observable b] (Observable/zip a b (iop/fn* f)))
+  ([f ^Observable a ^Observable b ^Observable c] (Observable/zip a b c (iop/fn* f)))
+  ([f ^Observable a ^Observable b ^Observable c ^Observable d] (Observable/zip a b c d (iop/fn* f)))
+  ([f a b c d & more]
+    ; recurse on more and then pull everything together with 4 parameter version
+   (zip (fn [a b c more-value]
+          (apply f a b c more-value))
+        a
+        b
+        c
+        (apply zip vector d more))))
+
+(defmacro zip-let
+  [bindings & body]
+  (let [pairs  (clojure.core/partition 2 bindings)
+        names  (clojure.core/mapv clojure.core/first pairs)
+        values (clojure.core/map second pairs)]
+    `(zip (fn ~names ~@body) ~@values)))
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
new file mode 100644
index 0000000000..9455636b11
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
@@ -0,0 +1,57 @@
+(ns rx.lang.clojure.blocking
+  "Blocking operators and functions. These should never be used in
+  production code except at the end of an async chain to convert from
+  rx land back to sync land. For example, to produce a servlet response."
+  (:refer-clojure :exclude [first into])
+  (:require [rx.lang.clojure.core :as rx])
+  (:import [rx Observable]
+           [rx.observables BlockingObservable]))
+
+(def ^:private -ns- *ns*)
+(set! *warn-on-reflection* true)
+
+(defn ^BlockingObservable ->blocking
+  "Convert an Observable to a BlockingObservable"
+  [^Observable o]
+  (.toBlockingObservable o))
+
+(defn first
+  "*Blocks* and waits for the first value emitted by the given observable.
+
+  If an error is produced it is thrown.
+
+  See:
+    clojure.core/first
+    rx/first
+  "
+  [observable]
+  (let [result (clojure.core/promise)]
+    (rx/subscribe (->> observable (rx/take 1))
+                #(clojure.core/deliver result [:value %])
+                #(clojure.core/deliver result [:error %])
+                #(clojure.core/deliver result nil))
+    (if-let [[type v] @result]
+      (case type
+        :value v
+        :error (throw v)))))
+
+(defn single
+  "*Blocks* and waits for the first value emitted by the given observable.
+
+   An error is thrown if more then one value is produced.
+  "
+  [observable]
+  (.single (->blocking observable)))
+
+(defn into
+  "*Blocks* and pours the elements emitted by the given observables into
+  to.
+
+  If an error is produced it is thrown.
+
+  See:
+    clojure.core/into
+    rx/into
+  "
+  [to from-observable]
+  (first (rx/into to from-observable)))
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
new file mode 100644
index 0000000000..d44c26f2c2
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
@@ -0,0 +1,97 @@
+(ns rx.lang.clojure.chunk
+  (:refer-clojure :exclude [chunk])
+  (:require [rx.lang.clojure.core :as rx]
+            [rx.lang.clojure.base :as rx-base]))
+
+(def ^:private -ns- *ns*)
+(set! *warn-on-reflection* true)
+
+(defn chunk
+  "Same as rx.Observable.merge(Observable<Observable<T>>) but the input Observables
+  are \"chunked\" so that at most chunk-size of them are \"in flight\" at any given
+  time.
+
+  The order of the input Observables is not preserved.
+
+  The main purpose here is to allow a large number of Hystrix observables to
+  be processed in a controlled way so that the Hystrix execution queues aren't
+  overwhelmed.
+
+  Example:
+
+    (->> users
+         (map #(-> (GetUserCommand. %) .toObservable))
+         (chunk 10))
+
+  See:
+    http://netflix.github.io/RxJava/javadoc/rx/Observable.html#merge(rx.Observable)
+    http://netflix.github.io/RxJava/javadoc/rx/Observable.html#mergeDelayError(rx.Observable)
+  "
+  ([chunk-size observable-source] (chunk chunk-size {} observable-source))
+  ([chunk-size options observable-source]
+  (let [new-state-atom #(atom {:in-flight #{}     ; observables currently in-flight
+                               :buffered  []      ; observables waiting to be emitted
+                               :complete  false   ; true if observable-source is complete
+                               :observer  % })    ; the observer
+        ps   #(do (printf "%s/%d/%d%n"
+                          (:complete %)
+                          (-> % :buffered count)
+                          (-> % :in-flight count))
+                (flush))
+
+        ; Given the current state, returns [action new-state]. action is the
+        ; next Observable or Throwable to emit, or :complete if we're done.
+        next-state (fn [{:keys [complete buffered in-flight] :as old}]
+                     (cond
+                       (empty? buffered)                [complete old]
+
+                       (< (count in-flight) chunk-size) (let [next-o (first buffered)]
+                                                          [next-o
+                                                           (-> old
+                                                               (update-in [:buffered] next)
+                                                               (update-in [:in-flight] conj next-o))])
+
+                       :else                            [nil old]))
+
+        ; Advance the state, performing side-effects as necessary
+        advance! (fn advance! [state-atom]
+                   (let [old-state        @state-atom
+                         [action new-state] (next-state old-state)]
+                     (if (compare-and-set! state-atom old-state new-state)
+                       (let [observer (:observer new-state)]
+                         (if (:debug options) (ps new-state))
+                         (cond
+                          (= :complete action)
+                            (rx/on-completed observer)
+
+                          (instance? Throwable action)
+                            (rx/on-error observer action)
+
+                          (instance? rx.Observable action)
+                            (rx/on-next observer
+                                        (.finallyDo ^rx.Observable action
+                                                    (reify rx.util.functions.Action0
+                                                              (call [this]
+                                                                (swap! state-atom update-in [:in-flight] disj action)
+                                                                (advance! state-atom)))))))
+                       (recur state-atom))))
+
+        subscribe (fn [state-atom]
+                    (rx/subscribe observable-source
+                                  (fn [o]
+                                    (swap! state-atom update-in [:buffered] conj o)
+                                    (advance! state-atom))
+
+                                  (fn [e]
+                                    (swap! state-atom assoc :complete e)
+                                    (advance! state-atom))
+
+                                  (fn []
+                                    (swap! state-atom assoc :complete :complete)
+                                    (advance! state-atom))))
+        observable (rx/fn->o (fn [observer]
+                               (subscribe (new-state-atom observer)))) ]
+    (if (:delay-error? options)
+      (rx.Observable/mergeDelayError observable)
+      (rx.Observable/merge observable)))))
+
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
new file mode 100644
index 0000000000..e807882e4c
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -0,0 +1,544 @@
+(ns rx.lang.clojure.core
+  (:refer-clojure :exclude [concat cons do drop drop-while empty
+                            filter future
+                            interpose into keep keep-indexed
+                            map mapcat map-indexed
+                            merge next partition reduce reductions
+                            rest seq some sort sort-by split-with
+                            take take-while throw])
+  (:require [rx.lang.clojure.interop :as iop]
+            [rx.lang.clojure.base :as base]
+            [rx.lang.clojure.graph :as graph]
+            [rx.lang.clojure.realized :as realized])
+  (:import [rx Observable Observer Subscription]
+           [rx.observables BlockingObservable]
+           [rx.subscriptions Subscriptions]
+           [rx.util.functions Action0 Action1 Func0 Func1 Func2]))
+
+(set! *warn-on-reflection* true)
+
+(declare map map-indexed reduce take take-while)
+
+(defn ^Func1 fn->predicate
+  "Turn f into a predicate that returns true/false like Rx predicates should"
+  [f]
+  (iop/fn* (comp boolean f)))
+
+;################################################################################
+
+(defn observable?
+  "Returns true if o is an rx.Observable"
+  [o]
+  (instance? Observable o))
+
+;################################################################################
+
+(defn on-next
+  "Call onNext on the given observer."
+  [^Observer o value]
+  (.onNext o value))
+
+(defn on-completed
+  "Call onCompleted on the given observer."
+  [^Observer o]
+  (.onCompleted o))
+
+(defn on-error
+  "Call onError on the given observer."
+  [^Observer o e]
+  (.onError o e))
+
+(defn on-error-return
+  [^Observable o f]
+  (.onErrorReturn o f))
+
+;################################################################################
+
+(defn ^Subscription subscribe
+  ([^Observable o on-next-action]
+    (.subscribe o ^Action1 (iop/action* on-next-action)))
+  ([^Observable o on-next-action on-error-action]
+    (.subscribe o ^Action1 (iop/action* on-next-action) ^Action1 (iop/action* on-error-action)))
+  ([^Observable o on-next-action on-error-action on-completed-action]
+    (.subscribe o ^Action1 (iop/action* on-next-action) ^Action1 (iop/action* on-error-action) ^Action0 (iop/action* on-completed-action))))
+
+(defn chain
+  "Like subscribe, but any omitted handlers pass-through to the next observable."
+  ([from to]
+    (chain from to #(on-next to %)))
+  ([from to on-next-action]
+    (chain from to on-next-action #(on-error to %)))
+  ([from to on-next-action on-error-action]
+    (chain from to on-next-action on-error-action #(on-completed to)))
+  ([from to on-next-action on-error-action on-completed-action]
+    (subscribe from on-next-action on-error-action on-completed-action)))
+
+(defn unsubscribe
+  "Unsubscribe from Subscription s and return it."
+  [^Subscription s]
+  (.unsubscribe s)
+  s)
+
+(defn ^Subscription fn->subscription
+  "Create a new subscription that calls the given no-arg handler function when
+  unsubscribe is called
+
+  See:
+    rx.subscriptions.Subscriptions/create
+  "
+  [handler]
+  (Subscriptions/create ^Action0 (iop/action* handler)))
+
+;################################################################################
+
+(defn ^Observable never [] (Observable/never))
+(defn ^Observable empty [] (Observable/empty))
+
+(defn ^Observable return
+  "Returns an observable that emits a single value.
+
+  See:
+    Observable/just
+  "
+  [value]
+  (Observable/just value))
+
+(defn ^Observable fn->o
+  "Create an observable from the given handler. When subscribed to, (f observer)
+  is called at which point, f can start emitting values, etc."
+  [f]
+  (Observable/create (iop/fn* f)))
+
+(defn ^Observable seq->o
+  "Make an observable out of some seq-able thing. The rx equivalent of clojure.core/seq."
+  [xs]
+  (if xs
+    (Observable/from ^Iterable xs)
+    (empty)))
+
+;################################################################################
+
+(defn cache
+  "caches the observable value so that multiple subscribers don't re-evaluate it"
+  [^Observable xs]
+  (.cache xs))
+
+(defn cons
+  "cons x to the beginning of xs"
+  [x xs]
+  (fn->o (fn [target]
+           (on-next target x)
+           (chain xs target))))
+
+(defn ^Observable concat
+  "Concatenate the given Observables one after the another.
+
+  Note that xs is separate Observables which are concatentated. To concatenate an
+  Observable of Observables, use concat*
+
+  See:
+    rx.Observable/concat
+    concat*
+  "
+  [& xs]
+  (Observable/concat (seq->o xs)))
+
+(defn ^Observable concat*
+  "Concatenate the given Observable of Observables one after another.
+
+  See:
+    rx.Observable/concat
+    concat
+  "
+  [^Observable os]
+  (Observable/concat os))
+
+(defn ^Observable do
+  "Returns a new Observable that, for each x in Observable xs, executes (do-fn x),
+  presumably for its side effects, and then passes x along unchanged.
+
+  If do-fn throws an exception, that exception is emitted via onError and the sequence
+  is finished.
+
+  Example:
+
+    (->> (rx/seq->o [1 2 3])
+         (rx/do println)
+        ...)
+
+    Will print 1, 2, 3.
+  "
+  ([do-fn xs]
+   (fn->o (fn [target]
+            (let [state (atom {:sub   nil
+                               :error nil })
+                  on-next-fn (fn [v]
+                               ; since we may not be able to unsubscribe, drop
+                               ; anything after an error
+                               (let [{:keys [sub error]} @state]
+                                 (if-not error
+                                   (try
+                                     (do-fn v)
+                                     (on-next target v)
+                                     (catch Throwable e
+                                       (reset! state {:error e :sub nil})
+                                       (if sub
+                                         (unsubscribe sub))
+                                       (on-error target e))))))]
+              (let [sub (chain xs target on-next-fn)]
+                ; dependening on xs, this may not be reached until after the sequence
+                ; is complete.
+                (swap! state update-in [:sub] (constantly sub))
+                sub))))))
+
+(defn ^Observable drop
+  [n ^Observable xs]
+  (.skip xs n))
+
+(defn ^Observable drop-while
+  [p xs]
+  (fn->o (fn [target]
+           (let [dropping (atom true)]
+             (chain xs
+                    target
+                    (fn [v]
+                      (when (or (not @dropping)
+                                (not (reset! dropping (p v))))
+                        (on-next target v))))))))
+
+(defn ^Observable filter
+  [p ^Observable xs]
+  (.filter xs (fn->predicate p)))
+
+(defn interpose
+  [sep xs]
+  (fn->o (fn [target]
+           (let [first? (atom true)]
+             (chain xs
+                    target
+                    (fn [v]
+                      (if-not (compare-and-set! first? true false)
+                        (on-next target sep))
+                      (on-next target v)))))))
+
+(defn into
+  "Returns an observable that emits a single value which is all of the
+  values of from-observable conjoined onto to
+
+  See:
+    clojure.core/into
+    rx.Observable/toList
+  "
+  [to ^Observable from-observable]
+  (->> from-observable
+   .toList
+   (map (partial clojure.core/into to))))
+
+(defn keep
+  [f xs]
+  (filter (complement nil?) (map xs f)))
+
+(defn keep
+  [f xs]
+  (filter (complement nil?) (map f xs)))
+
+(defn keep-indexed
+  [f xs]
+  (filter (complement nil?) (map-indexed f xs)))
+
+(defn ^Observable map
+  "Map a function over an observable sequence. Unlike clojure.core/map, only supports up
+  to 4 simultaneous source sequences at the moment."
+  ([f ^Observable xs] (.map xs (iop/fn* f)))
+  ([f xs & observables] (apply base/zip f xs observables)))
+
+(defn ^Observable mapcat
+  "Returns an observable which, for each value x in xs, calls (f x), which must
+  return an Observable. The resulting observables are concatentated together
+  into one observable.
+
+  See:
+    clojure.core/mapcat
+    rx.Observable/mapMany
+  "
+  ([f ^Observable xs] (.mapMany xs (iop/fn* f)))
+  ; TODO multi-arg version
+  )
+
+(defn map-indexed
+  "Returns an observable that invokes (f index value) for each value of the input
+  observable. index starts at 0.
+
+  See:
+    clojure.core/map-indexed
+  "
+  [f xs]
+  (fn->o (fn [target]
+           (let [n (atom -1)]
+             (chain xs
+                    target
+                    (fn [v] (on-next target (f (swap! n inc) v))))))))
+
+(defn merge
+  "
+  Returns an observable that emits a single map that consists of the rest of the
+  maps emitted by the input observable conj-ed onto the first.  If a key occurs
+  in more than one map, the mapping from the latter (left-to-right) will be the
+  mapping in the result.
+
+  NOTE: This is very different from rx.Observable/merge. See rx.base/merge for that
+  one.
+
+  See:
+    clojure.core/merge
+  "
+  [maps]
+  (reduce clojure.core/merge {} maps))
+
+(def next
+  "Returns an observable that emits all of the first element of the input observable.
+
+  See:
+    clojure.core/next
+  "
+  (partial drop 1))
+
+; TODO partition. Use Buffer whenever it's implemented.
+
+(defn ^Observable reduce
+  ([f ^Observable xs] (.reduce xs (iop/fn* f)))
+  ([f val ^Observable xs] (.reduce xs val (iop/fn* f))))
+
+(defn ^Observable reductions
+  ([f ^Observable xs] (.scan xs (iop/fn* f)))
+  ([f val ^Observable xs] (.scan xs val (iop/fn* f))))
+
+(def rest
+  "Same as rx/next"
+  next)
+
+(defn some
+  "Returns an observable that emits the first logical true value of (pred x) for
+  any x in xs, else completes immediately.
+
+  See:
+    clojure.core/some
+  "
+  [p ^Observable xs]
+  (fn->o (fn [target]
+           (chain xs
+                  target
+                  (fn [v]
+                    (when-let [result (p v)]
+                      (on-next target result)
+                      (on-completed target)))))))
+
+(defn sort
+  "Returns an observable that emits a single value which is a sorted sequence
+  of the items in coll, where the sort order is determined by comparing
+  items.  If no comparator is supplied, uses compare. comparator must
+  implement java.util.Comparator.
+
+  See:
+    clojure.core/sort
+  "
+  ([coll] (sort clojure.core/compare coll))
+  ([comp ^Observable coll]
+   (.toSortedList coll (iop/fn [a b]
+                         ; force to int so rxjava doesn't have a fit
+                         (int (comp a b))))))
+
+(defn sort-by
+  "Returns an observable that emits a single value which is a sorted sequence
+  of the items in coll, where the sort order is determined by comparing
+  (keyfn item).  If no comparator is supplied, uses compare. comparator must
+  implement java.util.Comparator.
+
+  See:
+    clojure.core/sort-by
+  "
+  ([keyfn coll] (sort-by keyfn clojure.core/compare coll))
+  ([keyfn comp ^Observable coll]
+   (.toSortedList coll (iop/fn [a b]
+                         ; force to int so rxjava doesn't have a fit
+                         (int (comp (keyfn a) (keyfn b)))))))
+
+(defn split-with
+  "Returns an observable that emits a pair of observables
+
+    [(take-while p xs) (drop-while p xs)]
+
+  See:
+    rx.lang.clojure/take-while
+    rx.lang.clojure/drop-while
+    clojure.core/split-with
+  "
+  [p xs]
+  (return [(take-while p xs) (drop-while p xs)]))
+
+(defn ^Observable take
+  "Returns an observable that emits the first n elements of xs.
+
+  See:
+    clojure.core/take
+  "
+  [n ^Observable xs]
+  {:pre [(>= n 0)]}
+  (.take xs n))
+
+(defn take-while
+  [p xs]
+  (fn->o (fn [target]
+           (chain xs
+                  target
+                  (fn [v]
+                    (if (p v)
+                      (on-next target v)
+                      (on-completed target)))))))
+
+;################################################################################;
+
+(defn throw
+  "Returns an Observable the simply emits the given exception with on-error
+
+  See:
+    http://netflix.github.io/RxJava/javadoc/rx/Observable.html#error(java.lang.Exception)
+  "
+  [^Exception e]
+  (Observable/error e))
+
+(defn catch*
+  "Returns an observable that, when Observable o triggers an error, e, continues with
+  Observable returned by (apply f e args) if (p e) is true. If (p e) returns a Throwable
+  that value is passed as e.
+
+  If p is a class object, a normal instance? check is performed rather than calling it
+  as a function. If the value returned by (p e) is not true, the error is propagated.
+
+  Examples:
+
+    (-> my-observable
+
+        ; On IllegalArgumentException, just emit 1
+        (catch* IllegalArgumentException (fn [e] (rx/return 1)))
+
+        ; If exception message contains \"WAT\", emit [\\W \\A \\T]
+        (catch* #(-> % .getMessage (.contains \"WAT\")) (rx/seq->o [\\W \\A \\T])))
+
+  See:
+
+    http://netflix.github.io/RxJava/javadoc/rx/Observable.html#onErrorResumeNext(rx.util.functions.Func1)
+  "
+  [^Observable o p f & args]
+  (let [p (if (class? p)
+            (fn [e] (.isInstance ^Class p e))
+            p)]
+    (.onErrorResumeNext o
+                        ^Func1 (iop/fn [e]
+                                 (if-let [maybe-e (p e)]
+                                   (apply f (if (instance? Throwable maybe-e) maybe-e e) args)
+                                   (rx.lang.clojure.core/throw e))))))
+
+(defmacro catch
+  "Macro version of catch*.
+
+  The body of the catch is wrapped in an implicit (do). It must evaluate to an Observable.
+
+  Example:
+
+    (-> my-observable
+        ; just emit 0 on IllegalArgumentException
+        (catch IllegalArgumentException e
+          (rx/return 0))
+
+        (catch DependencyException e
+          (if (.isMinor e)
+            (rx/return 0)
+            (rx/throw (WebException. 503)))))
+
+  See:
+    catch*
+  "
+  [o p binding & body]
+  `(catch* ~o ~p (fn [~binding] ~@body)))
+
+(defn finally*
+  "Returns an Observable that, as a side-effect, executes (apply f args) when the given
+  Observable completes regardless of success or failure.
+
+  Example:
+
+    (-> my-observable
+        (finally* (fn [] (println \"Done\"))))
+
+  "
+  [^Observable o f & args]
+  (.finallyDo o ^Action0 (iop/action [] (apply f args))))
+
+(defmacro finally
+  "Macro version of finally*.
+
+  Example:
+
+    (-> my-observable
+        (finally (println \"Done\")))
+
+  See:
+    finally*
+  "
+  [o & body]
+  `(finally* ~o (fn [] ~@body)))
+
+;################################################################################;
+
+(defn generator*
+  "Creates an observable that calls (f observable & args) which should emit a sequence.
+
+  Automatically calls on-completed on return, or on-error if any exception is thrown.
+
+  Subscribers will block.
+
+  Examples:
+
+    ; An observable that emits just 99
+    (generator* on-next 99)
+  "
+  [f & args]
+  (fn->o (-> (fn [observer]
+               (apply f observer args)
+               (Subscriptions/empty))
+             base/wrap-on-completed
+             base/wrap-on-error)))
+
+(defmacro generator
+  "Create an observable that executes body which should emit a sequence. bindings
+  should be a single [observer] argument.
+
+  Automatically calls on-completed on return, or on-error if any exception is thrown.
+
+  Subscribe will block.
+
+  Examples:
+
+    ; make an observer that emits [0 1 2 3 4]
+    (generator [observer]
+      (dotimes [i 5]
+        (on-next observer i)))
+
+  "
+  [bindings & body]
+  `(generator* (fn ~bindings ~@body)))
+
+;################################################################################;
+
+; Import public graph symbols here. I want them in this namespace, but implementing
+; them here with all the clojure.core symbols excluded is a pain.
+(intern *ns* (with-meta 'let-o* (meta #'graph/let-o*)) @#'graph/let-o*)
+(intern *ns* (with-meta 'let-o (meta #'graph/let-o)) @#'graph/let-o)
+
+;################################################################################;
+
+; Import some public realized symbols here. I want them in this namespace, but implementing
+; them here with all the clojure.core symbols excluded is a pain.
+(intern *ns* (with-meta 'let-realized (meta #'realized/let-realized)) @#'realized/let-realized)
+
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
new file mode 100644
index 0000000000..7f6a78761d
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
@@ -0,0 +1,88 @@
+(ns rx.lang.clojure.future
+  (:refer-clojure :exclude [future])
+  (:require [rx.lang.clojure.interop :as iop]
+            [rx.lang.clojure.core :as rx :refer [fn->o fn->subscription]]
+            [rx.lang.clojure.base :as base]))
+
+(def ^:private -ns- *ns*)
+(set! *warn-on-reflection* true)
+
+(defn default-runner
+  "Default runner creator function. Creates futures on Clojure's default future thread pool."
+  [f]
+  (future-call f))
+
+(defn future-generator*
+  "Same as rx/generator* except f is invoked in a separate thread.
+
+  runner is a function that takes a no-arg function argument and returns a future
+  representing the execution of that function.
+
+  subscribe will not block.
+
+  See:
+    rx.lang.clojure.core/generator*
+    rx.lang.clojure.future/future-generator
+  "
+  [runner f & args]
+  {:pre [(ifn? runner) (ifn? f)]}
+  (fn->o (fn [observer]
+           (let [wrapped (-> (fn [o]
+                               (apply f o args))
+                             base/wrap-on-completed
+                             base/wrap-on-error)
+                 fu      (runner #(wrapped observer))]
+             (fn->subscription #(future-cancel fu))))))
+
+(defmacro future-generator
+  "Same as rx/generator macro except body is invoked in a separate thread.
+
+  runner is a function that takes a no-arg function argument and returns a future
+  representing the execution of that function.
+
+  subscribe will not block.
+
+  See:
+    rx.lang.clojure.core/generator*
+    rx.lang.clojure.future/future-generator
+  "
+  [runner bindings & body]
+  `(future-generator* ~runner (fn ~bindings ~@body)))
+
+(defn future*
+  "Execute (f & args) in a separate thread and pass the result to onNext.
+  If an exception is thrown, onError is called with the exception.
+
+  runner is a function that takes a no-arg function argument and returns a future
+  representing the execution of that function.
+
+  Returns an Observable.
+  "
+  [runner f & args]
+  {:pre [(ifn? runner) (ifn? f)]}
+  (fn->o (fn [observer]
+           (let [wrapped (-> #(rx/on-next % (apply f args))
+                             base/wrap-on-completed
+                             base/wrap-on-error)
+                 fu      (runner #(wrapped observer))]
+             (fn->subscription #(future-cancel fu))))))
+
+(defmacro future
+  "Executes body in a separate thread and passes the single result to onNext.
+  If an exception occurs, onError is called.
+
+  Returns an Observable
+
+  runner is a function that takes a no-arg function argument and returns a future
+  representing the execution of that function.
+
+  Examples:
+
+    (subscribe (rx/future rx/default-runner
+                  (slurp \"input.txt\"))
+               (fn [v] (println \"Got: \" v)))
+    ; eventually outputs content of input.txt
+  "
+  [runner & body]
+  `(future* ~runner (fn [] ~@body)))
+
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj
new file mode 100644
index 0000000000..18187d29ac
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj
@@ -0,0 +1,137 @@
+(ns rx.lang.clojure.graph
+  "This is an implementation namespace. Don't use it directly. Use the symbols
+  in rx.lang.clojure.core
+  "
+  (:require [clojure.set :as set]))
+
+(def ^:private -ns- *ns*)
+(set! *warn-on-reflection* true)
+
+(defn ^:private ->let-o*-observable
+  [^rx.Observable o n name]
+  (if (= n 1)
+    o
+    ; TODO This is a shortcut. We know the expected number of subscriptions so
+    ; we only need to cache values until we get the nth subscription at which
+    ; point, it just becomes a pass through. I haven't found a cache/replay-ish
+    ; operator that gives this level of control over the cached values
+    (.cache o)))
+
+(defn let-o*
+  "Given a graph description, returns an observable that emits a single
+  map of observables all hooked up and ready for subscription.
+
+  A graph is a map from name to a map with keys:
+
+    :deps     A vector of dependency names
+    :factory  A function that takes a map from name to Observable
+              for the names in :deps and returns an Observable
+
+  Returns a map from name to Observable. Additionally, there will be a
+  ::non-terminals key in the map with a vector of non-terminal names.
+
+  See:
+    let-o
+  "
+  [description]
+  (let [in-dep-counts (->> description
+                           vals
+                           (mapcat :deps)
+                           frequencies)
+        terminals     (set/difference (set (keys description)) (set (keys in-dep-counts)))
+        non-terminals (vec (keys in-dep-counts))
+
+        resolve-node (fn resolve-node [state {:keys [id deps factory] :as node}]
+                       (let [existing (state id)]
+                         (cond
+                           ; It's already resolving up the stack. We've hit a cycle.
+                           (= ::resolving existing) (throw (IllegalArgumentException. (format "Cycle found at '%s'" id)))
+
+                           ; It's already resolved. Done.
+                           (not (nil? existing))    state
+
+                           :else
+                            ; recursively resolve dependencies
+                            (let [new-state (reduce (fn [s dep]
+                                                      (if-let [dep-node (description dep)]
+                                                        (resolve-node s (assoc dep-node :id dep))
+                                                        (throw (IllegalArgumentException. (format "Unknown node '%s' referenced from '%s'" dep id)))))
+                                                    (assoc state id ::resolving)
+                                                    deps)
+                                  ; execute the factory function and wrap it in an observable that delays dependencies
+                                  o         (-> (select-keys new-state deps)
+                                                factory
+                                                (->let-o*-observable (in-dep-counts id 1) id))]
+                              ; return the updated state with the resolved node
+                              (assoc new-state id o)))))]
+    ; resolve the graph and build the result map
+    (-> (reduce (fn [s [id node]]
+                  (resolve-node s (assoc node :id id)))
+                {}
+                description)
+        (select-keys terminals)
+        (assoc ::non-terminals non-terminals))))
+
+(defmacro let-o
+  "Similar to clojure.core/let, but bindings are Observables and the result of the body
+  must be an Observable. Binding names must start with ?. Binding order doesn't matter
+  and any binding is visible to all other expressions as long as no cycles are produced
+  in the resulting Observable expression.
+
+  The key difference here is that the macro can identify the dependencies between Observables
+  and correctly connect them, protecting from variations in subscribe behavior as well as
+  the idiosyncracies of setting up multiple subscriptions to Observables.
+
+  This is only very useful for constructing graphs of Observables where you'd usually have
+  to fiddle around with publish, connect, replay and all that stuff. If you have a linear
+  sequence of operators, just chain them together.
+
+  Current limitations:
+
+    * All Observables are cache()'d so watch out for large sequences. This will be
+      fixed eventually.
+    * let-o cannot be nested. Some deep-walking macro-magic will be required for this.
+
+  Example:
+
+    ; Note that both ?c and ?d depend on ?b and the result Observable depends on
+    ; ?c and ?d.
+    (let-o [?a (rx/return 99)
+            ?b (... some observable network request ...)
+            ?c (rx/map vector ?a ?b)
+            ?d (rx/map ... ?b)]
+      (rx/map vector ?c ?d))
+
+  See:
+    let-o*
+  "
+  [bindings & result-body]
+  (let [sym->dep-sym (fn [s]
+                       (when (and (symbol? s)
+                                  (not (namespace s))
+                                  (.startsWith (name s) "?"))
+                         s))
+        body->dep-syms (fn [body]
+                          (->> body
+                               flatten
+                               (keep sym->dep-sym)
+                               distinct
+                               vec))
+        ->node-map (fn [[id & body]]
+                     (let [dep-syms (body->dep-syms body)
+                           dep-keys (->> dep-syms (map (comp keyword name)) vec)]
+                       [(keyword (name id)) {:deps dep-keys
+                                             :factory `(fn [{:keys ~dep-syms}] ~@body) }]))
+        node-map (let [base-map  (->> bindings
+                                      (partition 2)
+                                      (map ->node-map)
+                                      (into {}))
+                       result-dep-syms (body->dep-syms result-body)]
+                   (assoc base-map
+                          :rx.lang.clojure.core/result
+                          {:deps     (mapv keyword result-dep-syms)
+                           :factory `(fn [{:keys ~result-dep-syms}] ~@result-body) }))]
+    `(->> ~node-map
+          let-o*
+          :rx.lang.clojure.core/result)))
+
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
new file mode 100644
index 0000000000..7747c71881
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
@@ -0,0 +1,127 @@
+(ns rx.lang.clojure.realized
+  (:require [rx.lang.clojure.interop :as iop]
+            [rx.lang.clojure.base :as rx-base]))
+
+(def ^:private -ns- *ns*)
+(set! *warn-on-reflection* true)
+
+(defrecord ^:private PostProc [o f])
+
+(defn all
+  "Tell realized map to capture all output of the observable, not just the last one"
+  [o]
+  (->PostProc o identity))
+
+(defn only
+  "Tell realized map to capture the only value emitted by the observable.
+  If there are 0 or more than one values, an IllegalStateException is thrown
+  which should propagate to onError.
+
+  This is the default mode of realized-map and let-realized.
+  "
+  [o]
+  (->PostProc o (fn [values]
+                  (condp = (count values)
+                    1 (first values)
+                    (throw (IllegalStateException. "Observable did not produce exactly one value"))))))
+
+(defn ^:private ->post-proc
+  [v]
+  (cond
+    (instance? rx.Observable v) (only v)
+    (instance? PostProc v)      v
+    (vector? v)                 (->PostProc (first v)
+                                            (apply comp (reverse (next v))))
+    :else                       (->post-proc (rx.Observable/just v))))
+
+(defn realized-map
+  "See let-realized.
+
+  Given a map from key to observable, returns an observable that emits a single
+  map from the same keys to the values emitted by their corresponding observable.
+
+  keyvals is a list of key/value pairs where key is a key in the emitted map and val
+  can be one of the following:
+
+    rx.Observable The only value of the emitted sequence is bound to the key. This is the
+                  default since this is often a singleton response from a request. If the
+                  Observable produces 0 or more than 1 values, an IllegalStateException is
+                  produced.
+
+    vector        The first element of the vector must be an Observable. Remaining elements
+                  are functions applied in sequence to the list of values emitted by the
+                  observable. For example [my-observable first] will result in a single
+                  value in the emitted map rather than a vector of values.
+
+    other         The value is placed in the emitted map as is
+
+  Note the observable can also be wrapped with realized/all to get the full list rather than
+  just the last value.
+
+  The purpose of this is to simplify the messy pattern of mapping observables to
+  single key maps, merging and then folding all the separate maps together. So code
+  like this:
+
+    (rx/merge (rx-base/merge (->> (user-info-o user-id)
+                                  (rx/map (fn [u] {:user u})))
+                             (->> (user-likes-o user-id)
+                                  (rx/map (fn [u] {:likes u})))))
+
+  becomes:
+
+    (realized-map :user  (user-info-o user-id)
+                  :likes (user-likes-o user-id))
+
+  See:
+    let-realized
+  "
+  [& keyvals]
+  (let [o (->> keyvals
+               (partition 2)
+               ; generate a sequence of observables
+               (map (fn [[k v]]
+                      (let [{:keys [^rx.Observable o f]} (->post-proc v)]
+                        ; pour the observable into a single list and apply post-proc func to it
+                        (-> o
+                            .toList
+                            (.map (iop/fn [list] {k (f list)})))))))]
+
+    (-> o
+        rx-base/merge ; funnel all the observables into a single sequence
+        (.reduce {} (iop/fn* merge))))) ; do the map merge dance
+
+(defn ^rx.Observable realized-map*
+  "Same as realized-map, but takes a map argument rather than key-value pairs."
+  [map-description]
+  (apply realized-map (apply concat map-description)))
+
+(defmacro let-realized
+  "'let' version of realized map.
+
+    (let-realized [a (make-observable)]
+      (* 2 a))
+
+  is equivalent to:
+
+    (->> (realized-map :a (make-observable))
+         (map (fn [{:keys [a]}] (* 2 a))))
+
+  That is, it eliminates the repition of the map keys when you want to do something
+  with the final result.
+
+  Evaluates to an Observable that emits the value of the let body.
+
+  See:
+    rx.lang.clojure.realized/realized-map
+    rx.lang.clojure.realized/all
+  "
+  [bindings & body]
+  (let [b-parts (partition 2 bindings)
+        b-map (->> b-parts
+                   (map (fn [[k v]]
+                          [(keyword (name k)) v]))
+                   (into {}))
+        b-names (mapv first b-parts)]
+    `(.map (realized-map* ~b-map)
+           (iop/fn [{:keys ~b-names}] ~@body))))
+
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj
new file mode 100644
index 0000000000..985e7eeb1f
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj
@@ -0,0 +1,38 @@
+(ns rx.lang.clojure.base-test
+  (:require [rx.lang.clojure.core :as rx]
+            [rx.lang.clojure.base :as b]
+            [rx.lang.clojure.blocking :as blocking]
+            [rx.lang.clojure.future :as f]
+            )
+  (:require [clojure.test :refer [deftest testing is]]))
+
+(deftest test-zip
+  (testing "is happy with less than 4 args"
+    (is (= [[1 2 3]] (blocking/into [] (b/zip vector
+                                        (rx/seq->o [1]) (rx/seq->o [2]) (rx/seq->o [3]))))))
+  (testing "is happy with more than 4 args"
+    (is (= [[1 2 3 4 5 6 7 8]]
+           (blocking/into [] (b/zip vector
+                              (rx/seq->o [1])
+                              (rx/seq->o [2])
+                              (rx/seq->o [3])
+                              (rx/seq->o [4])
+                              (rx/seq->o [5])
+                              (rx/seq->o [6])
+                              (rx/seq->o [7])
+                              (rx/seq->o [8])))))))
+
+(deftest test-merge
+  (is (= [[1 3 5] [2 4 6]]
+         (let [r (blocking/into []
+                   (b/merge [(f/future-generator f/default-runner [o]
+                                                   (doseq [x [1 3 5]]
+                                                     (Thread/sleep 10)
+                                                     (rx/on-next o x)))
+                              (f/future-generator f/default-runner [o]
+                                                   (doseq [x [2 4 6]]
+                                                     (Thread/sleep 10)
+                                                     (rx/on-next o x)))]))]
+           ; make sure each sequence maintained original order
+           [(keep #{1 3 5} r)
+            (keep #{2 4 6} r) ]))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
new file mode 100644
index 0000000000..0963c14bab
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
@@ -0,0 +1,18 @@
+(ns rx.lang.clojure.blocking-test
+  (:require [rx.lang.clojure.blocking :as b]
+            [rx.lang.clojure.core :as rx]
+            [clojure.test :refer [deftest testing is]]))
+
+(deftest test-first
+  (testing "returns first element of observable"
+    (is (= 1 (b/first (rx/return 1)))))
+  (testing "returns nil for empty observable"
+    (is (nil? (b/first (rx/empty))))))
+
+(deftest test-single
+  (testing "returns one element"
+    (is (= 1 (b/single (rx/return 1)))))
+  (testing "throw if empty"
+    (is (thrown? java.lang.IllegalArgumentException (b/single (rx/empty)))))
+  (testing "throw if many"
+    (is (thrown? java.lang.IllegalArgumentException (b/single (rx/seq->o [1 2]))))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj
new file mode 100644
index 0000000000..c0d8974e8b
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj
@@ -0,0 +1,56 @@
+(ns rx.lang.clojure.chunk-test
+  (:require [rx.lang.clojure.chunk :as rx-chunk]
+            [rx.lang.clojure.core :as rx]
+            [rx.lang.clojure.future :as rx-future]
+            [rx.lang.clojure.blocking :as rx-blocking]
+            [clojure.test :refer [deftest testing is]]))
+
+
+(deftest test-chunk
+  (let [n          20
+        chunk-size 10
+        factory (rx-future/future-generator rx-future/default-runner [o]
+                  (doseq [i (range n)]
+                    (Thread/sleep (rand-int 50))
+                    (rx/on-next o (rx-future/future rx-future/default-runner
+                                      (let [t (rand-int 500)]
+                                        (Thread/sleep t))
+                                      i))))]
+    (is (= (range n)
+           (sort (rx-blocking/into []
+                                   (rx-chunk/chunk chunk-size {:debug true} factory)))))))
+
+(deftest test-chunk-with-error
+  (testing "error from source is propagated"
+    (let [n          20
+          chunk-size 4
+          factory (rx-future/future-generator rx-future/default-runner [o]
+                                              (doseq [i (range n)]
+                                                (Thread/sleep (rand-int 50))
+                                                (rx/on-next o (rx-future/future rx-future/default-runner
+                                                                                (let [t (rand-int 1000)]
+                                                                                  (Thread/sleep t))
+                                                                                i)))
+                                              (throw (IllegalArgumentException. "hi")))]
+      (is (thrown-with-msg? IllegalArgumentException #"hi"
+                            (rx-blocking/into []
+                                              (rx-chunk/chunk chunk-size {:debug true} factory))))))
+
+  (testing "error from single observable is propagated"
+    (let [n          20
+          chunk-size 4
+          factory (rx-future/future-generator rx-future/default-runner [o]
+                                              (doseq [i (range n)]
+                                                (Thread/sleep (rand-int 50))
+                                                (rx/on-next o (rx-future/future rx-future/default-runner
+                                                                                (let [t (rand-int 1000)]
+                                                                                  (throw (IllegalArgumentException. "byebye"))
+                                                                                  (Thread/sleep t))
+                                                                                i))))]
+      (is (thrown? rx.exceptions.CompositeException
+                   (rx-blocking/into []
+                                     (rx-chunk/chunk chunk-size
+                                                 {:debug true
+                                                  :delay-error? true }
+                                                 factory)))))))
+
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
new file mode 100644
index 0000000000..7af636345d
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -0,0 +1,351 @@
+(ns rx.lang.clojure.core-test
+  (:require [rx.lang.clojure.core :as rx]
+            [rx.lang.clojure.blocking :as b]
+            [clojure.test :refer [deftest is testing]]))
+(comment
+  (rx/subscribe
+    (->>
+      (rx/map (fn [a b] (hash-map :a a :b b)) (rx/seq->o [1 2 3 4 5 6])
+              (rx/seq->o ["x" "y" 9 10 "z"]))
+      (rx/map    #(update-in % [:a] (partial * 2)))
+      (rx/filter (comp not number? :b))
+      (rx/concat (rx/seq->o (range 3)))
+      (rx/drop 1)
+      (rx/take 6)
+      (rx/into []))
+    println
+    println))
+
+(deftest test-observable?
+  (is (rx/observable? (rx/return 99)))
+  (is (not (rx/observable? "I'm not an observable"))))
+
+(deftest test-subscribe
+  (testing "subscribe overload with only onNext"
+    (let [o (rx/return 1)
+          called (atom nil)]
+      (rx/subscribe o (fn [v] (swap! called (fn [_] v))))
+      (is (= 1 @called)))))
+
+(deftest test-generator
+  (testing "calls on-completed automatically"
+    (let [o (rx/generator [o])
+          called (atom nil)]
+      (rx/subscribe o (fn [v]) (fn [_]) #(reset! called "YES"))
+      (is (= "YES" @called))))
+
+  (testing "exceptions automatically go to on-error"
+    (let [expected (IllegalArgumentException. "hi")
+          actual   (atom nil)]
+      (rx/subscribe (rx/generator [o] (throw expected))
+                     (fn [v])
+                     #(reset! actual %))
+      (is (identical? expected @actual)))))
+
+(deftest test-seq->o
+  (is (= [] (b/into [] (rx/seq->o []))))
+  (is (= [] (b/into [] (rx/seq->o nil))))
+  (is (= [0 1 2 3] (b/first (rx/into [] (rx/seq->o (range 4))))))
+  (is (= #{0 1 2 3} (b/first (rx/into #{} (rx/seq->o (range 4))))))
+  (is (= {:a 1 :b 2 :c 3} (b/first (rx/into {} (rx/seq->o [[:a 1] [:b 2] [:c 3]]))))))
+
+(deftest test-return
+  (is (= [0] (b/into [] (rx/return 0)))))
+
+(deftest test-cache
+  (let [value (atom 0)
+        o (->>
+            (rx/return 0)
+            (rx/map (fn [x] (swap! value inc)))
+            (rx/cache))]
+    (is (= 1 (b/single o)))
+    (is (= 1 @value))
+    (is (= 1 (b/single o)))
+    (is (= 1 @value))
+    (is (= 1 (b/single o)))))
+
+(deftest test-cons
+  (is (= [1] (b/into [] (rx/cons 1 (rx/empty)))))
+  (is (= [1 2 3 4] (b/into [] (rx/cons 1 (rx/seq->o [2 3 4]))))))
+
+(deftest test-concat
+  (is (= [:q :r]
+         (b/into [] (rx/concat (rx/seq->o [:q :r])))))
+  (is (= [:q :r 1 2 3]
+         (b/into [] (rx/concat (rx/seq->o [:q :r])
+                               (rx/seq->o [1 2 3]))))))
+
+(deftest test-concat*
+  (is (= [:q :r]
+         (b/into [] (rx/concat* (rx/return (rx/seq->o [:q :r]))))))
+  (is (= [:q :r 1 2 3]
+         (b/into [] (rx/concat* (rx/seq->o [(rx/seq->o [:q :r])
+                                            (rx/seq->o [1 2 3])]))))))
+
+(deftest test-do
+  (testing "calls a function with each element"
+    (let [collected (atom [])]
+      (is (= [1 2 3]
+             (->> (rx/seq->o [1 2 3])
+                  (rx/do (fn [v]
+                           (swap! collected conj (* 2 v))))
+                  (rx/do (partial println "GOT"))
+                  (b/into []))))
+      (is (= [2 4 6] @collected))))
+  (testing "ends sequence with onError if action code throws an exception"
+    (let [collected (atom [])
+          o (->> (rx/seq->o [1 2 3])
+                 (rx/do (fn [v]
+                           (if (= v 2)
+                             (throw (IllegalStateException. (str "blah" v)))
+                             (swap! collected conj (* 99 v))))))]
+      (is (thrown-with-msg? IllegalStateException #"blah2"
+                            (b/into [] o)))
+      (is (= [99] @collected)))))
+
+(deftest test-drop-while
+  (is (= (into [] (drop-while even? [2 4 6 8 1 2 3]))
+         (b/into [] (rx/drop-while even? (rx/seq->o [2 4 6 8 1 2 3])))))
+  (is (= (into [] (drop-while even? [2 4 6 8 1 2 3]))
+         (b/into [] (rx/drop-while even? (rx/seq->o [2 4 6 8 1 2 3]))))))
+
+(deftest test-filter
+  (is (= (into [] (->> [:a :b :c :d :e :f :G :e]
+                    (filter #{:b :e :G})))
+         (b/into [] (->> (rx/seq->o [:a :b :c :d :e :f :G :e])
+                        (rx/filter #{:b :e :G}))))))
+
+(deftest test-interpose
+  (is (= (interpose \, [1 2 3])
+         (b/into [] (rx/interpose \, (rx/seq->o [1 2 3]))))))
+
+(deftest test-into
+  (is (= (into [6 7 8] [9 10 [11]])
+         (b/first (rx/into [6 7 8] (rx/seq->o [9 10 [11]]))))))
+
+(deftest test-keep
+  (is (= (into [] (keep identity [true true false]))
+         (b/into [] (rx/keep identity (rx/seq->o [true true false])))))
+
+  (is (= (into [] (keep #(if (even? %) (* 2 %)) (range 9)))
+         (b/into [] (rx/keep #(if (even? %) (* 2 %)) (rx/seq->o (range 9)))))))
+
+(deftest test-keep-indexed
+  (is (= (into [] (keep-indexed (fn [i v]
+                                  (if (even? i) v))
+                                [true true false]))
+         (b/into [] (rx/keep-indexed (fn [i v]
+                                         (if (even? i) v))
+                                       (rx/seq->o [true true false]))))))
+
+(deftest test-map
+  (is (= (into {} (map (juxt identity name)
+                       [:q :r :s :t :u]))
+         (b/into {} (rx/map (juxt identity name)
+                              (rx/seq->o [:q :r :s :t :u])))))
+  (is (= (into [] (map vector
+                       [:q :r :s :t :u]
+                       (range 10)
+                       ["a" "b" "c" "d" "e"] ))
+         (b/into [] (rx/map vector
+                              (rx/seq->o [:q :r :s :t :u])
+                              (rx/seq->o (range 10) )
+                              (rx/seq->o ["a" "b" "c" "d" "e"] )))))
+  ; check > 4 arg case
+  (is (= (into [] (map vector
+                       [:q :r :s :t :u]
+                       [:q :r :s :t :u]
+                       [:q :r :s :t :u]
+                       (range 10)
+                       (range 10)
+                       (range 10)
+                       ["a" "b" "c" "d" "e"]
+                       ["a" "b" "c" "d" "e"]
+                       ["a" "b" "c" "d" "e"]))
+         (b/into [] (rx/map vector
+                            (rx/seq->o [:q :r :s :t :u])
+                            (rx/seq->o [:q :r :s :t :u])
+                            (rx/seq->o [:q :r :s :t :u])
+                            (rx/seq->o (range 10))
+                            (rx/seq->o (range 10))
+                            (rx/seq->o (range 10))
+                            (rx/seq->o ["a" "b" "c" "d" "e"])
+                            (rx/seq->o ["a" "b" "c" "d" "e"])
+                            (rx/seq->o ["a" "b" "c" "d" "e"]))))))
+
+(deftest test-map-indexed
+  (is (= (map-indexed vector [:a :b :c])
+         (b/into [] (rx/map-indexed vector (rx/seq->o [:a :b :c]))))))
+
+(deftest test-merge
+  (is (= [{:a 1 :b 2 :c 3 :d 4}]
+         (b/into [] (rx/merge (rx/seq->o [{:a 1 :d 0} {:b 2} {:c 3} {:d 4} ]))))))
+
+(deftest test-mapcat
+  (let [f  (fn [v] [v (* v v)])
+        xs (range 10)]
+    (is (= (mapcat f xs)
+           (b/into [] (rx/mapcat (comp rx/seq->o f) (rx/seq->o xs))))))
+  (comment
+    (is (= (into [] (mapcat vector
+                              [:q :r :s :t :u]
+                              (range 10)
+                              ["a" "b" "c" "d" "e"] ))
+        (b/into [] (rx/mapcat vector
+                              (rx/seq->o [:q :r :s :t :u])
+                              (rx/seq->o (range 10) )
+                              (rx/seq->o ["a" "b" "c" "d" "e"] )))))))
+
+(deftest test-next
+  (let [in [:q :r :s :t :u]]
+    (is (= (next in) (b/into [] (rx/next (rx/seq->o in)))))))
+
+(deftest test-rest
+  (let [in [:q :r :s :t :u]]
+    (is (= (rest in) (b/into [] (rx/rest (rx/seq->o in)))))))
+
+(deftest test-reduce
+  (is (= (reduce + 0 (range 4))
+         (b/first (rx/reduce + 0 (rx/seq->o (range 4)))))))
+
+(deftest test-reductions
+  (is (= (into [] (reductions + 0 (range 4)))
+         (b/into [] (rx/reductions + 0 (rx/seq->o (range 4)))))))
+
+(deftest test-some
+  (is (= [:r] (b/into [] (rx/some #{:r :s :t} (rx/seq->o [:q :v :r])))))
+  (is (= [] (b/into [] (rx/some #{:r :s :t} (rx/seq->o [:q :v]))))))
+
+(deftest test-sort
+  (is (= [[]] (b/into [] (rx/sort (rx/empty)))))
+  (is (= [[1 2 3]]
+         (b/into [] (rx/sort (rx/seq->o [3 1 2])))))
+  (is (= [[3 2 1]]
+         (b/into [] (rx/sort (fn [a b] (- (compare a b))) (rx/seq->o [2 1 3]))))))
+
+(deftest test-sort-by
+  (is (= [[]] (b/into [] (rx/sort-by :foo (rx/empty)))))
+  (is (= [[{:foo 1} {:foo 2} {:foo 3}]]
+         (b/into [] (rx/sort-by :foo (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}])))))
+  (is (= [[{:foo 3} {:foo 2} {:foo 1}]]
+         (b/into [] (rx/sort-by :foo (fn [a b] (- (compare a b))) (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}]))))))
+
+(deftest test-split-with
+  (is (= (split-with (partial >= 3) (range 6))
+         (->> (rx/seq->o (range 6))
+              (rx/split-with (partial >= 3))
+              b/first
+              (map (partial b/into []))))))
+
+(deftest test-take-while
+  (is (= (into [] (take-while even? [2 4 6 8 1 2 3]))
+         (b/into [] (rx/take-while even? (rx/seq->o [2 4 6 8 1 2 3]))))))
+
+(deftest test-throw
+  (let [expected (IllegalArgumentException. "HI")
+        called (atom nil)]
+    (rx/subscribe (rx/throw expected)
+                  (fn [_])
+                  (fn [e] (reset! called expected))
+                  (fn [_]))
+    (is (identical? expected @called))))
+
+(deftest test-catch*
+  (testing "Is just a passthrough if there's no error"
+    (is (= [1 2 3]
+           (b/into []
+                   (->
+                     (rx/seq->o [1 2 3])
+                     (rx/catch* Exception (fn [e] (throw "OH NO"))))))))
+
+  (testing "Can catch a particular exception type and continue with an observable"
+    (is (= [1 2 4 5 6 "foo"]
+           (b/into []
+                   (->
+                     (rx/generator [o]
+                                   (rx/on-next o 1)
+                                   (rx/on-next o 2)
+                                   (rx/on-error o (IllegalStateException. "foo")))
+                     (rx/catch* IllegalStateException
+                             (fn [e]
+                               (rx/seq->o [4 5 6 (.getMessage e)]))))))))
+
+  (testing "if exception isn't matched, it's passed to on-error"
+    (let [expected (IllegalArgumentException. "HI")
+          called (atom nil)]
+    (rx/subscribe (->
+                    (rx/generator [o]
+                                   (rx/on-next o 1)
+                                   (rx/on-next o 2)
+                                   (rx/on-error o expected))
+                    (rx/catch* IllegalStateException (fn [e]
+                      (rx/return "WAT?"))))
+                  (fn [_])
+                  (fn [e] (reset! called expected))
+                  (fn [_]))
+    (is (identical? expected @called))))
+
+  (testing "if p returns Throwable, that's passed as e"
+    (let [cause (IllegalArgumentException. "HI")
+          wrapper (java.util.concurrent.ExecutionException. cause)]
+      (is (= [cause]
+             (b/into []
+                     (->
+                       (rx/generator [o]
+                                     (rx/on-error o wrapper))
+                       (rx/catch #(.getCause %) e
+                         (rx/return e)))))))))
+
+
+(deftest test-finally
+  (testing "Supports a finally clause"
+    (testing "called on completed"
+      (let [completed (atom nil)
+            called (atom nil)]
+        (rx/subscribe (->
+                        (rx/seq->o [1 2 3])
+                        (rx/finally* (fn [extra] (reset! called (str "got " extra)))
+                                     "it"))
+                      (fn [_])
+                      (fn [_] (throw (IllegalStateException. "WAT")))
+                      (fn [] (reset! completed "DONE")))
+        (is (= "got it" @called))
+        (is (= "DONE" @completed))))
+
+    (testing "called on error"
+      (let [expected (IllegalStateException. "expected")
+            completed (atom nil)
+            called (atom nil)]
+        (rx/subscribe (->
+                        (rx/generator [o]
+                                   (rx/on-next o 1)
+                                   (rx/on-next o 2)
+                                   (rx/on-error o expected))
+                        (rx/finally
+                          (reset! called "got it")))
+                      (fn [_])
+                      (fn [e] (reset! completed e))
+                      (fn [] (throw (IllegalStateException. "WAT"))))
+        (is (= "got it" @called))
+        (is (identical? expected @completed))))))
+
+;################################################################################
+
+(deftest test-graph-imports
+  (is (= 99
+         (-> {:a {:deps [] :factory (fn [_] (rx/return 99))}}
+             rx/let-o*
+             :a
+             b/single)))
+  (is (= 100
+         (b/single (rx/let-o [?a (rx/return 100)]
+                     ?a)))))
+
+;################################################################################
+
+(deftest test-realized-imports
+  (is (= {:a 1 :b 2}
+         (->> (rx/let-realized [a (rx/return 1)
+                                b (rx/return 2)]
+                {:a a :b b})
+              b/single))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
new file mode 100644
index 0000000000..dccf89c908
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
@@ -0,0 +1,37 @@
+(ns rx.lang.clojure.future-test
+  (:require [rx.lang.clojure.core :as rx]
+            [rx.lang.clojure.blocking :as blocking]
+            [rx.lang.clojure.future :as f])
+  (:require [clojure.test :refer [deftest testing is]]))
+
+(deftest test-future-generator
+  (is (not= [(.getId (Thread/currentThread))]
+            (blocking/into []
+                      (f/future-generator f/default-runner
+                        [observer]
+                        (rx/on-next observer (.getId (Thread/currentThread))))))))
+
+(deftest test-future
+  (is (= [15] (blocking/into [] (f/future* f/default-runner + 1 2 3 4 5))))
+  (is (= [15] (blocking/into [] (f/future f/default-runner (println "HI") (+ 1 2 3 4 5))))) )
+
+
+(comment (rx/subscribe (f/future* f/default-runner + 1 2 3 4 5)
+                        (fn [v] (println "RESULT: " v))
+                        (fn [e] (println "ERROR: " e))
+                        #(println "COMPLETED")))
+
+(comment (rx/subscribe (f/future f/default-runner
+                          (Thread/sleep 5000)
+                          (+ 100 200))
+                        (fn [v] (println "RESULT: " v))
+                        (fn [e] (println "ERROR: " e))
+                        #(println "COMPLETED")))
+
+(comment (rx/subscribe (f/future f/default-runner
+                          (Thread/sleep 2000)
+                          (throw (Exception. "Failed future")))
+                        (fn [v] (println "RESULT: " v))
+                        (fn [e] (println "ERROR: " e))
+                        #(println "COMPLETED")))
+
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
new file mode 100644
index 0000000000..2b3fdde98c
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
@@ -0,0 +1,118 @@
+(ns rx.lang.clojure.graph-test
+  (:require [rx.lang.clojure.graph :as graph]
+            [rx.lang.clojure.core :as rx]
+            [rx.lang.clojure.future :as rx-future]
+            [rx.lang.clojure.blocking :as rx-blocking]
+            [clojure.test :refer [deftest testing is]]))
+
+(deftest test-let-o*
+  (testing "throws on cycle"
+    (is (thrown-with-msg? IllegalArgumentException #"Cycle found"
+                          (graph/let-o* {:a {:deps [:a]}}))))
+
+  (testing "throws on unknown"
+    (is (thrown-with-msg? IllegalArgumentException #"Unknown node"
+                          (graph/let-o* {:a {:deps [:b]}}))))
+
+  (testing "it works in a simple case"
+    (let [d {:a {:deps []
+                 :factory (fn [_] (rx/seq->o [1 2 3 4 5]))}
+             :b {:deps [:a]
+                 :factory (fn [{:keys [a]}] (rx/map #(* % %) a)) }
+             :c {:deps [:a :b]
+                 :factory (fn [{:keys [a b]}] (rx/map #(+ %1 %2) a b)) }
+             :d {:deps [:c :b]
+                 :factory (fn [{:keys [c b]}] (rx/map #(+ %1 %2) c b)) }
+             }
+          f (graph/let-o* d) ]
+      (println f)
+      ; (n^2 + n) + n^2
+      (is (= [3 10 21 36 55]
+             (rx-blocking/into [] (:d f)))))))
+
+(deftest test-let-o
+  (testing "it works"
+    (let [f (graph/let-o [?a (rx/seq->o [1 2 3])
+                          ?b (rx/seq->o [4 5 6])]
+              (rx/map + ?a ?b))]
+      (is (= [5 7 9]
+             (rx-blocking/into [] f)))))
+
+  (testing "it still works"
+    (is (= {:a 99 :b 100 :z "hi"}
+           (rx-blocking/single
+             (-> (let [z (rx/return "hi")] ; an observable from "somewhere else"
+                   (graph/let-o
+                     [?a (rx-future/future rx-future/default-runner (Thread/sleep 50) 99)
+                      ?b (rx-future/future rx-future/default-runner (Thread/sleep 500) 100)
+                      ?c (rx/map #(hash-map :a %1 :b %2 :z %3) ?a ?b ?z)
+                      ?z z]
+                     (rx/merge ?c)))))))))
+
+(deftest test-complicated-graph
+  ; These funcs model network requests for various stuff. They all return observable.
+  (let [request-vhs (fn []
+                      (rx-future/future-generator rx-future/default-runner
+                                                 [o]
+                                                 (Thread/sleep 50)
+                                                 (doseq [i (range 3)]
+                                                   (rx/on-next o {:id i}))))
+        request-user (fn [id]
+                       (rx-future/future rx-future/default-runner
+                                         (Thread/sleep (rand-int 250))
+                                         {:id id
+                                          :name (str "friend" id) }))
+        request-ab (fn [u]
+                     (rx-future/future rx-future/default-runner
+                                       (Thread/sleep (rand-int 250))
+                                       {:user-id (:id u)
+                                        :cell    (* 2 (:id u))}))
+
+        request-video-md (fn [v]
+                           (rx/return {:video v
+                                       :title (str "title" (:id v)) }))
+
+        ; Now we can stitch all these requests together into an rx graph to
+        ; produce a response.
+        o (graph/let-o [?user-info (rx-future/future rx-future/default-runner
+                                                     (Thread/sleep 20)
+                                                     {:name "Bob"
+                                                      :id 12345
+                                                      :friend-ids [1 2 3] })
+
+                        ?friends   (->> ?user-info
+                                        (rx/mapcat (fn [ui]
+                                                     (rx/mapcat request-user
+                                                                (rx/seq->o (:friend-ids ui))))))
+
+                        ?ab        (->> (rx/concat ?user-info ?friends)
+                                        (rx/mapcat request-ab))
+
+                        ?ab-lookup (->> ?ab
+                                        (rx/map (juxt :user-id #(dissoc % :user-id)))
+                                        (rx/into {}))
+
+                        ?vhs       (request-vhs)
+
+
+                        ?metadata  (->> ?vhs
+                                        (rx/mapcat request-video-md))]
+            (rx/map (fn [u m f ab-lookup]
+                      {:user    (dissoc u :friend-ids)
+                      :videos  m
+                      :friends (sort-by :id f)
+                      :ab      ab-lookup})
+                    ?user-info
+                    (rx/into [] ?metadata)
+                    (rx/into [] ?friends)
+                    ?ab-lookup))]
+
+    (is (= {:user {:name "Bob" :id 12345}
+            :videos [{:video {:id 0} :title "title0"}
+                     {:video {:id 1} :title "title1"}
+                     {:video {:id 2} :title "title2"}]
+            :friends [{:name "friend1" :id 1}{:name "friend2" :id 2}{:name "friend3" :id 3}]
+            :ab {12345 {:cell 24690} 1 {:cell 2} 2 {:cell 4} 3 {:cell 6}} }
+           (rx-blocking/single o)))))
+
+
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/realized_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/realized_test.clj
new file mode 100644
index 0000000000..3bf9b16872
--- /dev/null
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/realized_test.clj
@@ -0,0 +1,130 @@
+(ns rx.lang.clojure.realized-test
+  (:require [rx.lang.clojure.realized :as r]
+            [rx.lang.clojure.core :as rx]
+            [rx.lang.clojure.future :as rx-future]
+            [rx.lang.clojure.blocking :as rx-blocking]
+            [clojure.test :refer [deftest testing is]]))
+
+
+
+(deftest test-realized-map
+  (testing "Turns map of observables into observable of map"
+    (let [o (r/realized-map :a (r/all (rx/seq->o [1 2 3]))
+                               :a2 (rx/seq->o [99 100 101])
+                               :b (rx/return "hi")
+                               :c [(->> [1 2 3]
+                                       rx/seq->o
+                                       (rx/map #(* % %)))
+                                   next]
+                               :d (rx/return "just one")
+                               :e "just a value")
+          result (rx-blocking/single o)]
+      (is (= {:a [1 2 3]
+              :a2 101
+              :b "hi"
+              :c [4 9]
+              :d "just one"
+              :e "just a value" }
+             result)))))
+
+(deftest test-realized-map
+  (testing "works like realized-map, but takes a map instead of key/value pairs"
+    (is (= {:a [1 2]
+            :b 500 }
+           (->> {:a (r/all (rx/seq->o [1 2]))
+                 :b 500 }
+                r/realized-map*
+                rx-blocking/single)))))
+
+(deftest test-let-realized
+  (is (= {:a* 2
+          :b* 500
+          :c* 1000 }
+         (->> (r/let-realized [a [(rx/seq->o [1 2]) last]
+                               b 500
+                               c (rx/return 1000) ]
+                                 {:a* a
+                                  :b* b
+                                  :c* c })
+              rx-blocking/single))))
+
+(deftest test-only
+  (testing "raises IllegalStateException if sequence is empty"
+    (is (thrown-with-msg? IllegalStateException #"did not produce"
+                          (->> (r/let-realized [a (rx/seq->o [1 2])]
+                                               {:a a})
+                               rx-blocking/single)))
+    ; Just to be sure, make sure it goes through onError.
+    (let [values (atom [])
+          errors (atom [])]
+      (rx/subscribe (r/let-realized [a (rx/seq->o [1 2])]
+                              {:a a})
+                  #(swap! values conj %)
+                  #(swap! errors conj %))
+      (is (empty? @values))
+      (is (= 1 (count @errors)))
+      (let [[e] @errors]
+        (is (instance? IllegalStateException e))))))
+
+(deftest test-all
+  (testing "collects all values from an observable"
+    (is (= [1 2 3]
+           (->> (r/let-realized [a (r/all (rx/seq->o [1 2 3]))]
+                           a)
+                rx-blocking/single)))))
+
+; Playing with some expressing some of the video stuff with this.
+(comment
+  (->> (get-list-of-lists user-id)
+       (rx/mapcat (fn [list]
+                    (->> (video-list->videos list)
+                         (rx/take 10))))
+       (rx/mapcat (fn [video]
+                    (->> (r/let-realized [md (video->metadata video)
+                                             bm (video->bookmark video)
+                                             rt (video->rating video user-id)]
+                            {:id       (:id video)
+                             :title    (:title md)
+                             :length   (:duration md)
+                             :bookmark bm
+                             :rating   {:actual    (:actual-star-rating rt)
+                                        :average   (:average-star-rating rt)
+                                        :predicted (:predicted-star-rating rt) } })))))
+
+  (->> (get-list-of-lists user-id)
+       (rx/mapcat (fn [list]
+                    (->> (video-list->videos list)
+                         (rx/take 10))))
+       (rx/mapcat (fn [video]
+                 (->> (r/realized-map :md (video->metadata video)
+                                         :bm (video->bookmark video)
+                                         :rt (video->rating video user-id))
+                      (rx/map (fn [{:keys [md bm rt]}]
+                             {:id       (:id video)
+                              :title    (:title md)
+                              :length   (:duration md)
+                              :bookmark bm
+                              :rating   {:actual (:actual-star-rating rt)
+                                         :average (:average-star-rating rt)
+                                         :predicted (:predicted-star-rating rt) } }))))))
+
+  (->> (get-list-of-lists user-id)
+       (rx/mapcat (fn [list]
+                    (->> (video-list->videos list)
+                         (rx/take 10))))
+       (rx/mapcat (fn [video]
+                    (->> (r/realized-map :id (:id video)
+                                            :md [(video->metadata video)
+                                                 first
+                                                 #(select-keys % [:title :duration])]
+                                            :bookmark (video->bookmark video)
+                                            :rating [(video->rating video user-id)
+                                                     first
+                                                     #(hash-map :actual (:actual-star-rating %)
+                                                                :average (:average-star-rating %)
+                                                                :predicted (:predicted-star-rating %))])
+                         (rx/map (fn [m]
+                                   (-> m
+                                       (merge (:md m))
+                                       (dissoc :md)))))))))
+

From 80ba1b3bd041a3dcfd58d8c295ce45cdc6076fe1 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Tue, 18 Feb 2014 14:28:14 -0800
Subject: [PATCH 024/422] Replace chain with operators. General core cleanup

---
 .../src/main/clojure/rx/lang/clojure/core.clj | 230 ++++++++++--------
 .../clojure/rx/lang/clojure/core_test.clj     |  62 +++--
 2 files changed, 181 insertions(+), 111 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index e807882e4c..ac3a21e647 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -1,6 +1,6 @@
 (ns rx.lang.clojure.core
   (:refer-clojure :exclude [concat cons do drop drop-while empty
-                            filter future
+                            filter first future
                             interpose into keep keep-indexed
                             map mapcat map-indexed
                             merge next partition reduce reductions
@@ -10,14 +10,14 @@
             [rx.lang.clojure.base :as base]
             [rx.lang.clojure.graph :as graph]
             [rx.lang.clojure.realized :as realized])
-  (:import [rx Observable Observer Subscription]
+  (:import [rx Observable Observer Subscriber Subscription Observable$Operator Observable$OnSubscribe]
            [rx.observables BlockingObservable]
            [rx.subscriptions Subscriptions]
            [rx.util.functions Action0 Action1 Func0 Func1 Func2]))
 
 (set! *warn-on-reflection* true)
 
-(declare map map-indexed reduce take take-while)
+(declare concat map map-indexed reduce take take-while)
 
 (defn ^Func1 fn->predicate
   "Turn f into a predicate that returns true/false like Rx predicates should"
@@ -62,16 +62,58 @@
   ([^Observable o on-next-action on-error-action on-completed-action]
     (.subscribe o ^Action1 (iop/action* on-next-action) ^Action1 (iop/action* on-error-action) ^Action0 (iop/action* on-completed-action))))
 
-(defn chain
-  "Like subscribe, but any omitted handlers pass-through to the next observable."
-  ([from to]
-    (chain from to #(on-next to %)))
-  ([from to on-next-action]
-    (chain from to on-next-action #(on-error to %)))
-  ([from to on-next-action on-error-action]
-    (chain from to on-next-action on-error-action #(on-completed to)))
-  ([from to on-next-action on-error-action on-completed-action]
-    (subscribe from on-next-action on-error-action on-completed-action)))
+(defn ^Subscriber ->subscriber
+  ""
+  ([o on-next-action] (->subscriber o on-next-action nil nil))
+  ([o on-next-action on-error-action] (->subscriber o on-next-action on-error-action))
+  ([^Subscriber o on-next-action on-error-action on-completed-action]
+   (proxy [Subscriber] [o]
+     (onCompleted []
+       (if on-completed-action
+         (on-completed-action o)
+         (on-completed o)))
+     (onError [e]
+       (if on-error-action
+         (on-error-action o e)
+         (on-error o e)))
+     (onNext [t]
+       (if on-next-action
+         (on-next-action o t)
+         (on-next o t))))))
+
+(defn ^Observable$Operator ->operator
+  "Create a basic Operator with the given handler fns. If a handler is omitted or nil
+  it's treated as a pass-through.
+
+  on-next-action  Passed Subscriber and value
+  on-error-action Passed Throwable
+  on-completed-action No-args
+
+  See:
+  lift
+  rx.Observable$Operator
+  "
+  [input]
+  {:pre [(fn? input)]}
+  (reify Observable$Operator
+    (call [this o]
+      (input o))))
+
+(defn lift
+  "Lift the Operator op over the given Observable xs
+
+  Example:
+
+    (->> my-observable
+         (rx/lift (rx/->operator ...))
+         ...)
+
+  See:
+    rx.Observable/lift
+    ->operator
+  "
+  [^Observable$Operator op ^Observable xs]
+  (.lift xs op))
 
 (defn unsubscribe
   "Unsubscribe from Subscription s and return it."
@@ -79,6 +121,16 @@
   (.unsubscribe s)
   s)
 
+(defn unsubscribed?
+  "Returns true if the given Subscription (or Subscriber) is unsubscribed.
+
+  See:
+    rx.Observable/create
+    fn->o
+  "
+  [^Subscription s]
+  (.isUnsubscribed s))
+
 (defn ^Subscription fn->subscription
   "Create a new subscription that calls the given no-arg handler function when
   unsubscribe is called
@@ -89,6 +141,19 @@
   [handler]
   (Subscriptions/create ^Action0 (iop/action* handler)))
 
+(defn ^Observable fn->o
+  "Create an Observable from the given function.
+
+  When subscribed to, (f subscriber) is called at which point, f can start emitting values, etc.
+  The passed subscriber is of type rx.Subscriber.
+
+  See:
+    rx.Subscriber
+    rx.Observable/create
+  "
+  [f]
+  (Observable/create ^Observable$OnSubscribe (iop/action* f)))
+
 ;################################################################################
 
 (defn ^Observable never [] (Observable/never))
@@ -103,12 +168,6 @@
   [value]
   (Observable/just value))
 
-(defn ^Observable fn->o
-  "Create an observable from the given handler. When subscribed to, (f observer)
-  is called at which point, f can start emitting values, etc."
-  [f]
-  (Observable/create (iop/fn* f)))
-
 (defn ^Observable seq->o
   "Make an observable out of some seq-able thing. The rx equivalent of clojure.core/seq."
   [xs]
@@ -119,16 +178,17 @@
 ;################################################################################
 
 (defn cache
-  "caches the observable value so that multiple subscribers don't re-evaluate it"
+  "caches the observable value so that multiple subscribers don't re-evaluate it.
+
+  See:
+    rx.Observable/cache"
   [^Observable xs]
   (.cache xs))
 
 (defn cons
   "cons x to the beginning of xs"
   [x xs]
-  (fn->o (fn [target]
-           (on-next target x)
-           (chain xs target))))
+  (concat (return x) xs))
 
 (defn ^Observable concat
   "Concatenate the given Observables one after the another.
@@ -162,64 +222,46 @@
 
   Example:
 
-    (->> (rx/seq->o [1 2 3])
-         (rx/do println)
-        ...)
+  (->> (rx/seq->o [1 2 3])
+  (rx/do println)
+  ...)
 
-    Will print 1, 2, 3.
+  Will print 1, 2, 3.
   "
-  ([do-fn xs]
-   (fn->o (fn [target]
-            (let [state (atom {:sub   nil
-                               :error nil })
-                  on-next-fn (fn [v]
-                               ; since we may not be able to unsubscribe, drop
-                               ; anything after an error
-                               (let [{:keys [sub error]} @state]
-                                 (if-not error
-                                   (try
-                                     (do-fn v)
-                                     (on-next target v)
-                                     (catch Throwable e
-                                       (reset! state {:error e :sub nil})
-                                       (if sub
-                                         (unsubscribe sub))
-                                       (on-error target e))))))]
-              (let [sub (chain xs target on-next-fn)]
-                ; dependening on xs, this may not be reached until after the sequence
-                ; is complete.
-                (swap! state update-in [:sub] (constantly sub))
-                sub))))))
+  [do-fn xs]
+  (map #(do (do-fn %) %) xs))
 
 (defn ^Observable drop
   [n ^Observable xs]
   (.skip xs n))
 
 (defn ^Observable drop-while
-  [p xs]
-  (fn->o (fn [target]
-           (let [dropping (atom true)]
-             (chain xs
-                    target
-                    (fn [v]
-                      (when (or (not @dropping)
-                                (not (reset! dropping (p v))))
-                        (on-next target v))))))))
+  [p ^Observable xs]
+  (.skipWhile xs (fn->predicate p)))
 
 (defn ^Observable filter
   [p ^Observable xs]
   (.filter xs (fn->predicate p)))
 
+(defn ^Observable first
+  "Returns an Observable that emits the first item emitted by xs, or an
+  empty Observable if xs is empty.
+
+  See:
+    rx.Observable/takeFirst
+  "
+  [^Observable xs]
+  (.takeFirst xs))
+
 (defn interpose
   [sep xs]
-  (fn->o (fn [target]
-           (let [first? (atom true)]
-             (chain xs
-                    target
-                    (fn [v]
-                      (if-not (compare-and-set! first? true false)
-                        (on-next target sep))
-                      (on-next target v)))))))
+  (let [op (->operator (fn [o]
+                         (let [first? (atom true)]
+                           (->subscriber o (fn [o v]
+                                             (if-not (compare-and-set! first? true false)
+                                               (on-next o sep))
+                                             (on-next o v))))))]
+    (lift op xs)))
 
 (defn into
   "Returns an observable that emits a single value which is all of the
@@ -234,10 +276,6 @@
    .toList
    (map (partial clojure.core/into to))))
 
-(defn keep
-  [f xs]
-  (filter (complement nil?) (map xs f)))
-
 (defn keep
   [f xs]
   (filter (complement nil?) (map f xs)))
@@ -273,12 +311,13 @@
     clojure.core/map-indexed
   "
   [f xs]
-  (fn->o (fn [target]
-           (let [n (atom -1)]
-             (chain xs
-                    target
-                    (fn [v] (on-next target (f (swap! n inc) v))))))))
+  (let [op (->operator (fn [o]
+                         (let [n (atom -1)]
+                           (->subscriber o
+                                  (fn [o v] (on-next o (f (swap! n inc) v)))))))]
+    (lift op xs)))
 
+; TODO which merge goes here?
 (defn merge
   "
   Returns an observable that emits a single map that consists of the rest of the
@@ -296,7 +335,7 @@
   (reduce clojure.core/merge {} maps))
 
 (def next
-  "Returns an observable that emits all of the first element of the input observable.
+  "Returns an observable that emits all but the first element of the input observable.
 
   See:
     clojure.core/next
@@ -325,13 +364,10 @@
     clojure.core/some
   "
   [p ^Observable xs]
-  (fn->o (fn [target]
-           (chain xs
-                  target
-                  (fn [v]
-                    (when-let [result (p v)]
-                      (on-next target result)
-                      (on-completed target)))))))
+  (->> xs
+       (map p)
+       (filter identity)
+       first))
 
 (defn sort
   "Returns an observable that emits a single value which is a sorted sequence
@@ -387,14 +423,15 @@
   (.take xs n))
 
 (defn take-while
-  [p xs]
-  (fn->o (fn [target]
-           (chain xs
-                  target
-                  (fn [v]
-                    (if (p v)
-                      (on-next target v)
-                      (on-completed target)))))))
+  "Returns an Observable that emits xs until the first x such that
+  (p x) is falsey.
+
+  See:
+    clojure.core/take-while
+    rx.Observable/takeWhile
+  "
+  [p ^Observable xs]
+  (.takeWhile xs (fn->predicate p)))
 
 ;################################################################################;
 
@@ -402,9 +439,9 @@
   "Returns an Observable the simply emits the given exception with on-error
 
   See:
-    http://netflix.github.io/RxJava/javadoc/rx/Observable.html#error(java.lang.Exception)
+    rx.Observable/error
   "
-  [^Exception e]
+  [^Throwable e]
   (Observable/error e))
 
 (defn catch*
@@ -444,6 +481,9 @@
 
   The body of the catch is wrapped in an implicit (do). It must evaluate to an Observable.
 
+  Note that the source observable is the first argument so this won't mix well with ->>
+  threading.
+
   Example:
 
     (-> my-observable
@@ -504,9 +544,7 @@
     (generator* on-next 99)
   "
   [f & args]
-  (fn->o (-> (fn [observer]
-               (apply f observer args)
-               (Subscriptions/empty))
+  (fn->o (-> #(apply f % args)
              base/wrap-on-completed
              base/wrap-on-error)))
 
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 7af636345d..80652f461b 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -1,20 +1,7 @@
 (ns rx.lang.clojure.core-test
   (:require [rx.lang.clojure.core :as rx]
             [rx.lang.clojure.blocking :as b]
-            [clojure.test :refer [deftest is testing]]))
-(comment
-  (rx/subscribe
-    (->>
-      (rx/map (fn [a b] (hash-map :a a :b b)) (rx/seq->o [1 2 3 4 5 6])
-              (rx/seq->o ["x" "y" 9 10 "z"]))
-      (rx/map    #(update-in % [:a] (partial * 2)))
-      (rx/filter (comp not number? :b))
-      (rx/concat (rx/seq->o (range 3)))
-      (rx/drop 1)
-      (rx/take 6)
-      (rx/into []))
-    println
-    println))
+            [clojure.test :refer [deftest is testing are]]))
 
 (deftest test-observable?
   (is (rx/observable? (rx/return 99)))
@@ -27,6 +14,45 @@
       (rx/subscribe o (fn [v] (swap! called (fn [_] v))))
       (is (= 1 @called)))))
 
+(deftest test-fn->predicate
+  (are [f arg result] (= result (.call (rx/fn->predicate f) arg))
+       identity nil    false
+       identity false  false
+       identity 1      true
+       identity "true" true
+       identity true   true))
+
+(deftest test-fn->subscription
+  (let [called (atom 0)
+        s (rx/fn->subscription #(swap! called inc))]
+    (is (identical? s (rx/unsubscribe s)))
+    (is (= 1 @called))))
+
+(deftest test-unsubscribed?
+  (let [s (rx/fn->subscription #())]
+    (is (not (rx/unsubscribed? s)))
+    (rx/unsubscribe s)
+    (is (rx/unsubscribed? s))))
+
+
+(deftest test-fn->o
+  (let [o (rx/fn->o (fn [s]
+                      (rx/on-next s 0)
+                      (rx/on-next s 1)
+                      (when-not (rx/unsubscribed? s) (rx/on-next s 2))
+                      (rx/on-completed s)))]
+    (is (= [0 1 2] (b/into [] o)))))
+
+(deftest test-->operator
+  (let [o (rx/->operator #(rx/->subscriber %
+                                           (fn [o v]
+                                             (if (even? v)
+                                               (rx/on-next o v)))))
+        result (->> (rx/seq->o [1 2 3 4 5])
+                    (rx/lift o)
+                    (b/into []))]
+    (is (= [2 4] result))))
+
 (deftest test-generator
   (testing "calls on-completed automatically"
     (let [o (rx/generator [o])
@@ -38,7 +64,7 @@
     (let [expected (IllegalArgumentException. "hi")
           actual   (atom nil)]
       (rx/subscribe (rx/generator [o] (throw expected))
-                     (fn [v])
+                     #()
                      #(reset! actual %))
       (is (identical? expected @actual)))))
 
@@ -115,6 +141,12 @@
          (b/into [] (->> (rx/seq->o [:a :b :c :d :e :f :G :e])
                         (rx/filter #{:b :e :G}))))))
 
+(deftest test-first
+  (is (= [3]
+         (b/into [] (rx/first (rx/seq->o [3 4 5])))))
+  (is (= []
+         (b/into [] (rx/first (rx/empty))))))
+
 (deftest test-interpose
   (is (= (interpose \, [1 2 3])
          (b/into [] (rx/interpose \, (rx/seq->o [1 2 3]))))))

From da88202077ffb51833da41e0d515b3f92881e243 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Tue, 18 Feb 2014 14:57:22 -0800
Subject: [PATCH 025/422] Got rid of base. It was weird.

---
 .../src/main/clojure/rx/lang/clojure/base.clj | 75 --------------
 .../main/clojure/rx/lang/clojure/chunk.clj    |  3 +-
 .../src/main/clojure/rx/lang/clojure/core.clj | 99 +++++++++++++++----
 .../main/clojure/rx/lang/clojure/future.clj   | 19 ++--
 .../main/clojure/rx/lang/clojure/realized.clj | 17 ++--
 .../clojure/rx/lang/clojure/base_test.clj     | 38 -------
 .../clojure/rx/lang/clojure/core_test.clj     | 39 +++++++-
 .../clojure/rx/lang/clojure/graph_test.clj    |  2 +-
 8 files changed, 133 insertions(+), 159 deletions(-)
 delete mode 100644 language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj
 delete mode 100644 language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj
deleted file mode 100644
index 0d1c181062..0000000000
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/base.clj
+++ /dev/null
@@ -1,75 +0,0 @@
-(ns rx.lang.clojure.base
-  "Generic, low-level rx helpers."
-  (:refer-clojure :exclude [merge])
-  (:require [rx.lang.clojure.interop :as iop])
-  (:import [rx Observable Observer Subscription]
-           [rx.observables BlockingObservable]
-           [rx.subscriptions Subscriptions]))
-
-(def ^:private -ns- *ns*)
-(set! *warn-on-reflection* true)
-
-(defn wrap-on-completed
-  "Wrap handler with code that automaticaly calls rx.Observable.onCompleted."
-  [handler]
-  (fn [^Observer observer]
-    (handler observer)
-    (.onCompleted observer)))
-
-(defn wrap-on-error
-  "Wrap handler with code that automaticaly calls (on-error) if an exception is thrown"
-  [handler]
-  (fn [^Observer observer]
-    (try
-      (handler observer)
-      (catch Exception e
-        (.onError observer e)))))
-
-(defn ^Observable merge
-  "Observable.merge, renamed because merge means something else in Clojure
-
-  os is one of:
-
-    * An Iterable of Observables to merge
-    * An Observable<Observable<T>> to merge
-  "
-  [os]
-  (cond
-    (instance? Iterable os)
-      (Observable/merge (Observable/from ^Iterable os))
-    (instance? Observable os)
-      (Observable/merge ^Observable os)
-    :else
-      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
-
-(defn ^Observable merge-delay-error
-  "Observable.mergeDelayError, renamed because merge means something else in Clojure"
-  [os]
-  (cond
-    (instance? java.util.List os)
-      (Observable/mergeDelayError ^java.util.List os)
-    (instance? Observable os)
-      (Observable/mergeDelayError ^Observable os)
-    :else
-      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
-
-(defn ^Observable zip
-  "Observable.zip. You want map."
-  ([f ^Observable a ^Observable b] (Observable/zip a b (iop/fn* f)))
-  ([f ^Observable a ^Observable b ^Observable c] (Observable/zip a b c (iop/fn* f)))
-  ([f ^Observable a ^Observable b ^Observable c ^Observable d] (Observable/zip a b c d (iop/fn* f)))
-  ([f a b c d & more]
-    ; recurse on more and then pull everything together with 4 parameter version
-   (zip (fn [a b c more-value]
-          (apply f a b c more-value))
-        a
-        b
-        c
-        (apply zip vector d more))))
-
-(defmacro zip-let
-  [bindings & body]
-  (let [pairs  (clojure.core/partition 2 bindings)
-        names  (clojure.core/mapv clojure.core/first pairs)
-        values (clojure.core/map second pairs)]
-    `(zip (fn ~names ~@body) ~@values)))
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
index d44c26f2c2..303f8cc090 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
@@ -1,7 +1,6 @@
 (ns rx.lang.clojure.chunk
   (:refer-clojure :exclude [chunk])
-  (:require [rx.lang.clojure.core :as rx]
-            [rx.lang.clojure.base :as rx-base]))
+  (:require [rx.lang.clojure.core :as rx]))
 
 (def ^:private -ns- *ns*)
 (set! *warn-on-reflection* true)
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index ac3a21e647..308e363dc2 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -7,7 +7,6 @@
                             rest seq some sort sort-by split-with
                             take take-while throw])
   (:require [rx.lang.clojure.interop :as iop]
-            [rx.lang.clojure.base :as base]
             [rx.lang.clojure.graph :as graph]
             [rx.lang.clojure.realized :as realized])
   (:import [rx Observable Observer Subscriber Subscription Observable$Operator Observable$OnSubscribe]
@@ -156,6 +155,81 @@
 
 ;################################################################################
 
+(defn wrap-on-completed
+  "Wrap handler with code that automaticaly calls rx.Observable.onCompleted."
+  [handler]
+  (fn [^Observer observer]
+    (handler observer)
+    (.onCompleted observer)))
+
+(defn wrap-on-error
+  "Wrap handler with code that automaticaly calls (on-error) if an exception is thrown"
+  [handler]
+  (fn [^Observer observer]
+    (try
+      (handler observer)
+      (catch Throwable e
+        (.onError observer e)))))
+
+(defn ^Observable merge
+  "Observable.merge, renamed because merge means something else in Clojure
+
+  os is one of:
+
+    * An Iterable of Observables to merge
+    * An Observable<Observable<T>> to merge
+
+  If you want clojure.core/merge, it's just this:
+
+    (rx/reduce clojure.core/merge {} maps)
+
+  "
+  [os]
+  (cond
+    (instance? Iterable os)
+      (Observable/merge (Observable/from ^Iterable os))
+    (instance? Observable os)
+      (Observable/merge ^Observable os)
+    :else
+      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
+
+(defn ^Observable merge-delay-error
+  "Observable.mergeDelayError, renamed because merge means something else in Clojure"
+  [os]
+  (cond
+    (instance? java.util.List os)
+      (Observable/mergeDelayError ^java.util.List os)
+    (instance? Observable os)
+      (Observable/mergeDelayError ^Observable os)
+    :else
+      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
+
+(defn ^Observable zip
+  "Observable.zip. You want map."
+  ([f ^Observable a ^Observable b] (Observable/zip a b (iop/fn* f)))
+  ([f ^Observable a ^Observable b ^Observable c] (Observable/zip a b c (iop/fn* f)))
+  ([f ^Observable a ^Observable b ^Observable c ^Observable d] (Observable/zip a b c d (iop/fn* f)))
+  ([f a b c d & more]
+    ; recurse on more and then pull everything together with 4 parameter version
+   (zip (fn [a b c more-value]
+          (apply f a b c more-value))
+        a
+        b
+        c
+        (apply zip vector d more))))
+
+(defmacro zip-let
+  [bindings & body]
+  (let [pairs  (clojure.core/partition 2 bindings)
+        names  (clojure.core/mapv clojure.core/first pairs)
+        values (clojure.core/map second pairs)]
+    `(zip (fn ~names ~@body) ~@values)))
+;################################################################################
+
+
+
+
+
 (defn ^Observable never [] (Observable/never))
 (defn ^Observable empty [] (Observable/empty))
 
@@ -288,7 +362,7 @@
   "Map a function over an observable sequence. Unlike clojure.core/map, only supports up
   to 4 simultaneous source sequences at the moment."
   ([f ^Observable xs] (.map xs (iop/fn* f)))
-  ([f xs & observables] (apply base/zip f xs observables)))
+  ([f xs & observables] (apply zip f xs observables)))
 
 (defn ^Observable mapcat
   "Returns an observable which, for each value x in xs, calls (f x), which must
@@ -317,23 +391,6 @@
                                   (fn [o v] (on-next o (f (swap! n inc) v)))))))]
     (lift op xs)))
 
-; TODO which merge goes here?
-(defn merge
-  "
-  Returns an observable that emits a single map that consists of the rest of the
-  maps emitted by the input observable conj-ed onto the first.  If a key occurs
-  in more than one map, the mapping from the latter (left-to-right) will be the
-  mapping in the result.
-
-  NOTE: This is very different from rx.Observable/merge. See rx.base/merge for that
-  one.
-
-  See:
-    clojure.core/merge
-  "
-  [maps]
-  (reduce clojure.core/merge {} maps))
-
 (def next
   "Returns an observable that emits all but the first element of the input observable.
 
@@ -545,8 +602,8 @@
   "
   [f & args]
   (fn->o (-> #(apply f % args)
-             base/wrap-on-completed
-             base/wrap-on-error)))
+             wrap-on-completed
+             wrap-on-error)))
 
 (defmacro generator
   "Create an observable that executes body which should emit a sequence. bindings
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
index 7f6a78761d..38fc8fa461 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
@@ -1,8 +1,7 @@
 (ns rx.lang.clojure.future
   (:refer-clojure :exclude [future])
   (:require [rx.lang.clojure.interop :as iop]
-            [rx.lang.clojure.core :as rx :refer [fn->o fn->subscription]]
-            [rx.lang.clojure.base :as base]))
+            [rx.lang.clojure.core :as rx]))
 
 (def ^:private -ns- *ns*)
 (set! *warn-on-reflection* true)
@@ -26,13 +25,13 @@
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
-  (fn->o (fn [observer]
+  (rx/fn->o (fn [observer]
            (let [wrapped (-> (fn [o]
                                (apply f o args))
-                             base/wrap-on-completed
-                             base/wrap-on-error)
+                             rx/wrap-on-completed
+                             rx/wrap-on-error)
                  fu      (runner #(wrapped observer))]
-             (fn->subscription #(future-cancel fu))))))
+             (rx/fn->subscription #(future-cancel fu))))))
 
 (defmacro future-generator
   "Same as rx/generator macro except body is invoked in a separate thread.
@@ -60,12 +59,12 @@
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
-  (fn->o (fn [observer]
+  (rx/fn->o (fn [observer]
            (let [wrapped (-> #(rx/on-next % (apply f args))
-                             base/wrap-on-completed
-                             base/wrap-on-error)
+                             rx/wrap-on-completed
+                             rx/wrap-on-error)
                  fu      (runner #(wrapped observer))]
-             (fn->subscription #(future-cancel fu))))))
+             (rx/fn->subscription #(future-cancel fu))))))
 
 (defmacro future
   "Executes body in a separate thread and passes the single result to onNext.
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
index 7747c71881..e0b455af14 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
@@ -1,6 +1,5 @@
 (ns rx.lang.clojure.realized
-  (:require [rx.lang.clojure.interop :as iop]
-            [rx.lang.clojure.base :as rx-base]))
+  (:require [rx.lang.clojure.interop :as iop]))
 
 (def ^:private -ns- *ns*)
 (set! *warn-on-reflection* true)
@@ -62,10 +61,12 @@
   single key maps, merging and then folding all the separate maps together. So code
   like this:
 
-    (rx/merge (rx-base/merge (->> (user-info-o user-id)
-                                  (rx/map (fn [u] {:user u})))
-                             (->> (user-likes-o user-id)
-                                  (rx/map (fn [u] {:likes u})))))
+    ; TODO update
+    (->> (rx/merge (->> (user-info-o user-id)
+                             (rx/map (fn [u] {:user u})))
+                        (->> (user-likes-o user-id)
+                             (rx/map (fn [u] {:likes u}))))
+         (rx/reduce merge {}))
 
   becomes:
 
@@ -86,8 +87,8 @@
                             .toList
                             (.map (iop/fn [list] {k (f list)})))))))]
 
-    (-> o
-        rx-base/merge ; funnel all the observables into a single sequence
+    (-> ^Iterable o
+        (rx.Observable/merge) ; funnel all the observables into a single sequence
         (.reduce {} (iop/fn* merge))))) ; do the map merge dance
 
 (defn ^rx.Observable realized-map*
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj
deleted file mode 100644
index 985e7eeb1f..0000000000
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/base_test.clj
+++ /dev/null
@@ -1,38 +0,0 @@
-(ns rx.lang.clojure.base-test
-  (:require [rx.lang.clojure.core :as rx]
-            [rx.lang.clojure.base :as b]
-            [rx.lang.clojure.blocking :as blocking]
-            [rx.lang.clojure.future :as f]
-            )
-  (:require [clojure.test :refer [deftest testing is]]))
-
-(deftest test-zip
-  (testing "is happy with less than 4 args"
-    (is (= [[1 2 3]] (blocking/into [] (b/zip vector
-                                        (rx/seq->o [1]) (rx/seq->o [2]) (rx/seq->o [3]))))))
-  (testing "is happy with more than 4 args"
-    (is (= [[1 2 3 4 5 6 7 8]]
-           (blocking/into [] (b/zip vector
-                              (rx/seq->o [1])
-                              (rx/seq->o [2])
-                              (rx/seq->o [3])
-                              (rx/seq->o [4])
-                              (rx/seq->o [5])
-                              (rx/seq->o [6])
-                              (rx/seq->o [7])
-                              (rx/seq->o [8])))))))
-
-(deftest test-merge
-  (is (= [[1 3 5] [2 4 6]]
-         (let [r (blocking/into []
-                   (b/merge [(f/future-generator f/default-runner [o]
-                                                   (doseq [x [1 3 5]]
-                                                     (Thread/sleep 10)
-                                                     (rx/on-next o x)))
-                              (f/future-generator f/default-runner [o]
-                                                   (doseq [x [2 4 6]]
-                                                     (Thread/sleep 10)
-                                                     (rx/on-next o x)))]))]
-           ; make sure each sequence maintained original order
-           [(keep #{1 3 5} r)
-            (keep #{2 4 6} r) ]))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 80652f461b..2fa3daa0cd 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -1,6 +1,7 @@
 (ns rx.lang.clojure.core-test
   (:require [rx.lang.clojure.core :as rx]
             [rx.lang.clojure.blocking :as b]
+            [rx.lang.clojure.future :as f]
             [clojure.test :refer [deftest is testing are]]))
 
 (deftest test-observable?
@@ -53,6 +54,37 @@
                     (b/into []))]
     (is (= [2 4] result))))
 
+(deftest test-zip
+  (testing "is happy with less than 4 args"
+    (is (= [[1 2 3]] (b/into [] (rx/zip vector
+                                        (rx/seq->o [1]) (rx/seq->o [2]) (rx/seq->o [3]))))))
+  (testing "is happy with more than 4 args"
+    (is (= [[1 2 3 4 5 6 7 8]]
+           (b/into [] (rx/zip vector
+                              (rx/seq->o [1])
+                              (rx/seq->o [2])
+                              (rx/seq->o [3])
+                              (rx/seq->o [4])
+                              (rx/seq->o [5])
+                              (rx/seq->o [6])
+                              (rx/seq->o [7])
+                              (rx/seq->o [8])))))))
+
+(deftest test-merge
+  (is (= [[1 3 5] [2 4 6]]
+         (let [r (b/into []
+                   (rx/merge [(f/future-generator f/default-runner [o]
+                                                   (doseq [x [1 3 5]]
+                                                     (Thread/sleep 10)
+                                                     (rx/on-next o x)))
+                              (f/future-generator f/default-runner [o]
+                                                   (doseq [x [2 4 6]]
+                                                     (Thread/sleep 10)
+                                                     (rx/on-next o x)))]))]
+           ; make sure each sequence maintained original order
+           [(keep #{1 3 5} r)
+            (keep #{2 4 6} r) ]))))
+
 (deftest test-generator
   (testing "calls on-completed automatically"
     (let [o (rx/generator [o])
@@ -209,10 +241,6 @@
   (is (= (map-indexed vector [:a :b :c])
          (b/into [] (rx/map-indexed vector (rx/seq->o [:a :b :c]))))))
 
-(deftest test-merge
-  (is (= [{:a 1 :b 2 :c 3 :d 4}]
-         (b/into [] (rx/merge (rx/seq->o [{:a 1 :d 0} {:b 2} {:c 3} {:d 4} ]))))))
-
 (deftest test-mapcat
   (let [f  (fn [v] [v (* v v)])
         xs (range 10)]
@@ -361,6 +389,7 @@
         (is (= "got it" @called))
         (is (identical? expected @completed))))))
 
+
 ;################################################################################
 
 (deftest test-graph-imports
@@ -381,3 +410,5 @@
                                 b (rx/return 2)]
                 {:a a :b b})
               b/single))))
+
+
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
index 2b3fdde98c..cd3cf59788 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
@@ -47,7 +47,7 @@
                       ?b (rx-future/future rx-future/default-runner (Thread/sleep 500) 100)
                       ?c (rx/map #(hash-map :a %1 :b %2 :z %3) ?a ?b ?z)
                       ?z z]
-                     (rx/merge ?c)))))))))
+                     (rx/reduce merge {} ?c)))))))))
 
 (deftest test-complicated-graph
   ; These funcs model network requests for various stuff. They all return observable.

From 236cbdb7fd227f17869ed854e329dd95465d7253 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Tue, 18 Feb 2014 17:38:51 -0800
Subject: [PATCH 026/422] Clean up future stuff and docs

---
 .../src/main/clojure/rx/lang/clojure/core.clj | 83 ++++++++++++-------
 .../main/clojure/rx/lang/clojure/future.clj   | 43 +++++++---
 .../clojure/rx/lang/clojure/core_test.clj     |  4 +-
 .../clojure/rx/lang/clojure/future_test.clj   | 67 ++++++++++-----
 4 files changed, 131 insertions(+), 66 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 308e363dc2..938c68cdc3 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -9,7 +9,10 @@
   (:require [rx.lang.clojure.interop :as iop]
             [rx.lang.clojure.graph :as graph]
             [rx.lang.clojure.realized :as realized])
-  (:import [rx Observable Observer Subscriber Subscription Observable$Operator Observable$OnSubscribe]
+  (:import [rx
+            Observable
+            Observer Observable$Operator Observable$OnSubscribe
+            Subscriber Subscription]
            [rx.observables BlockingObservable]
            [rx.subscriptions Subscriptions]
            [rx.util.functions Action0 Action1 Func0 Func1 Func2]))
@@ -47,24 +50,29 @@
   [^Observer o e]
   (.onError o e))
 
-(defn on-error-return
-  [^Observable o f]
-  (.onErrorReturn o f))
-
 ;################################################################################
 
 (defn ^Subscription subscribe
+
   ([^Observable o on-next-action]
-    (.subscribe o ^Action1 (iop/action* on-next-action)))
+    (.subscribe o
+                ^Action1 (iop/action* on-next-action)))
+
   ([^Observable o on-next-action on-error-action]
-    (.subscribe o ^Action1 (iop/action* on-next-action) ^Action1 (iop/action* on-error-action)))
+    (.subscribe o
+                ^Action1 (iop/action* on-next-action)
+                ^Action1 (iop/action* on-error-action)))
+
   ([^Observable o on-next-action on-error-action on-completed-action]
-    (.subscribe o ^Action1 (iop/action* on-next-action) ^Action1 (iop/action* on-error-action) ^Action0 (iop/action* on-completed-action))))
+    (.subscribe o
+                ^Action1 (iop/action* on-next-action)
+                ^Action1 (iop/action* on-error-action)
+                ^Action0 (iop/action* on-completed-action))))
 
 (defn ^Subscriber ->subscriber
   ""
   ([o on-next-action] (->subscriber o on-next-action nil nil))
-  ([o on-next-action on-error-action] (->subscriber o on-next-action on-error-action))
+  ([o on-next-action on-error-action] (->subscriber o on-next-action on-error-action nil))
   ([^Subscriber o on-next-action on-error-action on-completed-action]
    (proxy [Subscriber] [o]
      (onCompleted []
@@ -80,8 +88,8 @@
          (on-next-action o t)
          (on-next o t))))))
 
-(defn ^Observable$Operator ->operator
-  "Create a basic Operator with the given handler fns. If a handler is omitted or nil
+(defn ^Observable$Operator fn->operator
+  "Create a basic Operator with f. If a handler is omitted or nil
   it's treated as a pass-through.
 
   on-next-action  Passed Subscriber and value
@@ -92,11 +100,11 @@
   lift
   rx.Observable$Operator
   "
-  [input]
-  {:pre [(fn? input)]}
+  [f]
+  {:pre [(fn? f)]}
   (reify Observable$Operator
     (call [this o]
-      (input o))))
+      (f o))))
 
 (defn lift
   "Lift the Operator op over the given Observable xs
@@ -104,12 +112,12 @@
   Example:
 
     (->> my-observable
-         (rx/lift (rx/->operator ...))
+         (rx/lift (rx/fn->operator ...))
          ...)
 
   See:
     rx.Observable/lift
-    ->operator
+    fn->operator
   "
   [^Observable$Operator op ^Observable xs]
   (.lift xs op))
@@ -160,7 +168,8 @@
   [handler]
   (fn [^Observer observer]
     (handler observer)
-    (.onCompleted observer)))
+    (when-not (unsubscribed? observer)
+      (.onCompleted observer))))
 
 (defn wrap-on-error
   "Wrap handler with code that automaticaly calls (on-error) if an exception is thrown"
@@ -169,7 +178,8 @@
     (try
       (handler observer)
       (catch Throwable e
-        (.onError observer e)))))
+        (when-not (unsubscribed? observer)
+          (.onError observer e))))))
 
 (defn ^Observable merge
   "Observable.merge, renamed because merge means something else in Clojure
@@ -194,7 +204,7 @@
       (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
 
 (defn ^Observable merge-delay-error
-  "Observable.mergeDelayError, renamed because merge means something else in Clojure"
+  "Observable.mergeDelayError"
   [os]
   (cond
     (instance? java.util.List os)
@@ -205,7 +215,7 @@
       (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
 
 (defn ^Observable zip
-  "Observable.zip. You want map."
+  "rx.Observable.zip. You want map."
   ([f ^Observable a ^Observable b] (Observable/zip a b (iop/fn* f)))
   ([f ^Observable a ^Observable b ^Observable c] (Observable/zip a b c (iop/fn* f)))
   ([f ^Observable a ^Observable b ^Observable c ^Observable d] (Observable/zip a b c d (iop/fn* f)))
@@ -224,20 +234,32 @@
         names  (clojure.core/mapv clojure.core/first pairs)
         values (clojure.core/map second pairs)]
     `(zip (fn ~names ~@body) ~@values)))
-;################################################################################
 
+;################################################################################
 
+(defn ^Observable never
+  "Returns an Observable that never emits any values and never completes.
 
+  See:
+    rx.Observable/never
+  "
+  []
+  (Observable/never))
 
+(defn ^Observable empty
+  "Returns an Observable that completes immediately without emitting any values.
 
-(defn ^Observable never [] (Observable/never))
-(defn ^Observable empty [] (Observable/empty))
+  See:
+    rx.Observable/empty
+  "
+  []
+  (Observable/empty))
 
 (defn ^Observable return
   "Returns an observable that emits a single value.
 
   See:
-    Observable/just
+    rx.Observable/just
   "
   [value]
   (Observable/just value))
@@ -329,7 +351,7 @@
 
 (defn interpose
   [sep xs]
-  (let [op (->operator (fn [o]
+  (let [op (fn->operator (fn [o]
                          (let [first? (atom true)]
                            (->subscriber o (fn [o v]
                                              (if-not (compare-and-set! first? true false)
@@ -385,7 +407,7 @@
     clojure.core/map-indexed
   "
   [f xs]
-  (let [op (->operator (fn [o]
+  (let [op (fn->operator (fn [o]
                          (let [n (atom -1)]
                            (->subscriber o
                                   (fn [o v] (on-next o (f (swap! n inc) v)))))))]
@@ -589,16 +611,17 @@
 ;################################################################################;
 
 (defn generator*
-  "Creates an observable that calls (f observable & args) which should emit a sequence.
+  "Creates an observable that calls (f observable & args) which should emit values
+  with (rx/on-next observable value).
 
   Automatically calls on-completed on return, or on-error if any exception is thrown.
 
-  Subscribers will block.
+  f should exit early if (rx/unsubscribed? observable) returns true
 
   Examples:
 
     ; An observable that emits just 99
-    (generator* on-next 99)
+    (rx/generator* on-next 99)
   "
   [f & args]
   (fn->o (-> #(apply f % args)
@@ -611,7 +634,7 @@
 
   Automatically calls on-completed on return, or on-error if any exception is thrown.
 
-  Subscribe will block.
+  The body should exit early if (rx/unsubscribed? observable) returns true
 
   Examples:
 
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
index 38fc8fa461..ac8d29f5e6 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
@@ -1,4 +1,7 @@
 (ns rx.lang.clojure.future
+  "Functions and macros for making rx-ified futures. That is, run some code in some
+   other thread and return an Observable of its result.
+  "
   (:refer-clojure :exclude [future])
   (:require [rx.lang.clojure.interop :as iop]
             [rx.lang.clojure.core :as rx]))
@@ -17,7 +20,8 @@
   runner is a function that takes a no-arg function argument and returns a future
   representing the execution of that function.
 
-  subscribe will not block.
+  Returns an Observable. If the subscriber unsubscribes, the future will be canceled
+  with clojure.core/future-cancel
 
   See:
     rx.lang.clojure.core/generator*
@@ -25,13 +29,14 @@
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
-  (rx/fn->o (fn [observer]
-           (let [wrapped (-> (fn [o]
-                               (apply f o args))
-                             rx/wrap-on-completed
-                             rx/wrap-on-error)
-                 fu      (runner #(wrapped observer))]
-             (rx/fn->subscription #(future-cancel fu))))))
+  (rx/fn->o (fn [^rx.Subscriber observer]
+              (let [wrapped (-> (fn [o]
+                                  (apply f o args))
+                                rx/wrap-on-completed
+                                rx/wrap-on-error)
+                    fu      (runner #(wrapped observer))]
+              (.add observer
+                    (rx/fn->subscription #(future-cancel fu)))))))
 
 (defmacro future-generator
   "Same as rx/generator macro except body is invoked in a separate thread.
@@ -39,7 +44,16 @@
   runner is a function that takes a no-arg function argument and returns a future
   representing the execution of that function.
 
-  subscribe will not block.
+  Returns an Observable. If the subscriber unsubscribes, the future will be canceled
+  with clojure.core/future-cancel
+
+  Example:
+
+    (future-generator default-runner
+      [o]
+      (rx/on-next o 1)
+      (Thread/sleep 1000)
+      (rx/on-next o 2))
 
   See:
     rx.lang.clojure.core/generator*
@@ -55,22 +69,25 @@
   runner is a function that takes a no-arg function argument and returns a future
   representing the execution of that function.
 
-  Returns an Observable.
+  Returns an Observable. If the subscriber unsubscribes, the future will be canceled
+  with clojure.core/future-cancel
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
-  (rx/fn->o (fn [observer]
+  (rx/fn->o (fn [^rx.Subscriber observer]
            (let [wrapped (-> #(rx/on-next % (apply f args))
                              rx/wrap-on-completed
                              rx/wrap-on-error)
                  fu      (runner #(wrapped observer))]
-             (rx/fn->subscription #(future-cancel fu))))))
+             (.add observer
+                   (rx/fn->subscription #(future-cancel fu)))))))
 
 (defmacro future
   "Executes body in a separate thread and passes the single result to onNext.
   If an exception occurs, onError is called.
 
-  Returns an Observable
+  Returns an Observable. If the subscriber unsubscribes, the future will be canceled
+  with clojure.core/future-cancel
 
   runner is a function that takes a no-arg function argument and returns a future
   representing the execution of that function.
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 2fa3daa0cd..c9300fb739 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -44,8 +44,8 @@
                       (rx/on-completed s)))]
     (is (= [0 1 2] (b/into [] o)))))
 
-(deftest test-->operator
-  (let [o (rx/->operator #(rx/->subscriber %
+(deftest test-fn->operator
+  (let [o (rx/fn->operator #(rx/->subscriber %
                                            (fn [o v]
                                              (if (even? v)
                                                (rx/on-next o v)))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
index dccf89c908..46682ddc44 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
@@ -1,37 +1,62 @@
 (ns rx.lang.clojure.future-test
   (:require [rx.lang.clojure.core :as rx]
-            [rx.lang.clojure.blocking :as blocking]
+            [rx.lang.clojure.blocking :as b]
             [rx.lang.clojure.future :as f])
   (:require [clojure.test :refer [deftest testing is]]))
 
 (deftest test-future-generator
   (is (not= [(.getId (Thread/currentThread))]
-            (blocking/into []
+            (b/into []
                       (f/future-generator f/default-runner
                         [observer]
                         (rx/on-next observer (.getId (Thread/currentThread))))))))
 
 (deftest test-future
-  (is (= [15] (blocking/into [] (f/future* f/default-runner + 1 2 3 4 5))))
-  (is (= [15] (blocking/into [] (f/future f/default-runner (println "HI") (+ 1 2 3 4 5))))) )
+  (is (= [15] (b/into [] (f/future* f/default-runner + 1 2 3 4 5))))
+  (is (= [15] (b/into [] (f/future f/default-runner (println "HI") (+ 1 2 3 4 5))))) )
 
+(deftest test-future-exception
+  (is (= "Caught: boo"
+         (-> (f/future f/default-runner (throw (java.io.FileNotFoundException. "boo")))
+             (rx/catch java.io.FileNotFoundException e
+               (rx/return (str "Caught: " (.getMessage e))))
+             (b/single)))))
 
-(comment (rx/subscribe (f/future* f/default-runner + 1 2 3 4 5)
-                        (fn [v] (println "RESULT: " v))
-                        (fn [e] (println "ERROR: " e))
-                        #(println "COMPLETED")))
+(deftest test-future-cancel
+  (let [exited? (atom nil)
+        o (f/future f/default-runner
+            (Thread/sleep 1000)
+            (reset! exited? true)
+            "WAT")
+        result (->> o
+                    (rx/take 0)
+                    (b/into []))]
+    (Thread/sleep 2000)
+    (is (= [nil []]
+           [@exited? result]))))
 
-(comment (rx/subscribe (f/future f/default-runner
-                          (Thread/sleep 5000)
-                          (+ 100 200))
-                        (fn [v] (println "RESULT: " v))
-                        (fn [e] (println "ERROR: " e))
-                        #(println "COMPLETED")))
-
-(comment (rx/subscribe (f/future f/default-runner
-                          (Thread/sleep 2000)
-                          (throw (Exception. "Failed future")))
-                        (fn [v] (println "RESULT: " v))
-                        (fn [e] (println "ERROR: " e))
-                        #(println "COMPLETED")))
+(deftest test-future-generator-cancel
+  (let [exited? (atom nil)
+        o (f/future-generator f/default-runner
+            [o]
+            (rx/on-next o "FIRST")
+            (Thread/sleep 1000)
+            (reset! exited? true))
+        result (->> o
+                    (rx/take 1)
+                    (b/into []))]
+    (Thread/sleep 2000)
+    (is (= [nil ["FIRST"]]
+           [@exited? result]))))
 
+(deftest test-future-generator-exception
+  (let [e (java.io.FileNotFoundException. "snake")]
+    (is (= [1 2 e]
+           (b/into [] (-> (f/future-generator
+                            f/default-runner
+                            [o]
+                            (rx/on-next o 1)
+                            (rx/on-next o 2)
+                            (throw e))
+                          (rx/catch java.io.FileNotFoundException e
+                            (rx/return e))))))))

From bfc03d6a2f5590bf1c7f53526cbf4ade5ca12c25 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 00:02:16 -0800
Subject: [PATCH 027/422] Some more core operators

---
 .../src/main/clojure/rx/lang/clojure/core.clj | 244 ++++++++++++++----
 .../clojure/rx/lang/clojure/core_test.clj     | 120 ++++++---
 2 files changed, 283 insertions(+), 81 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 938c68cdc3..4e50cef03c 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -1,9 +1,12 @@
 (ns rx.lang.clojure.core
-  (:refer-clojure :exclude [concat cons do drop drop-while empty
+  (:refer-clojure :exclude [concat cons count cycle
+                            distinct do drop drop-while
+                            empty every?
                             filter first future
-                            interpose into keep keep-indexed
+                            interpose into
+                            keep keep-indexed
                             map mapcat map-indexed
-                            merge next partition reduce reductions
+                            merge next nth partition reduce reductions
                             rest seq some sort sort-by split-with
                             take take-while throw])
   (:require [rx.lang.clojure.interop :as iop]
@@ -128,6 +131,28 @@
   (.unsubscribe s)
   s)
 
+(defn subscribe-on
+  "Cause subscriptions to the given observable to happen on the given scheduler.
+
+  Returns a new Observable.
+
+  See:
+    rx.Observable/subscribeOn
+  "
+  [^rx.Scheduler s ^Observable xs]
+  (.subscribeOn xs s))
+
+(defn unsubscribe-on
+  "Cause unsubscriptions from the given observable to happen on the given scheduler.
+
+  Returns a new Observable.
+
+  See:
+    rx.Observable/unsubscribeOn
+  "
+  [^rx.Scheduler s ^Observable xs]
+  (.unsubscribeOn xs s))
+
 (defn unsubscribed?
   "Returns true if the given Subscription (or Subscriber) is unsubscribed.
 
@@ -161,8 +186,6 @@
   [f]
   (Observable/create ^Observable$OnSubscribe (iop/action* f)))
 
-;################################################################################
-
 (defn wrap-on-completed
   "Wrap handler with code that automaticaly calls rx.Observable.onCompleted."
   [handler]
@@ -181,6 +204,14 @@
         (when-not (unsubscribed? observer)
           (.onError observer e))))))
 
+;################################################################################
+
+(defn synchronize
+  ([^Observable xs]
+  (.synchronize xs))
+  ([lock ^Observable xs]
+  (.synchronize xs lock)))
+
 (defn ^Observable merge
   "Observable.merge, renamed because merge means something else in Clojure
 
@@ -214,26 +245,6 @@
     :else
       (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
 
-(defn ^Observable zip
-  "rx.Observable.zip. You want map."
-  ([f ^Observable a ^Observable b] (Observable/zip a b (iop/fn* f)))
-  ([f ^Observable a ^Observable b ^Observable c] (Observable/zip a b c (iop/fn* f)))
-  ([f ^Observable a ^Observable b ^Observable c ^Observable d] (Observable/zip a b c d (iop/fn* f)))
-  ([f a b c d & more]
-    ; recurse on more and then pull everything together with 4 parameter version
-   (zip (fn [a b c more-value]
-          (apply f a b c more-value))
-        a
-        b
-        c
-        (apply zip vector d more))))
-
-(defmacro zip-let
-  [bindings & body]
-  (let [pairs  (clojure.core/partition 2 bindings)
-        names  (clojure.core/mapv clojure.core/first pairs)
-        values (clojure.core/map second pairs)]
-    `(zip (fn ~names ~@body) ~@values)))
 
 ;################################################################################
 
@@ -309,6 +320,50 @@
   [^Observable os]
   (Observable/concat os))
 
+(defn count
+  "Returns an Observable that emits the number of items is xs as a long.
+
+  See:
+    rx.Observable/longCount
+  "
+  [^Observable xs]
+  (.longCount xs))
+
+(defn cycle
+  "Returns an Observable that emits the items of xs repeatedly, forever.
+
+  TODO: Other sigs.
+
+  See:
+    rx.Observable/repeat
+    clojure.core/cycle
+  "
+  [^Observable xs]
+  (.repeat xs))
+
+(defn distinct
+  "Returns an Observable of the elements of Observable xs with duplicates
+  removed. key-fn, if provided, is a one arg function that determines the
+  key used to determined duplicates. key-fn defaults to identity.
+
+  This implementation doesn't use rx.Observable/distinct because it doesn't
+  honor Clojure's equality semantics.
+
+  See:
+    clojure.core/distinct
+  "
+  ([xs] (distinct identity xs))
+  ([key-fn ^Observable xs]
+  (let [op (fn->operator (fn [o]
+                           (let [seen (atom #{})]
+                             (->subscriber o
+                                           (fn [o v]
+                                             (let [key (key-fn v)]
+                                               (when-not (contains? @seen key)
+                                                 (swap! seen conj key)
+                                                 (on-next o v))))))))]
+    (lift op xs))))
+
 (defn ^Observable do
   "Returns a new Observable that, for each x in Observable xs, executes (do-fn x),
   presumably for its side effects, and then passes x along unchanged.
@@ -318,14 +373,17 @@
 
   Example:
 
-  (->> (rx/seq->o [1 2 3])
-  (rx/do println)
-  ...)
+    (->> (rx/seq->o [1 2 3])
+    (rx/do println)
+    ...)
 
   Will print 1, 2, 3.
+
+  See:
+    rx.Observable/doOnNext
   "
-  [do-fn xs]
-  (map #(do (do-fn %) %) xs))
+  [do-fn ^Observable xs]
+  (.doOnNext xs (iop/action* do-fn)))
 
 (defn ^Observable drop
   [n ^Observable xs]
@@ -335,6 +393,17 @@
   [p ^Observable xs]
   (.skipWhile xs (fn->predicate p)))
 
+(defn ^Observable every?
+  "Returns an Observable that emits a single true value if (p x) is true for
+  all x in xs. Otherwise emits false.
+
+  See:
+    clojure.core/every?
+    rx.Observable/all
+  "
+  [p ^Observable xs]
+  (.all xs (fn->predicate p)))
+
 (defn ^Observable filter
   [p ^Observable xs]
   (.filter xs (fn->predicate p)))
@@ -349,6 +418,8 @@
   [^Observable xs]
   (.takeFirst xs))
 
+; TODO group-by
+
 (defn interpose
   [sep xs]
   (let [op (fn->operator (fn [o]
@@ -380,11 +451,34 @@
   [f xs]
   (filter (complement nil?) (map-indexed f xs)))
 
+(defn ^Observable map*
+  "Map a function over an Observable of Observables.
+
+  Each item from the first emitted Observable is the first arg, each
+  item from the second emitted Observable is the second arg, and so on.
+
+  See:
+    map
+    clojure.core/map
+    rx.Observable/zip
+  "
+  [f ^Observable observable]
+  (Observable/zip observable
+                  ^rx.functions.FuncN (iop/fnN* f)))
+
 (defn ^Observable map
-  "Map a function over an observable sequence. Unlike clojure.core/map, only supports up
-  to 4 simultaneous source sequences at the moment."
-  ([f ^Observable xs] (.map xs (iop/fn* f)))
-  ([f xs & observables] (apply zip f xs observables)))
+  "Map a function over one or more observable sequences.
+
+  Each item from the first Observable is the first arg, each item
+  from the second Observable is the second arg, and so on.
+
+  See:
+    clojure.core/map
+    rx.Observable/zip
+  "
+  [f & observables]
+  (Observable/zip ^Iterable observables
+                  ^rx.functions.FuncN (iop/fnN* f)))
 
 (defn ^Observable mapcat
   "Returns an observable which, for each value x in xs, calls (f x), which must
@@ -393,11 +487,9 @@
 
   See:
     clojure.core/mapcat
-    rx.Observable/mapMany
+    rx.Observable/flatMap
   "
-  ([f ^Observable xs] (.mapMany xs (iop/fn* f)))
-  ; TODO multi-arg version
-  )
+  ([f ^Observable xs] (.flatMap xs (iop/fn* f))))
 
 (defn map-indexed
   "Returns an observable that invokes (f index value) for each value of the input
@@ -408,9 +500,9 @@
   "
   [f xs]
   (let [op (fn->operator (fn [o]
-                         (let [n (atom -1)]
-                           (->subscriber o
-                                  (fn [o v] (on-next o (f (swap! n inc) v)))))))]
+                           (let [n (atom -1)]
+                             (->subscriber o
+                                           (fn [o v] (on-next o (f (swap! n inc) v)))))))]
     (lift op xs)))
 
 (def next
@@ -421,7 +513,19 @@
   "
   (partial drop 1))
 
-; TODO partition. Use Buffer whenever it's implemented.
+(defn nth
+  "Returns an Observable that emits the value at the index in the given
+  Observable.  nth throws an IndexOutOfBoundsException unless not-found
+  is supplied.
+
+  Note that the Observable is the *first* arg!
+  "
+  ([^Observable xs index]
+   (.elementAt xs index))
+  ([^Observable xs index not-found]
+   (.elementAtOrDefault xs index not-found)))
+
+; TODO partition. Use window
 
 (defn ^Observable reduce
   ([f ^Observable xs] (.reduce xs (iop/fn* f)))
@@ -448,36 +552,76 @@
        (filter identity)
        first))
 
-(defn sort
-  "Returns an observable that emits a single value which is a sorted sequence
+(defn sorted-list
+  "Returns an observable that emits a *single value* which is a sorted List
   of the items in coll, where the sort order is determined by comparing
   items.  If no comparator is supplied, uses compare. comparator must
   implement java.util.Comparator.
 
+  Use sort if you don't want the sequence squashed down to a List.
+
   See:
-    clojure.core/sort
+    rx.Observable/toSortedList
+    sort
   "
-  ([coll] (sort clojure.core/compare coll))
+  ([coll] (sorted-list clojure.core/compare coll))
   ([comp ^Observable coll]
    (.toSortedList coll (iop/fn [a b]
                          ; force to int so rxjava doesn't have a fit
                          (int (comp a b))))))
 
-(defn sort-by
-  "Returns an observable that emits a single value which is a sorted sequence
+(defn sorted-list-by
+  "Returns an observable that emits a *single value* which is a sorted List
   of the items in coll, where the sort order is determined by comparing
   (keyfn item).  If no comparator is supplied, uses compare. comparator must
   implement java.util.Comparator.
 
+  Use sort-by if you don't want the sequence squashed down to a List.
+
   See:
-    clojure.core/sort-by
+    rx.Observable/toSortedList
+    sort-by
   "
-  ([keyfn coll] (sort-by keyfn clojure.core/compare coll))
+  ([keyfn coll] (sorted-list-by keyfn clojure.core/compare coll))
   ([keyfn comp ^Observable coll]
    (.toSortedList coll (iop/fn [a b]
                          ; force to int so rxjava doesn't have a fit
                          (int (comp (keyfn a) (keyfn b)))))))
 
+(defn sort
+  "Returns an observable that emits the items in xs, where the sort order is
+  determined by comparing items. If no comparator is supplied, uses compare.
+  comparator must implement java.util.Comparator.
+
+  See:
+    sorted-list
+    clojure.core/sort
+  "
+  ([xs]
+   (->> xs
+        (sorted-list)
+        (mapcat seq->o)))
+  ([comp xs]
+   (->> xs
+        (sorted-list comp)
+        (mapcat seq->o))))
+
+(defn sort-by
+  "Returns an observable that emits the items in xs, where the sort order is
+  determined by comparing (keyfn item). If no comparator is supplied, uses
+  compare. comparator must implement java.util.Comparator.
+
+  See:
+    clojure.core/sort-by
+  "
+  ([keyfn xs]
+   (->> (sorted-list-by keyfn xs)
+        (mapcat seq->o)))
+  ([keyfn comp ^Observable xs]
+   (->> xs
+        (sorted-list-by keyfn comp)
+        (mapcat seq->o))))
+
 (defn split-with
   "Returns an observable that emits a pair of observables
 
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index c9300fb739..daefe3c05c 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -54,21 +54,21 @@
                     (b/into []))]
     (is (= [2 4] result))))
 
-(deftest test-zip
-  (testing "is happy with less than 4 args"
-    (is (= [[1 2 3]] (b/into [] (rx/zip vector
-                                        (rx/seq->o [1]) (rx/seq->o [2]) (rx/seq->o [3]))))))
-  (testing "is happy with more than 4 args"
-    (is (= [[1 2 3 4 5 6 7 8]]
-           (b/into [] (rx/zip vector
-                              (rx/seq->o [1])
-                              (rx/seq->o [2])
-                              (rx/seq->o [3])
-                              (rx/seq->o [4])
-                              (rx/seq->o [5])
-                              (rx/seq->o [6])
-                              (rx/seq->o [7])
-                              (rx/seq->o [8])))))))
+
+(deftest test-syncrhonize
+  ; I'm going to believe synchronize works and just exercise it
+  ; here for sanity.
+  (is (= [1 2 3]
+         (->> [1 2 3]
+              (rx/seq->o)
+              (rx/synchronize)
+              (b/into []))))
+  (let [lock (Object.)]
+    (is (= [1 2 3]
+           (->> [1 2 3]
+                (rx/seq->o)
+                (rx/synchronize lock)
+                (b/into []))))))
 
 (deftest test-merge
   (is (= [[1 3 5] [2 4 6]]
@@ -140,6 +140,35 @@
          (b/into [] (rx/concat* (rx/seq->o [(rx/seq->o [:q :r])
                                             (rx/seq->o [1 2 3])]))))))
 
+(deftest test-count
+  (are [xs] (= (count xs) (->> xs (rx/seq->o) (rx/count) (b/single)))
+       []
+       [1]
+       [5 6 7]
+       (range 10000)))
+
+(deftest test-cycle
+  (is (= [1 2 3 1 2 3 1 2 3 1 2]
+         (->> [1 2 3]
+              (rx/seq->o)
+              (rx/cycle)
+              (rx/take 11)
+              (b/into [])))))
+
+(deftest test-distinct
+  (let [input [{:a 1} {:a 1} {:b 1} {"a" (int 1)} {:a (int 1)}]]
+    (is (= (distinct input)
+           (->> input
+                (rx/seq->o)
+                (rx/distinct)
+                (b/into [])))))
+  (let [input [{:name "Bob" :x 2} {:name "Jim" :x 99} {:name "Bob" :x 3}]]
+    (is (= [{:name "Bob" :x 2} {:name "Jim" :x 99}]
+           (->> input
+                (rx/seq->o)
+                (rx/distinct :name)
+                (b/into []))))))
+
 (deftest test-do
   (testing "calls a function with each element"
     (let [collected (atom [])]
@@ -167,6 +196,13 @@
   (is (= (into [] (drop-while even? [2 4 6 8 1 2 3]))
          (b/into [] (rx/drop-while even? (rx/seq->o [2 4 6 8 1 2 3]))))))
 
+(deftest test-every?
+  (are [xs p result] (= result (->> xs (rx/seq->o) (rx/every? p) (b/single)))
+       [2 4 6 8] even?      true
+       [2 4 3 8] even?      false
+       [1 2 3 4] #{1 2 3 4} true
+       [1 2 3 4] #{1 3 4}   false))
+
 (deftest test-filter
   (is (= (into [] (->> [:a :b :c :d :e :f :G :e]
                     (filter #{:b :e :G})))
@@ -237,6 +273,17 @@
                             (rx/seq->o ["a" "b" "c" "d" "e"])
                             (rx/seq->o ["a" "b" "c" "d" "e"]))))))
 
+(deftest test-map*
+  (is (= [[1 2 3 4 5 6 7 8]]
+           (b/into [] (rx/map* vector
+                               (rx/seq->o [(rx/seq->o [1])
+                                           (rx/seq->o [2])
+                                           (rx/seq->o [3])
+                                           (rx/seq->o [4])
+                                           (rx/seq->o [5])
+                                           (rx/seq->o [6])
+                                           (rx/seq->o [7])
+                                           (rx/seq->o [8])]))))))
 (deftest test-map-indexed
   (is (= (map-indexed vector [:a :b :c])
          (b/into [] (rx/map-indexed vector (rx/seq->o [:a :b :c]))))))
@@ -245,21 +292,18 @@
   (let [f  (fn [v] [v (* v v)])
         xs (range 10)]
     (is (= (mapcat f xs)
-           (b/into [] (rx/mapcat (comp rx/seq->o f) (rx/seq->o xs))))))
-  (comment
-    (is (= (into [] (mapcat vector
-                              [:q :r :s :t :u]
-                              (range 10)
-                              ["a" "b" "c" "d" "e"] ))
-        (b/into [] (rx/mapcat vector
-                              (rx/seq->o [:q :r :s :t :u])
-                              (rx/seq->o (range 10) )
-                              (rx/seq->o ["a" "b" "c" "d" "e"] )))))))
+           (b/into [] (rx/mapcat (comp rx/seq->o f) (rx/seq->o xs)))))))
 
 (deftest test-next
   (let [in [:q :r :s :t :u]]
     (is (= (next in) (b/into [] (rx/next (rx/seq->o in)))))))
 
+(deftest test-nth
+  (is (= [:a]
+         (b/into [] (rx/nth (rx/seq->o [:s :b :a :c]) 2))))
+  (is (= [:fallback]
+         (b/into [] (rx/nth (rx/seq->o [:s :b :a :c]) 25 :fallback)))))
+
 (deftest test-rest
   (let [in [:q :r :s :t :u]]
     (is (= (rest in) (b/into [] (rx/rest (rx/seq->o in)))))))
@@ -276,18 +320,32 @@
   (is (= [:r] (b/into [] (rx/some #{:r :s :t} (rx/seq->o [:q :v :r])))))
   (is (= [] (b/into [] (rx/some #{:r :s :t} (rx/seq->o [:q :v]))))))
 
-(deftest test-sort
-  (is (= [[]] (b/into [] (rx/sort (rx/empty)))))
+(deftest test-sorted-list
+  (is (= [[]] (b/into [] (rx/sorted-list (rx/empty)))))
   (is (= [[1 2 3]]
-         (b/into [] (rx/sort (rx/seq->o [3 1 2])))))
+         (b/into [] (rx/sorted-list (rx/seq->o [3 1 2])))))
   (is (= [[3 2 1]]
+         (b/into [] (rx/sorted-list (fn [a b] (- (compare a b))) (rx/seq->o [2 1 3]))))))
+
+(deftest test-sorted-list-by
+  (is (= [[]] (b/into [] (rx/sorted-list-by :foo (rx/empty)))))
+  (is (= [[{:foo 1} {:foo 2} {:foo 3}]]
+         (b/into [] (rx/sorted-list-by :foo (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}])))))
+  (is (= [[{:foo 3} {:foo 2} {:foo 1}]]
+         (b/into [] (rx/sorted-list-by :foo (fn [a b] (- (compare a b))) (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}]))))))
+
+(deftest test-sort
+  (is (= [] (b/into [] (rx/sort (rx/empty)))))
+  (is (= [1 2 3]
+         (b/into [] (rx/sort (rx/seq->o [3 1 2])))))
+  (is (= [3 2 1]
          (b/into [] (rx/sort (fn [a b] (- (compare a b))) (rx/seq->o [2 1 3]))))))
 
 (deftest test-sort-by
-  (is (= [[]] (b/into [] (rx/sort-by :foo (rx/empty)))))
-  (is (= [[{:foo 1} {:foo 2} {:foo 3}]]
+  (is (= [] (b/into [] (rx/sort-by :foo (rx/empty)))))
+  (is (= [{:foo 1} {:foo 2} {:foo 3}]
          (b/into [] (rx/sort-by :foo (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}])))))
-  (is (= [[{:foo 3} {:foo 2} {:foo 1}]]
+  (is (= [{:foo 3} {:foo 2} {:foo 1}]
          (b/into [] (rx/sort-by :foo (fn [a b] (- (compare a b))) (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}]))))))
 
 (deftest test-split-with

From 42763685f9360b5ea83498494208a7fac3506b24 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 10:05:24 -0800
Subject: [PATCH 028/422] Update blocking stuff

---
 .../main/clojure/rx/lang/clojure/blocking.clj | 112 +++++++++++++++---
 .../clojure/rx/lang/clojure/blocking_test.clj |  53 ++++++++-
 2 files changed, 146 insertions(+), 19 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
index 9455636b11..f81f4b3c64 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
@@ -1,39 +1,81 @@
 (ns rx.lang.clojure.blocking
   "Blocking operators and functions. These should never be used in
   production code except at the end of an async chain to convert from
-  rx land back to sync land. For example, to produce a servlet response."
-  (:refer-clojure :exclude [first into])
-  (:require [rx.lang.clojure.core :as rx])
+  rx land back to sync land. For example, to produce a servlet response.
+
+  If you use these, you're a bad person.
+  "
+  (:refer-clojure :exclude [first into doseq last])
+  (:require [rx.lang.clojure.interop :as iop] [rx.lang.clojure.core :as rx])
   (:import [rx Observable]
            [rx.observables BlockingObservable]))
 
 (def ^:private -ns- *ns*)
 (set! *warn-on-reflection* true)
 
+(defmacro ^:private with-ex-unwrap
+  [& body]
+  `(try
+    ~@body
+    (catch RuntimeException e#
+      (throw (or
+               (and (identical? RuntimeException (class e#))
+                    (.getCause e#))
+               e#)))))
+
 (defn ^BlockingObservable ->blocking
-  "Convert an Observable to a BlockingObservable"
-  [^Observable o]
-  (.toBlockingObservable o))
+  "Convert an Observable to a BlockingObservable.
+
+  If o is already a BlockingObservable it's returned unchanged.
+  "
+  [o]
+  (if (instance? BlockingObservable o)
+    o
+    (.toBlockingObservable ^Observable o)))
+
+(defn o->seq
+  "Returns a lazy sequence of the items emitted by o
+
+  See:
+    rx.observables.BlockingObservable/getIterator
+    rx.lang.clojure.core/seq->o
+  "
+  [o]
+  (-> (->blocking o)
+      (.getIterator)
+      (iterator-seq)))
 
 (defn first
   "*Blocks* and waits for the first value emitted by the given observable.
 
+  If the Observable is empty, returns nil
+
   If an error is produced it is thrown.
 
   See:
     clojure.core/first
     rx/first
+    rx.observables.BlockingObservable/first
+  "
+  [observable]
+  (with-ex-unwrap
+    (.firstOrDefault (->blocking observable) nil)))
+
+(defn last
+  "*Blocks* and waits for the last value emitted by the given observable.
+
+  If the Observable is empty, returns nil
+
+  If an error is produced it is thrown.
+
+  See:
+    clojure.core/last
+    rx/last
+    rx.observable.BlockingObservable/last
   "
   [observable]
-  (let [result (clojure.core/promise)]
-    (rx/subscribe (->> observable (rx/take 1))
-                #(clojure.core/deliver result [:value %])
-                #(clojure.core/deliver result [:error %])
-                #(clojure.core/deliver result nil))
-    (if-let [[type v] @result]
-      (case type
-        :value v
-        :error (throw v)))))
+  (with-ex-unwrap
+    (.lastOrDefault (->blocking observable) nil)))
 
 (defn single
   "*Blocks* and waits for the first value emitted by the given observable.
@@ -41,7 +83,8 @@
    An error is thrown if more then one value is produced.
   "
   [observable]
-  (.single (->blocking observable)))
+  (with-ex-unwrap
+    (.single (->blocking observable))))
 
 (defn into
   "*Blocks* and pours the elements emitted by the given observables into
@@ -55,3 +98,40 @@
   "
   [to from-observable]
   (first (rx/into to from-observable)))
+
+(defn doseq*
+  "*Blocks* and executes (f x) for each x emitted by xs
+
+  Returns nil.
+
+  See:
+    doseq
+    clojure.core/doseq
+  "
+  [xs f]
+  (with-ex-unwrap
+    (-> (->blocking xs)
+        (.forEach (rx.lang.clojure.interop/action* f)))))
+
+(defmacro doseq
+  "Like clojure.core/doseq except iterates over an observable in a blocking manner.
+
+  Unlike clojure.core/doseq, only supports a single binding
+
+  Returns nil.
+
+  Example:
+
+    (rx-blocking/doseq [{:keys [name]} users-observable]
+      (println \"User:\" name))
+
+  See:
+    doseq*
+    clojure.core/doseq
+  "
+  [bindings & body]
+  (when (not= (count bindings) 2)
+    (throw (IllegalArgumentException. (str "sorry, rx/doseq only supports one binding"))))
+  (let [[k v] bindings]
+    `(doseq* ~v (fn [~k] ~@body))))
+
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
index 0963c14bab..df8e9fae1e 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
@@ -3,11 +3,34 @@
             [rx.lang.clojure.core :as rx]
             [clojure.test :refer [deftest testing is]]))
 
+(deftest test-->blocking
+  (testing "returns a BlockingObservable from an Observable"
+    (is (instance? rx.observables.BlockingObservable (b/->blocking (rx/return 0)))))
+  
+  (testing "is idempotent"
+    (is (instance? rx.observables.BlockingObservable (b/->blocking (b/->blocking (rx/return 0)))))))
+
+
+(deftest test-o->seq
+  (is (= [1 2 3] (b/o->seq (rx/seq->o [1 2 3])))))
+
 (deftest test-first
   (testing "returns first element of observable"
-    (is (= 1 (b/first (rx/return 1)))))
+    (is (= 1 (b/first (rx/seq->o [1 2 3])))))
+  (testing "returns nil for empty observable"
+    (is (nil? (b/first (rx/empty)))))
+  (testing "rethrows errors"
+    (is (thrown? java.io.FileNotFoundException
+                 (b/first (rx/throw (java.io.FileNotFoundException. "boo")))))))
+
+(deftest test-last
+  (testing "returns last element of observable"
+    (is (= 3 (b/last (rx/seq->o [1 2 3])))))
   (testing "returns nil for empty observable"
-    (is (nil? (b/first (rx/empty))))))
+    (is (nil? (b/last (rx/empty)))))
+  (testing "rethrows errors"
+    (is (thrown? java.io.FileNotFoundException
+                 (b/last (rx/throw (java.io.FileNotFoundException. "boo")))))))
 
 (deftest test-single
   (testing "returns one element"
@@ -15,4 +38,28 @@
   (testing "throw if empty"
     (is (thrown? java.lang.IllegalArgumentException (b/single (rx/empty)))))
   (testing "throw if many"
-    (is (thrown? java.lang.IllegalArgumentException (b/single (rx/seq->o [1 2]))))))
+    (is (thrown? java.lang.IllegalArgumentException (b/single (rx/seq->o [1 2])))))
+  (testing "rethrows errors"
+    (is (thrown? java.io.FileNotFoundException
+                 (b/single (rx/throw (java.io.FileNotFoundException. "boo"))))))) 
+
+(deftest test-into
+  (is (= [1 2 3]
+         (b/into [1] (rx/seq->o [2 3]))))
+  (testing "rethrows errors"
+    (is (thrown? java.io.FileNotFoundException
+                 (b/into #{} (rx/throw (java.io.FileNotFoundException. "boo")))))))
+
+(deftest test-doseq
+  (is (= (range 3)
+         (let [capture (atom [])]
+           (b/doseq [{:keys [value]} (rx/seq->o (map #(hash-map :value %) (range 3)))]
+             (println value)
+             (swap! capture conj value))
+           @capture)))
+
+  (testing "rethrows errors"
+    (is (thrown? java.io.FileNotFoundException
+                 (b/doseq [i (rx/seq->o (range 3))]
+                   (throw (java.io.FileNotFoundException. "boo")))))))
+

From a2d231461b5aa9dda2ecb384f897681e05534a83 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 10:05:38 -0800
Subject: [PATCH 029/422] Experimental warnings

---
 .../src/main/clojure/rx/lang/clojure/blocking.clj    |  4 +++-
 .../src/main/clojure/rx/lang/clojure/chunk.clj       |  8 ++++++--
 .../src/main/clojure/rx/lang/clojure/graph.clj       |  8 ++++++--
 .../src/main/clojure/rx/lang/clojure/realized.clj    | 12 +++++++++---
 4 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
index f81f4b3c64..4512022466 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
@@ -14,6 +14,8 @@
 (set! *warn-on-reflection* true)
 
 (defmacro ^:private with-ex-unwrap
+  "The blocking ops wrap errors stuff in RuntimeException because of stupid Java.
+  This tries to unwrap them so callers get the exceptions they expect."
   [& body]
   `(try
     ~@body
@@ -80,7 +82,7 @@
 (defn single
   "*Blocks* and waits for the first value emitted by the given observable.
 
-   An error is thrown if more then one value is produced.
+   An error is thrown if zero or more then one value is produced.
   "
   [observable]
   (with-ex-unwrap
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
index 303f8cc090..2a6695bfb7 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
@@ -6,7 +6,11 @@
 (set! *warn-on-reflection* true)
 
 (defn chunk
-  "Same as rx.Observable.merge(Observable<Observable<T>>) but the input Observables
+  "EXTREMELY EXPERIMENTAL AND SUBJECT TO CHANGE OR DELETION
+
+  TODO RxJava's much bigger since this was written. Is there something built in?
+
+  Same as rx.Observable.merge(Observable<Observable<T>>) but the input Observables
   are \"chunked\" so that at most chunk-size of them are \"in flight\" at any given
   time.
 
@@ -19,7 +23,7 @@
   Example:
 
     (->> users
-         (map #(-> (GetUserCommand. %) .toObservable))
+         (rx/map #(-> (GetUserCommand. %) .toObservable))
          (chunk 10))
 
   See:
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj
index 18187d29ac..a67ebba47c 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/graph.clj
@@ -18,7 +18,9 @@
     (.cache o)))
 
 (defn let-o*
-  "Given a graph description, returns an observable that emits a single
+  "EXTREMELY EXPERIMENTAL AND SUBJECT TO CHANGE OR DELETION
+
+  Given a graph description, returns an observable that emits a single
   map of observables all hooked up and ready for subscription.
 
   A graph is a map from name to a map with keys:
@@ -73,7 +75,9 @@
         (assoc ::non-terminals non-terminals))))
 
 (defmacro let-o
-  "Similar to clojure.core/let, but bindings are Observables and the result of the body
+  "EXTREMELY EXPERIMENTAL AND SUBJECT TO CHANGE OR DELETION
+
+  Similar to clojure.core/let, but bindings are Observables and the result of the body
   must be an Observable. Binding names must start with ?. Binding order doesn't matter
   and any binding is visible to all other expressions as long as no cycles are produced
   in the resulting Observable expression.
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
index e0b455af14..2926633924 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/realized.clj
@@ -34,7 +34,9 @@
     :else                       (->post-proc (rx.Observable/just v))))
 
 (defn realized-map
-  "See let-realized.
+  "EXTREMELY EXPERIMENTAL AND SUBJECT TO CHANGE OR DELETION
+
+  See let-realized.
 
   Given a map from key to observable, returns an observable that emits a single
   map from the same keys to the values emitted by their corresponding observable.
@@ -92,12 +94,16 @@
         (.reduce {} (iop/fn* merge))))) ; do the map merge dance
 
 (defn ^rx.Observable realized-map*
-  "Same as realized-map, but takes a map argument rather than key-value pairs."
+  "EXTREMELY EXPERIMENTAL AND SUBJECT TO CHANGE OR DELETION
+
+  Same as realized-map, but takes a map argument rather than key-value pairs."
   [map-description]
   (apply realized-map (apply concat map-description)))
 
 (defmacro let-realized
-  "'let' version of realized map.
+  "EXTREMELY EXPERIMENTAL AND SUBJECT TO CHANGE OR DELETION
+
+  'let' version of realized map.
 
     (let-realized [a (make-observable)]
       (* 2 a))

From 0da1e888705e9af489cf420ee0ed19c621a8def4 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 12:43:37 -0800
Subject: [PATCH 030/422] Update Clojure README

---
 language-adaptors/rxjava-clojure/README.md | 119 +++++++++++++++------
 1 file changed, 87 insertions(+), 32 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/README.md b/language-adaptors/rxjava-clojure/README.md
index b2f69b3853..537e72d9f6 100644
--- a/language-adaptors/rxjava-clojure/README.md
+++ b/language-adaptors/rxjava-clojure/README.md
@@ -1,10 +1,90 @@
-# Clojure Adaptor for RxJava
+Clojure bindings for RxJava.
 
+# Binaries
+
+Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-clojure%22).
+
+Example for Leiningen:
+
+```clojure
+[com.netflix.rxjava/rxjava-clojure "x.y.z"]
+```
+
+and for Gradle:
+
+```groovy
+compile 'com.netflix.rx:rxjava-clojure:x.y.z'
+```
+
+and for Maven:
+
+```xml
+<dependency>
+    <groupId>com.netflix.rxjava</groupId>
+    <artifactId>rxjava-clojure</artifactId>
+    <version>x.y.z</version>
+</dependency>
+```
+
+and for Ivy:
+
+```xml
+<dependency org="com.netflix.rxjava" name="rxjava-clojure" rev="x.y.z" />
+```
+
+# Clojure Bindings
+This library provides convenient, idiomatic Clojure bindings for RxJava.
+
+The bindings try to present an API that will be comfortable and familiar to a Clojure programmer that's familiar with the sequence operations in `clojure.core`. It "fixes" several issues with using RxJava with raw Java interop, for example:
+
+* Argument lists are in the "right" order. So in RxJava, the function applied in `Observable.map` is the second argument, while here it's the first argument with one or more Observables as trailing arguments
+* Operators take normal Clojure functions as arguments, bypassing need for the interop described below
+* Predicates accomodate Clojure's notion of truth
+* Operators are generally names as they would be in `clojure.core` rather than the Rx names
+
+There is no object wrapping going on. That is, all functions return normal `rx.Observable` objects, so you can always drop back to Java interop for anything that's missing in this wrapper.
+
+## Basic Usage
+Most functionality resides in the `rx.lang.clojure.core` namespace and for the most part looks like normal Clojure sequence manipulation:
+
+```clojure
+(require '[rx.lang.clojure.core :as rx])
+
+(->> my-observable
+     (rx/map (comp clojure.string/lower-case :first-name))
+     (rx/map clojure.string/lower-case)
+     (rx/filter #{"bob"})
+     (rx/distinct)
+     (rx/into []))
+;=> An Observable that emits a single vector of names
+```
+
+Blocking operators, which are useful for testing, but should otherwise be avoided, reside in `rx.lang.clojure.blocking`. For example:
+
+```clojure
+(require '[rx.lang.clojure.blocking :as rxb])
+
+(rxb/doseq [{:keys [first-name]} users-observable]
+  (println "Hey," first-name))
+;=> nil
+```
+
+## What's Missing
+This library is an ongoing work in progress driven primarily by the needs of one team at Netflix. As such some things are currently missing:
+
+* Highly-specific operators that we felt cluttered the API and were easily composed from existing operators, especially since we're in not-Java land. For example, `Observable.sumLong()`.
+* Most everything involving schedulers
+* Most everything involving time
+* `Observable.window` and `Observable.buffer`. Who knows which parts of these beasts to wrap?
+
+Of course, contributions that cover these cases are welcome.
+
+# Low-level Interop
 This adaptor provides functions and macros to ease Clojure/RxJava interop. In particular, there are functions and macros for turning Clojure functions and code into RxJava `Func*` and `Action*` interfaces without the tedium of manually reifying the interfaces.
 
-# Basic Usage
+## Basic Usage
 
-## Requiring the interop namespace
+### Requiring the interop namespace
 The first thing to do is to require the namespace:
 
 ```clojure
@@ -19,7 +99,7 @@ or, at the REPL:
 (require '[rx.lang.clojure.interop :as rx])
 ```
 
-## Using rx/fn
+### Using rx/fn
 Once the namespace is required, you can use the `rx/fn` macro anywhere RxJava wants a `rx.util.functions.Func` object. The syntax is exactly the same as `clojure.core/fn`:
 
 ```clojure
@@ -34,7 +114,7 @@ If you already have a plain old Clojure function you'd like to use, you can pass
     (.reduce (rx/fn* +)))
 ```
 
-## Using rx/action
+### Using rx/action
 The `rx/action` macro is identical to `rx/fn` except that the object returned implements `rx.util.functions.Action` interfaces. It's used in `subscribe` and other side-effect-y contexts:
 
 ```clojure
@@ -46,7 +126,7 @@ The `rx/action` macro is identical to `rx/fn` except that the object returned im
                 (rx/action [] (println "Sequence complete"))))
 ```
 
-## Using Observable/create
+### 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
@@ -59,35 +139,10 @@ As of 0.17, `rx.Observable/create` takes an implementation of `rx.Observable$OnS
                      (.onCompleted s)))
 ```
 
-# Gotchas
+## Gotchas
 Here are a few things to keep in mind when using this interop:
 
 * Keep in mind the (mostly empty) distinction between `Func` and `Action` and which is used in which contexts
 * If there are multiple Java methods overloaded by `Func` arity, you'll need to use a type hint to let the compiler know which one to choose.
 * Methods that take a predicate (like filter) expect the predicate to return a boolean value. A function that returns a non-boolean value will result in a `ClassCastException`.
 
-# Binaries
-
-Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-clojure%22).
-
-Example for Maven:
-
-```xml
-<dependency>
-    <groupId>com.netflix.rxjava</groupId>
-    <artifactId>rxjava-clojure</artifactId>
-    <version>x.y.z</version>
-</dependency>
-```
-
-and for Ivy:
-
-```xml
-<dependency org="com.netflix.rxjava" name="rxjava-clojure" rev="x.y.z" />
-```
-
-and for Leiningen:
-
-```clojure
-[com.netflix.rxjava/rxjava-clojure "x.y.z"]
-```

From cf5a20c59ef1533004d205d82cb679fc2f0b63cf Mon Sep 17 00:00:00 2001
From: mike castleman <m@mlcastle.net>
Date: Wed, 19 Feb 2014 16:32:59 -0500
Subject: [PATCH 031/422] fix gradle spec in README

presumably the group ID should be the same for gradle as for the other dependency managers.
---
 language-adaptors/rxjava-clojure/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/language-adaptors/rxjava-clojure/README.md b/language-adaptors/rxjava-clojure/README.md
index 537e72d9f6..1a0d9e0af9 100644
--- a/language-adaptors/rxjava-clojure/README.md
+++ b/language-adaptors/rxjava-clojure/README.md
@@ -13,7 +13,7 @@ Example for Leiningen:
 and for Gradle:
 
 ```groovy
-compile 'com.netflix.rx:rxjava-clojure:x.y.z'
+compile 'com.netflix.rxjava:rxjava-clojure:x.y.z'
 ```
 
 and for Maven:

From df5503fcec91b1248fc4db913a517fc34ecd7750 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 16:46:53 -0800
Subject: [PATCH 032/422] Cleaned up naming of observable operator definition
 fns

---
 .../main/clojure/rx/lang/clojure/chunk.clj    |   4 +-
 .../src/main/clojure/rx/lang/clojure/core.clj | 242 +++++++++---------
 .../main/clojure/rx/lang/clojure/future.clj   |   8 +-
 .../clojure/rx/lang/clojure/core_test.clj     |  23 +-
 4 files changed, 139 insertions(+), 138 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
index 2a6695bfb7..d53c8ce322 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
@@ -92,8 +92,8 @@
                                   (fn []
                                     (swap! state-atom assoc :complete :complete)
                                     (advance! state-atom))))
-        observable (rx/fn->o (fn [observer]
-                               (subscribe (new-state-atom observer)))) ]
+        observable (rx/observable* (fn [observer]
+                                     (subscribe (new-state-atom observer)))) ]
     (if (:delay-error? options)
       (rx.Observable/mergeDelayError observable)
       (rx.Observable/merge observable)))))
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 4e50cef03c..4040d7da83 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -54,28 +54,14 @@
   (.onError o e))
 
 ;################################################################################
+; Tools for creating new operators and observables
 
-(defn ^Subscription subscribe
-
-  ([^Observable o on-next-action]
-    (.subscribe o
-                ^Action1 (iop/action* on-next-action)))
+(declare unsubscribed?)
 
-  ([^Observable o on-next-action on-error-action]
-    (.subscribe o
-                ^Action1 (iop/action* on-next-action)
-                ^Action1 (iop/action* on-error-action)))
-
-  ([^Observable o on-next-action on-error-action on-completed-action]
-    (.subscribe o
-                ^Action1 (iop/action* on-next-action)
-                ^Action1 (iop/action* on-error-action)
-                ^Action0 (iop/action* on-completed-action))))
-
-(defn ^Subscriber ->subscriber
+(defn ^Subscriber subscriber
   ""
-  ([o on-next-action] (->subscriber o on-next-action nil nil))
-  ([o on-next-action on-error-action] (->subscriber o on-next-action on-error-action nil))
+  ([o on-next-action] (subscriber o on-next-action nil nil))
+  ([o on-next-action on-error-action] (subscriber o on-next-action on-error-action nil))
   ([^Subscriber o on-next-action on-error-action on-completed-action]
    (proxy [Subscriber] [o]
      (onCompleted []
@@ -91,17 +77,23 @@
          (on-next-action o t)
          (on-next o t))))))
 
-(defn ^Observable$Operator fn->operator
-  "Create a basic Operator with f. If a handler is omitted or nil
-  it's treated as a pass-through.
+(defn ^Subscription subscription
+  "Create a new subscription that calls the given no-arg handler function when
+  unsubscribe is called
+
+  See:
+    rx.subscriptions.Subscriptions/create
+  "
+  [handler]
+  (Subscriptions/create ^Action0 (iop/action* handler)))
 
-  on-next-action  Passed Subscriber and value
-  on-error-action Passed Throwable
-  on-completed-action No-args
+(defn ^Observable$Operator operator*
+  "Returns a new implementation of rx.Observable$Operator that calls the given
+  function with a rx.Subscriber. The function should return a rx.Subscriber.
 
   See:
-  lift
-  rx.Observable$Operator
+    lift
+    rx.Observable$Operator
   "
   [f]
   {:pre [(fn? f)]}
@@ -109,22 +101,72 @@
     (call [this o]
       (f o))))
 
+(defn ^Observable observable*
+  "Create an Observable from the given function.
+
+  When subscribed to, (f subscriber) is called at which point, f can start emitting values, etc.
+  The passed subscriber is of type rx.Subscriber.
+
+  See:
+    rx.Subscriber
+    rx.Observable/create
+  "
+  [f]
+  (Observable/create ^Observable$OnSubscribe (iop/action* f)))
+
+(defn wrap-on-completed
+  "Wrap handler with code that automaticaly calls rx.Observable.onCompleted."
+  [handler]
+  (fn [^Observer observer]
+    (handler observer)
+    (when-not (unsubscribed? observer)
+      (.onCompleted observer))))
+
+(defn wrap-on-error
+  "Wrap handler with code that automaticaly calls (on-error) if an exception is thrown"
+  [handler]
+  (fn [^Observer observer]
+    (try
+      (handler observer)
+      (catch Throwable e
+        (when-not (unsubscribed? observer)
+          (.onError observer e))))))
+
 (defn lift
   "Lift the Operator op over the given Observable xs
 
   Example:
 
     (->> my-observable
-         (rx/lift (rx/fn->operator ...))
+         (rx/lift (rx/operator ...))
          ...)
 
   See:
     rx.Observable/lift
-    fn->operator
+    operator
   "
   [^Observable$Operator op ^Observable xs]
   (.lift xs op))
 
+;################################################################################
+
+(defn ^Subscription subscribe
+
+  ([^Observable o on-next-action]
+    (.subscribe o
+                ^Action1 (iop/action* on-next-action)))
+
+  ([^Observable o on-next-action on-error-action]
+    (.subscribe o
+                ^Action1 (iop/action* on-next-action)
+                ^Action1 (iop/action* on-error-action)))
+
+  ([^Observable o on-next-action on-error-action on-completed-action]
+    (.subscribe o
+                ^Action1 (iop/action* on-next-action)
+                ^Action1 (iop/action* on-error-action)
+                ^Action0 (iop/action* on-completed-action))))
+
 (defn unsubscribe
   "Unsubscribe from Subscription s and return it."
   [^Subscription s]
@@ -158,53 +200,50 @@
 
   See:
     rx.Observable/create
-    fn->o
+    observable*
   "
   [^Subscription s]
   (.isUnsubscribed s))
 
-(defn ^Subscription fn->subscription
-  "Create a new subscription that calls the given no-arg handler function when
-  unsubscribe is called
+;################################################################################
+; Functions for creating Observables
+
+(defn ^Observable never
+  "Returns an Observable that never emits any values and never completes.
 
   See:
-    rx.subscriptions.Subscriptions/create
+    rx.Observable/never
   "
-  [handler]
-  (Subscriptions/create ^Action0 (iop/action* handler)))
-
-(defn ^Observable fn->o
-  "Create an Observable from the given function.
+  []
+  (Observable/never))
 
-  When subscribed to, (f subscriber) is called at which point, f can start emitting values, etc.
-  The passed subscriber is of type rx.Subscriber.
+(defn ^Observable empty
+  "Returns an Observable that completes immediately without emitting any values.
 
   See:
-    rx.Subscriber
-    rx.Observable/create
+    rx.Observable/empty
   "
-  [f]
-  (Observable/create ^Observable$OnSubscribe (iop/action* f)))
+  []
+  (Observable/empty))
 
-(defn wrap-on-completed
-  "Wrap handler with code that automaticaly calls rx.Observable.onCompleted."
-  [handler]
-  (fn [^Observer observer]
-    (handler observer)
-    (when-not (unsubscribed? observer)
-      (.onCompleted observer))))
+(defn ^Observable return
+  "Returns an observable that emits a single value.
 
-(defn wrap-on-error
-  "Wrap handler with code that automaticaly calls (on-error) if an exception is thrown"
-  [handler]
-  (fn [^Observer observer]
-    (try
-      (handler observer)
-      (catch Throwable e
-        (when-not (unsubscribed? observer)
-          (.onError observer e))))))
+  See:
+    rx.Observable/just
+  "
+  [value]
+  (Observable/just value))
+
+(defn ^Observable seq->o
+  "Make an observable out of some seq-able thing. The rx equivalent of clojure.core/seq."
+  [xs]
+  (if xs
+    (Observable/from ^Iterable xs)
+    (empty)))
 
 ;################################################################################
+; Operators
 
 (defn synchronize
   ([^Observable xs]
@@ -246,44 +285,6 @@
       (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
 
 
-;################################################################################
-
-(defn ^Observable never
-  "Returns an Observable that never emits any values and never completes.
-
-  See:
-    rx.Observable/never
-  "
-  []
-  (Observable/never))
-
-(defn ^Observable empty
-  "Returns an Observable that completes immediately without emitting any values.
-
-  See:
-    rx.Observable/empty
-  "
-  []
-  (Observable/empty))
-
-(defn ^Observable return
-  "Returns an observable that emits a single value.
-
-  See:
-    rx.Observable/just
-  "
-  [value]
-  (Observable/just value))
-
-(defn ^Observable seq->o
-  "Make an observable out of some seq-able thing. The rx equivalent of clojure.core/seq."
-  [xs]
-  (if xs
-    (Observable/from ^Iterable xs)
-    (empty)))
-
-;################################################################################
-
 (defn cache
   "caches the observable value so that multiple subscribers don't re-evaluate it.
 
@@ -354,14 +355,14 @@
   "
   ([xs] (distinct identity xs))
   ([key-fn ^Observable xs]
-  (let [op (fn->operator (fn [o]
-                           (let [seen (atom #{})]
-                             (->subscriber o
-                                           (fn [o v]
-                                             (let [key (key-fn v)]
-                                               (when-not (contains? @seen key)
-                                                 (swap! seen conj key)
-                                                 (on-next o v))))))))]
+   (let [op (operator* (fn [o]
+                         (let [seen (atom #{})]
+                           (subscriber o
+                                       (fn [o v]
+                                         (let [key (key-fn v)]
+                                           (when-not (contains? @seen key)
+                                             (swap! seen conj key)
+                                             (on-next o v))))))))]
     (lift op xs))))
 
 (defn ^Observable do
@@ -422,12 +423,12 @@
 
 (defn interpose
   [sep xs]
-  (let [op (fn->operator (fn [o]
-                         (let [first? (atom true)]
-                           (->subscriber o (fn [o v]
-                                             (if-not (compare-and-set! first? true false)
-                                               (on-next o sep))
-                                             (on-next o v))))))]
+  (let [op (operator* (fn [o]
+                        (let [first? (atom true)]
+                          (subscriber o (fn [o v]
+                                          (if-not (compare-and-set! first? true false)
+                                            (on-next o sep))
+                                          (on-next o v))))))]
     (lift op xs)))
 
 (defn into
@@ -499,10 +500,11 @@
     clojure.core/map-indexed
   "
   [f xs]
-  (let [op (fn->operator (fn [o]
-                           (let [n (atom -1)]
-                             (->subscriber o
-                                           (fn [o v] (on-next o (f (swap! n inc) v)))))))]
+  (let [op (operator* (fn [o]
+                        (let [n (atom -1)]
+                          (subscriber o
+                                      (fn [o v]
+                                        (on-next o (f (swap! n inc) v)))))))]
     (lift op xs)))
 
 (def next
@@ -768,9 +770,9 @@
     (rx/generator* on-next 99)
   "
   [f & args]
-  (fn->o (-> #(apply f % args)
-             wrap-on-completed
-             wrap-on-error)))
+  (observable* (-> #(apply f % args)
+                   wrap-on-completed
+                   wrap-on-error)))
 
 (defmacro generator
   "Create an observable that executes body which should emit a sequence. bindings
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
index ac8d29f5e6..0c63be36e8 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
@@ -29,14 +29,14 @@
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
-  (rx/fn->o (fn [^rx.Subscriber observer]
+  (rx/observable* (fn [^rx.Subscriber observer]
               (let [wrapped (-> (fn [o]
                                   (apply f o args))
                                 rx/wrap-on-completed
                                 rx/wrap-on-error)
                     fu      (runner #(wrapped observer))]
               (.add observer
-                    (rx/fn->subscription #(future-cancel fu)))))))
+                    (rx/subscription #(future-cancel fu)))))))
 
 (defmacro future-generator
   "Same as rx/generator macro except body is invoked in a separate thread.
@@ -74,13 +74,13 @@
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
-  (rx/fn->o (fn [^rx.Subscriber observer]
+  (rx/observable* (fn [^rx.Subscriber observer]
            (let [wrapped (-> #(rx/on-next % (apply f args))
                              rx/wrap-on-completed
                              rx/wrap-on-error)
                  fu      (runner #(wrapped observer))]
              (.add observer
-                   (rx/fn->subscription #(future-cancel fu)))))))
+                   (rx/subscription #(future-cancel fu)))))))
 
 (defmacro future
   "Executes body in a separate thread and passes the single result to onNext.
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index daefe3c05c..f23bcc0013 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -23,29 +23,29 @@
        identity "true" true
        identity true   true))
 
-(deftest test-fn->subscription
+(deftest test-subscription
   (let [called (atom 0)
-        s (rx/fn->subscription #(swap! called inc))]
+        s (rx/subscription #(swap! called inc))]
     (is (identical? s (rx/unsubscribe s)))
     (is (= 1 @called))))
 
 (deftest test-unsubscribed?
-  (let [s (rx/fn->subscription #())]
+  (let [s (rx/subscription #())]
     (is (not (rx/unsubscribed? s)))
     (rx/unsubscribe s)
     (is (rx/unsubscribed? s))))
 
 
-(deftest test-fn->o
-  (let [o (rx/fn->o (fn [s]
-                      (rx/on-next s 0)
-                      (rx/on-next s 1)
-                      (when-not (rx/unsubscribed? s) (rx/on-next s 2))
-                      (rx/on-completed s)))]
+(deftest test-observable*
+  (let [o (rx/observable* (fn [s]
+                            (rx/on-next s 0)
+                            (rx/on-next s 1)
+                            (when-not (rx/unsubscribed? s) (rx/on-next s 2))
+                            (rx/on-completed s)))]
     (is (= [0 1 2] (b/into [] o)))))
 
-(deftest test-fn->operator
-  (let [o (rx/fn->operator #(rx/->subscriber %
+(deftest test-operator*
+  (let [o (rx/operator* #(rx/subscriber %
                                            (fn [o v]
                                              (if (even? v)
                                                (rx/on-next o v)))))
@@ -54,7 +54,6 @@
                     (b/into []))]
     (is (= [2 4] result))))
 
-
 (deftest test-syncrhonize
   ; I'm going to believe synchronize works and just exercise it
   ; here for sanity.

From f1ff778a8db1b9fc9e9d47bba02e6f1b50088ecc Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 21:00:12 -0800
Subject: [PATCH 033/422] Implement catch-error-value

Automating "rx.exceptions.OnErrorThrowable/addValueAsLastCause" idiom
when user code is invoked in onNext. Other minor cleanup.
---
 .../src/main/clojure/rx/lang/clojure/core.clj | 49 ++++++++++++++---
 .../clojure/rx/lang/clojure/core_test.clj     | 54 ++++++++++++++++++-
 2 files changed, 95 insertions(+), 8 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 4040d7da83..1b55535ee3 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -39,19 +39,53 @@
 ;################################################################################
 
 (defn on-next
-  "Call onNext on the given observer."
+  "Call onNext on the given observer and return o."
   [^Observer o value]
-  (.onNext o value))
+  (.onNext o value)
+  o)
 
 (defn on-completed
-  "Call onCompleted on the given observer."
+  "Call onCompleted on the given observer and return o."
   [^Observer o]
-  (.onCompleted o))
+  (.onCompleted o)
+  o)
 
 (defn on-error
-  "Call onError on the given observer."
+  "Call onError on the given observer and return o."
   [^Observer o e]
-  (.onError o e))
+  (.onError o e)
+  o)
+
+(defmacro catch-error-value
+  "Experimental
+
+  TODO: Better name, better abstraction.
+
+  Evaluate body and return its value.  If an exception e is thrown, inject the
+  given value into the exception's cause and call (on-error error-observer e),
+  returning e.
+
+  This is meant to facilitate implementing Observers that call user-supplied code
+  safely. The general pattern is something like:
+
+    (fn [o v]
+      (rx/catch-error-value o v
+        (rx/on-next o (some-func v))))
+
+  If (some-func v) throws an exception, it is caught, v is injected into the
+  exception's cause (with OnErrorThrowable/addValueAsLastCause) and
+  (rx/on-error o e) is invoked.
+
+  See:
+    rx.exceptions.OnErrorThrowable/addValueAsLastCause
+  "
+  [error-observer value & body]
+  `(try
+    ~@body
+    (catch Throwable e#
+      (on-error ~error-observer
+                (rx.exceptions.OnErrorThrowable/addValueAsLastCause e# ~value))
+      e#)))
 
 ;################################################################################
 ; Tools for creating new operators and observables
@@ -504,7 +538,8 @@
                         (let [n (atom -1)]
                           (subscriber o
                                       (fn [o v]
-                                        (on-next o (f (swap! n inc) v)))))))]
+                                        (catch-error-value o v
+                                          (on-next o (f (swap! n inc) v))))))))]
     (lift op xs)))
 
 (def next
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index f23bcc0013..8def4ec506 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -8,6 +8,48 @@
   (is (rx/observable? (rx/return 99)))
   (is (not (rx/observable? "I'm not an observable"))))
 
+(deftest test-on-next
+  (testing "calls onNext"
+    (let [called (atom [])
+          o (reify rx.Observer (onNext [this value] (swap! called conj value)))]
+      (is (identical? o (rx/on-next o 1)))
+      (is (= [1] @called)))))
+
+(deftest test-on-completed
+  (testing "calls onCompleted"
+    (let [called (atom 0)
+          o (reify rx.Observer (onCompleted [this] (swap! called inc)))]
+      (is (identical? o (rx/on-completed o)))
+      (is (= 1 @called)))))
+
+(deftest test-on-error
+  (testing "calls onError"
+    (let [called (atom [])
+          e (java.io.FileNotFoundException. "yum")
+          o (reify rx.Observer (onError [this e] (swap! called conj e)))]
+      (is (identical? o (rx/on-error o e)))
+      (is (= [e] @called)))))
+
+(deftest test-catch-error-value
+  (testing "if no exception, returns body"
+    (let [o (reify rx.Observer)]
+      (is (= 3 (rx/catch-error-value o 99
+                 (+ 1 2))))))
+
+  (testing "exceptions call onError on observable and inject value in exception"
+    (let [called (atom [])
+          e      (java.io.FileNotFoundException. "boo")
+          o      (reify rx.Observer
+                   (onError [this e]
+                     (swap! called conj e)))
+          result (rx/catch-error-value o 100
+                   (throw e))
+          cause  (.getCause e)]
+      (is (identical? e result))
+      (is (= [e] @called))
+      (when (is (instance? rx.exceptions.OnErrorThrowable$OnNextValue cause))
+        (is (= 100 (.getValue cause)))))))
+
 (deftest test-subscribe
   (testing "subscribe overload with only onNext"
     (let [o (rx/return 1)
@@ -285,7 +327,17 @@
                                            (rx/seq->o [8])]))))))
 (deftest test-map-indexed
   (is (= (map-indexed vector [:a :b :c])
-         (b/into [] (rx/map-indexed vector (rx/seq->o [:a :b :c]))))))
+         (b/into [] (rx/map-indexed vector (rx/seq->o [:a :b :c])))))
+  (testing "exceptions from fn have error value injected"
+    (try
+      (->> (rx/seq->o [:a :b :c])
+           (rx/map-indexed (fn [i v]
+                        (if (= 1 i)
+                          (throw (java.io.FileNotFoundException. "blah")))
+                        v))
+           (b/into []))
+      (catch java.io.FileNotFoundException e
+        (is (= :b (-> e .getCause .getValue)))))))
 
 (deftest test-mapcat
   (let [f  (fn [v] [v (* v v)])

From feb16d08967e10f413e7fdb641a07e44553555fe Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 21:06:45 -0800
Subject: [PATCH 034/422] more README

---
 language-adaptors/rxjava-clojure/README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/language-adaptors/rxjava-clojure/README.md b/language-adaptors/rxjava-clojure/README.md
index 1a0d9e0af9..14f6b312be 100644
--- a/language-adaptors/rxjava-clojure/README.md
+++ b/language-adaptors/rxjava-clojure/README.md
@@ -69,6 +69,12 @@ Blocking operators, which are useful for testing, but should otherwise be avoide
 ;=> nil
 ```
 
+## Open Issues
+
+* The missing stuff mentioned below
+* `group-by`
+* There are some functions for defining customer Observables and Operators (`subscriber`, `operator*`, `observable*`). I don't think these are really enough for serious operator implementation, but I'm hesitant to guess at an abstraction at this point. These will probably change dramatically.
+
 ## What's Missing
 This library is an ongoing work in progress driven primarily by the needs of one team at Netflix. As such some things are currently missing:
 

From 963cfd5af091eb4595be6d1cffe2544d4a15bd57 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 21:58:45 -0800
Subject: [PATCH 035/422] Implement group-by

Note that since 02ccc4d727a9297f14219549208757c6e0efce2a, the val-fn
variant of groupBy is unimplemented so for now an exception is thrown if
it's used.
---
 language-adaptors/rxjava-clojure/README.md    |  2 +-
 .../src/main/clojure/rx/lang/clojure/core.clj | 33 +++++++++++++++++--
 .../clojure/rx/lang/clojure/core_test.clj     | 30 +++++++++++++++++
 3 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/README.md b/language-adaptors/rxjava-clojure/README.md
index 14f6b312be..4c5bdafe46 100644
--- a/language-adaptors/rxjava-clojure/README.md
+++ b/language-adaptors/rxjava-clojure/README.md
@@ -72,7 +72,7 @@ Blocking operators, which are useful for testing, but should otherwise be avoide
 ## Open Issues
 
 * The missing stuff mentioned below
-* `group-by`
+* `group-by` val-fn variant isn't implemented in RxJava
 * There are some functions for defining customer Observables and Operators (`subscriber`, `operator*`, `observable*`). I don't think these are really enough for serious operator implementation, but I'm hesitant to guess at an abstraction at this point. These will probably change dramatically.
 
 ## What's Missing
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 1b55535ee3..a7a0555934 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -3,6 +3,7 @@
                             distinct do drop drop-while
                             empty every?
                             filter first future
+                            group-by
                             interpose into
                             keep keep-indexed
                             map mapcat map-indexed
@@ -16,7 +17,9 @@
             Observable
             Observer Observable$Operator Observable$OnSubscribe
             Subscriber Subscription]
-           [rx.observables BlockingObservable]
+           [rx.observables
+            BlockingObservable
+            GroupedObservable]
            [rx.subscriptions Subscriptions]
            [rx.util.functions Action0 Action1 Func0 Func1 Func2]))
 
@@ -453,7 +456,33 @@
   [^Observable xs]
   (.takeFirst xs))
 
-; TODO group-by
+(defn ^Observable group-by
+  "Returns an Observable of clojure.lang.MapEntry where the key is the result of
+  (key-fn x) and the val is an Observable of (val-fn x) for each key. If val-fn is
+  omitted, it defaults to identity.
+
+  This returns a clojure.lang.MapEntry rather than rx.observables.GroupedObservable
+  for some vague consistency with clojure.core/group-by and so that clojure.core/key,
+  clojure.core/val and destructuring will work as expected.
+
+  See:
+    clojure.core/group-by
+    rx.Observable/groupBy
+    rx.observables.GroupedObservable
+  "
+  ([key-fn ^Observable xs]
+   (->> (.groupBy xs (iop/fn* key-fn))
+        (map (fn [^GroupedObservable go]
+               (clojure.lang.MapEntry. (.getKey go) go)))))
+  ([key-fn val-fn ^Observable xs]
+   ; TODO reinstate once this is implemented
+   ; see https://github.com/Netflix/RxJava/commit/02ccc4d727a9297f14219549208757c6e0efce2a
+   (throw (UnsupportedOperationException. "groupBy with val-fn is currently unimplemented in RxJava"))
+   (->> (.groupBy xs
+                  (iop/fn* key-fn)
+                  (iop/fn* val-fn))
+        (map (fn [^GroupedObservable go]
+               (clojure.lang.MapEntry. (.getKey go) go))))))
 
 (defn interpose
   [sep xs]
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 8def4ec506..c59be6a034 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -256,6 +256,36 @@
   (is (= []
          (b/into [] (rx/first (rx/empty))))))
 
+(deftest test-group-by
+  (let [xs [{:k :a :v 1} {:k :b :v 2} {:k :a :v 3} {:k :c :v 4}]]
+    (testing "with just a key-fn"
+      (is (= [[:a {:k :a :v 1}]
+              [:b {:k :b :v 2}]
+              [:a {:k :a :v 3}]
+              [:c {:k :c :v 4}]]
+             (->> xs
+                  (rx/seq->o)
+                  (rx/group-by :k)
+                  (rx/mapcat (fn [[k vo :as me]]
+                               (is (instance? clojure.lang.MapEntry me))
+                               (rx/map #(vector k %) vo)))
+                  (b/into [])))))
+
+    ; TODO reinstate once this is implemented
+    ; see https://github.com/Netflix/RxJava/commit/02ccc4d727a9297f14219549208757c6e0efce2a
+    #_(testing "with a val-fn"
+      (is (= [[:a 1]
+              [:b 2]
+              [:a 3]
+              [:c 4]]
+             (->> xs
+                  (rx/seq->o)
+                  (rx/group-by :k :v)
+                  (rx/mapcat (fn [[k vo :as me]]
+                               (is (instance? clojure.lang.MapEntry me))
+                               (rx/map #(vector k %) vo)))
+                  (b/into [])))))
+    ))
 (deftest test-interpose
   (is (= (interpose \, [1 2 3])
          (b/into [] (rx/interpose \, (rx/seq->o [1 2 3]))))))

From 3714db96bbdcd50e8680d189d9e1c77de3018dc4 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Wed, 19 Feb 2014 23:41:01 -0800
Subject: [PATCH 036/422] Implement interleave and interleave*

---
 .../src/main/clojure/rx/lang/clojure/core.clj | 31 +++++++++++++++++--
 .../clojure/rx/lang/clojure/core_test.clj     | 31 +++++++++++++++++--
 2 files changed, 58 insertions(+), 4 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index a7a0555934..7a86f6d4a0 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -4,7 +4,7 @@
                             empty every?
                             filter first future
                             group-by
-                            interpose into
+                            interleave interpose into
                             keep keep-indexed
                             map mapcat map-indexed
                             merge next nth partition reduce reductions
@@ -25,7 +25,7 @@
 
 (set! *warn-on-reflection* true)
 
-(declare concat map map-indexed reduce take take-while)
+(declare concat* concat map* map map-indexed reduce take take-while)
 
 (defn ^Func1 fn->predicate
   "Turn f into a predicate that returns true/false like Rx predicates should"
@@ -484,6 +484,33 @@
         (map (fn [^GroupedObservable go]
                (clojure.lang.MapEntry. (.getKey go) go))))))
 
+(defn interleave*
+  "Returns an Observable of the first item in each Observable emitted by observables, then
+  the second etc.
+
+  observables is an Observable of Observables
+
+  See:
+    interleave
+    clojure.core/interleave
+  "
+  [observables]
+  (->> (map* #(seq->o %&) observables)
+       (concat*)))
+
+(defn interleave
+  "Returns an Observable of the first item in each Observable, then the second etc.
+
+  Each argument is an individual Observable
+
+  See:
+    observable*
+    clojure.core/interleave
+  "
+  [o1 & observables]
+  (->> (apply map #(seq->o %&) o1 observables)
+       (concat*)))
+
 (defn interpose
   [sep xs]
   (let [op (operator* (fn [o]
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index c59be6a034..2362638e50 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -284,8 +284,35 @@
                   (rx/mapcat (fn [[k vo :as me]]
                                (is (instance? clojure.lang.MapEntry me))
                                (rx/map #(vector k %) vo)))
-                  (b/into [])))))
-    ))
+                  (b/into [])))))))
+
+(deftest test-interleave
+  (are [inputs] (= (apply interleave inputs)
+                   (->> (apply rx/interleave (map rx/seq->o inputs))
+                        (b/into [])))
+       [[] []]
+       [[] [1]]
+       [(range 5) (range 10) (range 10) (range 3)]
+       [(range 50) (range 10)]
+       [(range 5) (range 10 60) (range 10) (range 50)])
+
+  ; one-arg case, not supported by clojure.core/interleave
+  (is (= (range 10)
+         (->> (rx/interleave (rx/seq->o (range 10)))
+              (b/into [])))))
+
+(deftest test-interleave*
+  (are [inputs] (= (apply interleave inputs)
+                   (->> (rx/interleave* (->> inputs
+                                             (map rx/seq->o)
+                                             (rx/seq->o)))
+                        (b/into [])))
+       [[] []]
+       [[] [1]]
+       [(range 5) (range 10) (range 10) (range 3)]
+       [(range 50) (range 10)]
+       [(range 5) (range 10 60) (range 10) (range 50)]))
+
 (deftest test-interpose
   (is (= (interpose \, [1 2 3])
          (b/into [] (rx/interpose \, (rx/seq->o [1 2 3]))))))

From 02ff779811751a4b032675c237782d22d310720f Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 08:44:10 -0800
Subject: [PATCH 037/422] Implemented partition-all

There isn't really an rxjava impl equivalent to clojure.core/partition,
so it's omitted.
---
 .../src/main/clojure/rx/lang/clojure/core.clj | 14 ++++++++--
 .../clojure/rx/lang/clojure/core_test.clj     | 27 +++++++++++++++++++
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 7a86f6d4a0..f74df0eed6 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -7,7 +7,7 @@
                             interleave interpose into
                             keep keep-indexed
                             map mapcat map-indexed
-                            merge next nth partition reduce reductions
+                            merge next nth partition-all reduce reductions
                             rest seq some sort sort-by split-with
                             take take-while throw])
   (:require [rx.lang.clojure.interop :as iop]
@@ -618,7 +618,17 @@
   ([^Observable xs index not-found]
    (.elementAtOrDefault xs index not-found)))
 
-; TODO partition. Use window
+(defn ^Observable partition-all
+  "Returns an Observable of Observables of n items each, at offsets step
+  apart. If step is not supplied, defaults to n, i.e. the partitions
+  do not overlap. May include partitions with fewer than n items at the end.
+
+  See:
+    clojure.core/partition-all
+    rx.Observable/window
+  "
+  ([n ^Observable xs] (.window xs (int n)))
+  ([n step ^Observable xs] (.window xs (int n) (int step))))
 
 (defn ^Observable reduce
   ([f ^Observable xs] (.reduce xs (iop/fn* f)))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 2362638e50..47db658c6c 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -416,6 +416,33 @@
   (let [in [:q :r :s :t :u]]
     (is (= (rest in) (b/into [] (rx/rest (rx/seq->o in)))))))
 
+(deftest test-partition-all
+  (are [input-size part-size step] (= (->> (range input-size)
+                                           (partition-all part-size step))
+                                      (->> (range input-size)
+                                           (rx/seq->o)
+                                           (rx/partition-all part-size step)
+                                           (rx/map #(rx/into [] %))
+                                           (rx/concat*)
+                                           (b/into [])))
+       0 1 1
+       10 2 2
+       10 3 2
+       15 30 4)
+
+  (are [input-size part-size] (= (->> (range input-size)
+                                      (partition-all part-size))
+                                 (->> (range input-size)
+                                      (rx/seq->o)
+                                      (rx/partition-all part-size)
+                                      (rx/map #(rx/into [] %))
+                                      (rx/concat*)
+                                      (b/into [])))
+       0 1
+       10 2
+       10 3
+       15 30))
+
 (deftest test-reduce
   (is (= (reduce + 0 (range 4))
          (b/first (rx/reduce + 0 (rx/seq->o (range 4)))))))

From 1ffe5fb9c8581185e0e090c2b4c8d71cb91ce488 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 10:04:53 -0800
Subject: [PATCH 038/422] Avoid intermediate toList for blocking/into

---
 .../src/main/clojure/rx/lang/clojure/blocking.clj              | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
index 4512022466..feee933225 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/blocking.clj
@@ -99,7 +99,8 @@
     rx/into
   "
   [to from-observable]
-  (first (rx/into to from-observable)))
+  (with-ex-unwrap
+    (clojure.core/into to (o->seq from-observable))))
 
 (defn doseq*
   "*Blocks* and executes (f x) for each x emitted by xs

From 7f4f07ed83df6e01619f888d557eec3675ac203c Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 12:09:46 -0800
Subject: [PATCH 039/422] Update merge/merge-delay-error impls.

Split merge into merge/merge* for consistency with other functions that
can take one or more observables or observable of observables.
---
 .../src/main/clojure/rx/lang/clojure/core.clj | 52 +++++++++++--------
 .../clojure/rx/lang/clojure/core_test.clj     | 48 ++++++++++++-----
 2 files changed, 63 insertions(+), 37 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index f74df0eed6..129306f43d 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -288,39 +288,45 @@
   ([lock ^Observable xs]
   (.synchronize xs lock)))
 
-(defn ^Observable merge
-  "Observable.merge, renamed because merge means something else in Clojure
+(defn merge*
+  "Merge an Observable of Observables into a single Observable
+
+  If you want clojure.core/merge, it's just this:
 
-  os is one of:
+    (rx/reduce clojure.core/merge {} maps)
 
-    * An Iterable of Observables to merge
-    * An Observable<Observable<T>> to merge
+  See:
+    merge
+    merge-delay-error*
+    rx.Observable/merge
+  "
+  [^Observable xs]
+  (Observable/merge xs))
+
+(defn ^Observable merge
+  "Merge one or more Observables into a single observable.
 
   If you want clojure.core/merge, it's just this:
 
     (rx/reduce clojure.core/merge {} maps)
 
+  See:
+    merge*
+    merge-delay-error
+    rx.Observable/merge
   "
-  [os]
-  (cond
-    (instance? Iterable os)
-      (Observable/merge (Observable/from ^Iterable os))
-    (instance? Observable os)
-      (Observable/merge ^Observable os)
-    :else
-      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
+  [& os]
+  (merge* (seq->o os)))
 
-(defn ^Observable merge-delay-error
-  "Observable.mergeDelayError"
-  [os]
-  (cond
-    (instance? java.util.List os)
-      (Observable/mergeDelayError ^java.util.List os)
-    (instance? Observable os)
-      (Observable/mergeDelayError ^Observable os)
-    :else
-      (throw (IllegalArgumentException. (str "Don't know how to merge " (type os))))))
+(defn ^Observable merge-delay-error*
+  "Same as merge*, but all values are emitted before errors are propagated"
+  [^Observable xs]
+  (Observable/mergeDelayError xs))
 
+(defn ^Observable merge-delay-error
+  "Same as merge, but all values are emitted before errors are propagated"
+  [& os]
+  (merge-delay-error* (seq->o os)))
 
 (defn cache
   "caches the observable value so that multiple subscribers don't re-evaluate it.
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 47db658c6c..f9a47dd99b 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -111,20 +111,40 @@
                 (rx/synchronize lock)
                 (b/into []))))))
 
-(deftest test-merge
-  (is (= [[1 3 5] [2 4 6]]
-         (let [r (b/into []
-                   (rx/merge [(f/future-generator f/default-runner [o]
-                                                   (doseq [x [1 3 5]]
-                                                     (Thread/sleep 10)
-                                                     (rx/on-next o x)))
-                              (f/future-generator f/default-runner [o]
-                                                   (doseq [x [2 4 6]]
-                                                     (Thread/sleep 10)
-                                                     (rx/on-next o x)))]))]
-           ; make sure each sequence maintained original order
-           [(keep #{1 3 5} r)
-            (keep #{2 4 6} r) ]))))
+(let [expected-result [[1 3 5] [2 4 6]]
+      sleepy-o        #(f/future-generator f/default-runner [o]
+                                           (doseq [x %]
+                                             (Thread/sleep 10)
+                                             (rx/on-next o x))) 
+      make-inputs (fn [] (mapv sleepy-o expected-result))
+      make-output (fn [r] [(keep #{1 3 5} r)
+                           (keep #{2 4 6} r)])]
+  (deftest test-merge*
+    (is (= expected-result
+           (->> (make-inputs)
+                (rx/seq->o)
+                (rx/merge*)
+                (b/into [])
+                (make-output)))))
+  (deftest test-merge
+    (is (= expected-result
+           (->> (make-inputs)
+                (apply rx/merge)
+                (b/into [])
+                (make-output)))))
+  (deftest test-merge-delay-error*
+    (is (= expected-result
+           (->> (make-inputs)
+                (rx/seq->o)
+                (rx/merge-delay-error*)
+                (b/into [])
+                (make-output)))))
+  (deftest test-merge-delay-error
+    (is (= expected-result
+           (->> (make-inputs)
+                (apply rx/merge-delay-error)
+                (b/into [])
+                (make-output))))))
 
 (deftest test-generator
   (testing "calls on-completed automatically"

From 67cf57e2a37618c1134ad3cf1e1a87a50111a226 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 12:17:28 -0800
Subject: [PATCH 040/422] Updates from @mbossenbroek's feedback.

---
 .../src/main/clojure/rx/lang/clojure/core.clj  | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 129306f43d..c87d6d2e1b 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -96,7 +96,7 @@
 (declare unsubscribed?)
 
 (defn ^Subscriber subscriber
-  ""
+  "Experimental, subject to change or deletion."
   ([o on-next-action] (subscriber o on-next-action nil nil))
   ([o on-next-action on-error-action] (subscriber o on-next-action on-error-action nil))
   ([^Subscriber o on-next-action on-error-action on-completed-action]
@@ -125,7 +125,9 @@
   (Subscriptions/create ^Action0 (iop/action* handler)))
 
 (defn ^Observable$Operator operator*
-  "Returns a new implementation of rx.Observable$Operator that calls the given
+  "Experimental, subject to change or deletion.
+
+  Returns a new implementation of rx.Observable$Operator that calls the given
   function with a rx.Subscriber. The function should return a rx.Subscriber.
 
   See:
@@ -188,6 +190,13 @@
 ;################################################################################
 
 (defn ^Subscription subscribe
+  "Subscribe to the given observable.
+
+  on-X-action is a normal clojure function.
+
+  See:
+    rx.Observable/subscribe
+  "
 
   ([^Observable o on-next-action]
     (.subscribe o
@@ -283,6 +292,11 @@
 ; Operators
 
 (defn synchronize
+  "Synchronize execution.
+
+  See:
+    rx.Observable/synchronize
+  "
   ([^Observable xs]
   (.synchronize xs))
   ([lock ^Observable xs]

From 2b597fc19fa70ac48423bbe285a2b38241354077 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 13:54:19 -0800
Subject: [PATCH 041/422] interpose docstring

---
 .../rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index c87d6d2e1b..28ef283e30 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -532,6 +532,11 @@
        (concat*)))
 
 (defn interpose
+  "Returns an Observable of the elements of xs separated by sep
+
+  See:
+    clojure.core/interpose
+  "
   [sep xs]
   (let [op (operator* (fn [o]
                         (let [first? (atom true)]

From c573cfd87c6f13ed037fc0e7a31155dcc0b95aca Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 15:17:07 -0800
Subject: [PATCH 042/422] Reimplement into without toList

---
 .../src/main/clojure/rx/lang/clojure/core.clj         |  9 +++++----
 .../src/test/clojure/rx/lang/clojure/core_test.clj    | 11 ++++++++---
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 28ef283e30..2a61e0ed20 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -554,10 +554,11 @@
     clojure.core/into
     rx.Observable/toList
   "
-  [to ^Observable from-observable]
-  (->> from-observable
-   .toList
-   (map (partial clojure.core/into to))))
+  [to ^Observable from]
+  ; clojure.core/into uses transients if to is IEditableCollection
+  ; I don't think we have any guarantee that all on-next calls will be on the
+  ; same thread, so we can't do that here.
+  (reduce conj to from))
 
 (defn keep
   [f xs]
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index f9a47dd99b..accd20cfed 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -115,7 +115,7 @@
       sleepy-o        #(f/future-generator f/default-runner [o]
                                            (doseq [x %]
                                              (Thread/sleep 10)
-                                             (rx/on-next o x))) 
+                                             (rx/on-next o x)))
       make-inputs (fn [] (mapv sleepy-o expected-result))
       make-output (fn [r] [(keep #{1 3 5} r)
                            (keep #{2 4 6} r)])]
@@ -338,8 +338,13 @@
          (b/into [] (rx/interpose \, (rx/seq->o [1 2 3]))))))
 
 (deftest test-into
-  (is (= (into [6 7 8] [9 10 [11]])
-         (b/first (rx/into [6 7 8] (rx/seq->o [9 10 [11]]))))))
+  (are [input to] (= (into to input)
+                     (b/single (rx/into to (rx/seq->o input))))
+       [6 7 8] [9 10 [11]]
+       #{} [1 2 3 2 4 5]
+       {} [[1 2] [3 2] [4 5]]
+       {} []
+       '() (range 50)))
 
 (deftest test-keep
   (is (= (into [] (keep identity [true true false]))

From c51054ea4d335997f7f26aed77937d44c83f0a3d Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 15:35:36 -0800
Subject: [PATCH 043/422] Update generator docstring

---
 .../src/main/clojure/rx/lang/clojure/core.clj          | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 2a61e0ed20..1ddf30b09b 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -432,7 +432,7 @@
   Example:
 
     (->> (rx/seq->o [1 2 3])
-    (rx/do println)
+         (rx/do println)
     ...)
 
   Will print 1, 2, 3.
@@ -884,8 +884,8 @@
 ;################################################################################;
 
 (defn generator*
-  "Creates an observable that calls (f observable & args) which should emit values
-  with (rx/on-next observable value).
+  "Creates an observable that calls (f observer & args) which should emit values
+  with (rx/on-next observer value).
 
   Automatically calls on-completed on return, or on-error if any exception is thrown.
 
@@ -902,8 +902,8 @@
                    wrap-on-error)))
 
 (defmacro generator
-  "Create an observable that executes body which should emit a sequence. bindings
-  should be a single [observer] argument.
+  "Create an observable that executes body which should emit values with
+  (rx/on-next observer value) where observer comes from bindings.
 
   Automatically calls on-completed on return, or on-error if any exception is thrown.
 

From ea22e7ae8d00315234511125262a237b75245ce3 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 17:21:09 -0800
Subject: [PATCH 044/422] Make catch and finally ->> friendly

Base on @mbossenbroek's feedback. Seems like an improvement.
---
 .../src/main/clojure/rx/lang/clojure/core.clj | 75 +++++++++++--------
 .../clojure/rx/lang/clojure/core_test.clj     | 66 +++++++---------
 .../clojure/rx/lang/clojure/future_test.clj   | 25 ++++---
 3 files changed, 87 insertions(+), 79 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 1ddf30b09b..8865fa0b21 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -798,7 +798,7 @@
 
 (defn catch*
   "Returns an observable that, when Observable o triggers an error, e, continues with
-  Observable returned by (apply f e args) if (p e) is true. If (p e) returns a Throwable
+  Observable returned by (f e) if (p e) is true. If (p e) returns a Throwable
   that value is passed as e.
 
   If p is a class object, a normal instance? check is performed rather than calling it
@@ -806,26 +806,30 @@
 
   Examples:
 
-    (-> my-observable
+    (->> my-observable
 
-        ; On IllegalArgumentException, just emit 1
-        (catch* IllegalArgumentException (fn [e] (rx/return 1)))
+         ; On IllegalArgumentException, just emit 1
+         (catch* IllegalArgumentException
+                 (fn [e] (rx/return 1)))
 
-        ; If exception message contains \"WAT\", emit [\\W \\A \\T]
-        (catch* #(-> % .getMessage (.contains \"WAT\")) (rx/seq->o [\\W \\A \\T])))
+         ; If exception message contains \"WAT\", emit [\\W \\A \\T]
+         (catch* (fn [e] (-> e .getMessage (.contains \"WAT\")))
+                 (fn [e] (rx/seq->o [\\W \\A \\T]))))
 
   See:
-
+    rx.Observable/onErrorResumeNext
     http://netflix.github.io/RxJava/javadoc/rx/Observable.html#onErrorResumeNext(rx.util.functions.Func1)
   "
-  [^Observable o p f & args]
+  [p f ^Observable o]
   (let [p (if (class? p)
             (fn [e] (.isInstance ^Class p e))
             p)]
     (.onErrorResumeNext o
                         ^Func1 (iop/fn [e]
                                  (if-let [maybe-e (p e)]
-                                   (apply f (if (instance? Throwable maybe-e) maybe-e e) args)
+                                   (f (if (instance? Throwable maybe-e)
+                                        maybe-e
+                                        e))
                                    (rx.lang.clojure.core/throw e))))))
 
 (defmacro catch
@@ -833,53 +837,64 @@
 
   The body of the catch is wrapped in an implicit (do). It must evaluate to an Observable.
 
-  Note that the source observable is the first argument so this won't mix well with ->>
-  threading.
+  Note that the source observable is the last argument so this works with ->> but may look
+  slightly odd when used standalone.
 
   Example:
 
-    (-> my-observable
-        ; just emit 0 on IllegalArgumentException
-        (catch IllegalArgumentException e
-          (rx/return 0))
+    (->> my-observable
+         ; just emit 0 on IllegalArgumentException
+         (catch IllegalArgumentException e
+           (rx/return 0))
 
-        (catch DependencyException e
-          (if (.isMinor e)
-            (rx/return 0)
-            (rx/throw (WebException. 503)))))
+         (catch DependencyException e
+           (if (.isMinor e)
+             (rx/return 0)
+             (rx/throw (WebException. 503)))))
 
   See:
     catch*
   "
-  [o p binding & body]
-  `(catch* ~o ~p (fn [~binding] ~@body)))
+  {:arglists '([p binding & body observable])}
+  [p binding & body]
+  (let [o    (last body)
+        body (butlast body)]
+    `(catch* ~p
+             (fn [~binding] ~@body)
+             ~o)))
 
 (defn finally*
-  "Returns an Observable that, as a side-effect, executes (apply f args) when the given
+  "Returns an Observable that, as a side-effect, executes (f) when the given
   Observable completes regardless of success or failure.
 
   Example:
 
-    (-> my-observable
-        (finally* (fn [] (println \"Done\"))))
+    (->> my-observable
+         (finally* (fn [] (println \"Done\"))))
 
   "
-  [^Observable o f & args]
-  (.finallyDo o ^Action0 (iop/action [] (apply f args))))
+  [f ^Observable o]
+  (.finallyDo o ^Action0 (iop/action* f)))
 
 (defmacro finally
   "Macro version of finally*.
 
+  Note that the source observable is the last argument so this works with ->> but may look
+  slightly odd when used standalone.
+
   Example:
 
-    (-> my-observable
-        (finally (println \"Done\")))
+    (->> my-observable
+         (finally (println \"Done\")))
 
   See:
     finally*
   "
-  [o & body]
-  `(finally* ~o (fn [] ~@body)))
+  {:arglists '([& body observable])}
+  [& body]
+  (let [o    (last body)
+        body (butlast body)]
+    `(finally* (fn [] ~@body) ~o)))
 
 ;################################################################################;
 
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index accd20cfed..89f1a4caf4 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -531,33 +531,30 @@
 (deftest test-catch*
   (testing "Is just a passthrough if there's no error"
     (is (= [1 2 3]
-           (b/into []
-                   (->
-                     (rx/seq->o [1 2 3])
-                     (rx/catch* Exception (fn [e] (throw "OH NO"))))))))
+           (->> (rx/seq->o [1 2 3])
+                (rx/catch* Exception (fn [e] (throw "OH NO")))
+                (b/into [])))))
 
   (testing "Can catch a particular exception type and continue with an observable"
     (is (= [1 2 4 5 6 "foo"]
-           (b/into []
-                   (->
-                     (rx/generator [o]
-                                   (rx/on-next o 1)
-                                   (rx/on-next o 2)
-                                   (rx/on-error o (IllegalStateException. "foo")))
-                     (rx/catch* IllegalStateException
-                             (fn [e]
-                               (rx/seq->o [4 5 6 (.getMessage e)]))))))))
+           (->> (rx/generator [o]
+                              (rx/on-next o 1)
+                              (rx/on-next o 2)
+                              (rx/on-error o (IllegalStateException. "foo")))
+                (rx/catch* IllegalStateException
+                           (fn [e]
+                             (rx/seq->o [4 5 6 (.getMessage e)])))
+                (b/into [])))))
 
   (testing "if exception isn't matched, it's passed to on-error"
     (let [expected (IllegalArgumentException. "HI")
           called (atom nil)]
-    (rx/subscribe (->
-                    (rx/generator [o]
-                                   (rx/on-next o 1)
-                                   (rx/on-next o 2)
-                                   (rx/on-error o expected))
-                    (rx/catch* IllegalStateException (fn [e]
-                      (rx/return "WAT?"))))
+      (rx/subscribe (->> (rx/generator [o]
+                                       (rx/on-next o 1)
+                                       (rx/on-next o 2)
+                                       (rx/on-error o expected))
+                         (rx/catch* IllegalStateException (fn [e]
+                                                            (rx/return "WAT?"))))
                   (fn [_])
                   (fn [e] (reset! called expected))
                   (fn [_]))
@@ -567,12 +564,10 @@
     (let [cause (IllegalArgumentException. "HI")
           wrapper (java.util.concurrent.ExecutionException. cause)]
       (is (= [cause]
-             (b/into []
-                     (->
-                       (rx/generator [o]
-                                     (rx/on-error o wrapper))
-                       (rx/catch #(.getCause %) e
-                         (rx/return e)))))))))
+             (->> (rx/throw wrapper)
+                  (rx/catch #(.getCause %) e
+                    (rx/return e))
+                  (b/into [])))))))
 
 
 (deftest test-finally
@@ -580,10 +575,8 @@
     (testing "called on completed"
       (let [completed (atom nil)
             called (atom nil)]
-        (rx/subscribe (->
-                        (rx/seq->o [1 2 3])
-                        (rx/finally* (fn [extra] (reset! called (str "got " extra)))
-                                     "it"))
+        (rx/subscribe (->> (rx/seq->o [1 2 3])
+                           (rx/finally* (fn [] (reset! called (str "got it")))))
                       (fn [_])
                       (fn [_] (throw (IllegalStateException. "WAT")))
                       (fn [] (reset! completed "DONE")))
@@ -594,13 +587,12 @@
       (let [expected (IllegalStateException. "expected")
             completed (atom nil)
             called (atom nil)]
-        (rx/subscribe (->
-                        (rx/generator [o]
-                                   (rx/on-next o 1)
-                                   (rx/on-next o 2)
-                                   (rx/on-error o expected))
-                        (rx/finally
-                          (reset! called "got it")))
+        (rx/subscribe (->> (rx/generator [o]
+                                         (rx/on-next o 1)
+                                         (rx/on-next o 2)
+                                         (rx/on-error o expected))
+                           (rx/finally
+                             (reset! called "got it")))
                       (fn [_])
                       (fn [e] (reset! completed e))
                       (fn [] (throw (IllegalStateException. "WAT"))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
index 46682ddc44..ae2bf4c81f 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
@@ -17,10 +17,10 @@
 
 (deftest test-future-exception
   (is (= "Caught: boo"
-         (-> (f/future f/default-runner (throw (java.io.FileNotFoundException. "boo")))
-             (rx/catch java.io.FileNotFoundException e
-               (rx/return (str "Caught: " (.getMessage e))))
-             (b/single)))))
+         (->> (f/future f/default-runner (throw (java.io.FileNotFoundException. "boo")))
+              (rx/catch java.io.FileNotFoundException e
+                (rx/return (str "Caught: " (.getMessage e))))
+              (b/single)))))
 
 (deftest test-future-cancel
   (let [exited? (atom nil)
@@ -52,11 +52,12 @@
 (deftest test-future-generator-exception
   (let [e (java.io.FileNotFoundException. "snake")]
     (is (= [1 2 e]
-           (b/into [] (-> (f/future-generator
-                            f/default-runner
-                            [o]
-                            (rx/on-next o 1)
-                            (rx/on-next o 2)
-                            (throw e))
-                          (rx/catch java.io.FileNotFoundException e
-                            (rx/return e))))))))
+           (->> (f/future-generator
+                  f/default-runner
+                  [o]
+                  (rx/on-next o 1)
+                  (rx/on-next o 2)
+                  (throw e))
+                (rx/catch java.io.FileNotFoundException e
+                  (rx/return e))
+                (b/into []))))))

From ee45b4494123849b9a18738c9d8b81c145464ee9 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 20:44:38 -0800
Subject: [PATCH 045/422] Eliminate sorted-list variants and cleanup sort tests

---
 .../src/main/clojure/rx/lang/clojure/core.clj | 41 ++-------------
 .../clojure/rx/lang/clojure/core_test.clj     | 52 ++++++++++---------
 2 files changed, 32 insertions(+), 61 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 8865fa0b21..5f007abbe2 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -681,36 +681,7 @@
        (filter identity)
        first))
 
-(defn sorted-list
-  "Returns an observable that emits a *single value* which is a sorted List
-  of the items in coll, where the sort order is determined by comparing
-  items.  If no comparator is supplied, uses compare. comparator must
-  implement java.util.Comparator.
-
-  Use sort if you don't want the sequence squashed down to a List.
-
-  See:
-    rx.Observable/toSortedList
-    sort
-  "
-  ([coll] (sorted-list clojure.core/compare coll))
-  ([comp ^Observable coll]
-   (.toSortedList coll (iop/fn [a b]
-                         ; force to int so rxjava doesn't have a fit
-                         (int (comp a b))))))
-
-(defn sorted-list-by
-  "Returns an observable that emits a *single value* which is a sorted List
-  of the items in coll, where the sort order is determined by comparing
-  (keyfn item).  If no comparator is supplied, uses compare. comparator must
-  implement java.util.Comparator.
-
-  Use sort-by if you don't want the sequence squashed down to a List.
-
-  See:
-    rx.Observable/toSortedList
-    sort-by
-  "
+(defn ^:private sorted-list-by
   ([keyfn coll] (sorted-list-by keyfn clojure.core/compare coll))
   ([keyfn comp ^Observable coll]
    (.toSortedList coll (iop/fn [a b]
@@ -723,16 +694,13 @@
   comparator must implement java.util.Comparator.
 
   See:
-    sorted-list
     clojure.core/sort
   "
   ([xs]
-   (->> xs
-        (sorted-list)
-        (mapcat seq->o)))
+   (sort clojure.core/compare xs))
   ([comp xs]
    (->> xs
-        (sorted-list comp)
+        (sorted-list-by identity comp)
         (mapcat seq->o))))
 
 (defn sort-by
@@ -744,8 +712,7 @@
     clojure.core/sort-by
   "
   ([keyfn xs]
-   (->> (sorted-list-by keyfn xs)
-        (mapcat seq->o)))
+   (sort-by keyfn clojure.core/compare xs))
   ([keyfn comp ^Observable xs]
    (->> xs
         (sorted-list-by keyfn comp)
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 89f1a4caf4..f0c3242ce5 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -480,33 +480,37 @@
   (is (= [:r] (b/into [] (rx/some #{:r :s :t} (rx/seq->o [:q :v :r])))))
   (is (= [] (b/into [] (rx/some #{:r :s :t} (rx/seq->o [:q :v]))))))
 
-(deftest test-sorted-list
-  (is (= [[]] (b/into [] (rx/sorted-list (rx/empty)))))
-  (is (= [[1 2 3]]
-         (b/into [] (rx/sorted-list (rx/seq->o [3 1 2])))))
-  (is (= [[3 2 1]]
-         (b/into [] (rx/sorted-list (fn [a b] (- (compare a b))) (rx/seq->o [2 1 3]))))))
-
-(deftest test-sorted-list-by
-  (is (= [[]] (b/into [] (rx/sorted-list-by :foo (rx/empty)))))
-  (is (= [[{:foo 1} {:foo 2} {:foo 3}]]
-         (b/into [] (rx/sorted-list-by :foo (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}])))))
-  (is (= [[{:foo 3} {:foo 2} {:foo 1}]]
-         (b/into [] (rx/sorted-list-by :foo (fn [a b] (- (compare a b))) (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}]))))))
-
 (deftest test-sort
-  (is (= [] (b/into [] (rx/sort (rx/empty)))))
-  (is (= [1 2 3]
-         (b/into [] (rx/sort (rx/seq->o [3 1 2])))))
-  (is (= [3 2 1]
-         (b/into [] (rx/sort (fn [a b] (- (compare a b))) (rx/seq->o [2 1 3]))))))
+  (are [in cmp] (= (if cmp
+                     (sort cmp in)
+                     (sort in))
+                   (->> in
+                        (rx/seq->o)
+                        (#(if cmp (rx/sort cmp %) (rx/sort %)))
+                        (b/into [])))
+       []      nil
+       []      (comp - compare)
+       [3 1 2] nil
+       [1 2 3] nil
+       [1 2 3] (comp - compare)
+       [2 1 3] (comp - compare)))
 
 (deftest test-sort-by
-  (is (= [] (b/into [] (rx/sort-by :foo (rx/empty)))))
-  (is (= [{:foo 1} {:foo 2} {:foo 3}]
-         (b/into [] (rx/sort-by :foo (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}])))))
-  (is (= [{:foo 3} {:foo 2} {:foo 1}]
-         (b/into [] (rx/sort-by :foo (fn [a b] (- (compare a b))) (rx/seq->o [{:foo 2}{:foo 1}{:foo 3}]))))))
+  (are [rin cmp] (let [in (map #(hash-map :foo %) rin)]
+                   (= (if cmp
+                        (sort-by :foo cmp in)
+                        (sort-by :foo in))
+                      (->> in
+                           (rx/seq->o)
+                           (#(if cmp (rx/sort-by :foo cmp %) (rx/sort-by :foo %)))
+                           (b/into []))))
+       []      nil
+       []      (comp - compare)
+       [3 1 2] nil
+       [1 2 3] nil
+       [1 2 3] (comp - compare)
+       [2 1 3] (comp - compare)))
+
 
 (deftest test-split-with
   (is (= (split-with (partial >= 3) (range 6))

From 9269d4e9e00db7c2edb68d471b47dad76b3da827 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 21:26:18 -0800
Subject: [PATCH 046/422] Eliminated macro version of future stuff based on
 feedback.

---
 .../main/clojure/rx/lang/clojure/future.clj   | 97 ++++++-------------
 .../clojure/rx/lang/clojure/chunk_test.clj    | 55 ++++++-----
 .../clojure/rx/lang/clojure/core_test.clj     | 10 +-
 .../clojure/rx/lang/clojure/future_test.clj   | 40 ++++----
 .../clojure/rx/lang/clojure/graph_test.clj    | 44 +++++----
 5 files changed, 113 insertions(+), 133 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
index 0c63be36e8..83b56b27b6 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/future.clj
@@ -2,20 +2,17 @@
   "Functions and macros for making rx-ified futures. That is, run some code in some
    other thread and return an Observable of its result.
   "
-  (:refer-clojure :exclude [future])
   (:require [rx.lang.clojure.interop :as iop]
             [rx.lang.clojure.core :as rx]))
 
 (def ^:private -ns- *ns*)
 (set! *warn-on-reflection* true)
 
-(defn default-runner
-  "Default runner creator function. Creates futures on Clojure's default future thread pool."
-  [f]
-  (future-call f))
+(defn future*
+  "Exerimental/Possibly a bad idea
 
-(defn future-generator*
-  "Same as rx/generator* except f is invoked in a separate thread.
+  Execute (f & args) in a separate thread and pass the result to onNext.
+  If an exception is thrown, onError is called with the exception.
 
   runner is a function that takes a no-arg function argument and returns a future
   representing the execution of that function.
@@ -23,23 +20,27 @@
   Returns an Observable. If the subscriber unsubscribes, the future will be canceled
   with clojure.core/future-cancel
 
-  See:
-    rx.lang.clojure.core/generator*
-    rx.lang.clojure.future/future-generator
+  Examples:
+
+    (subscribe (rx/future future-call
+                  #(slurp \"input.txt\"))
+               (fn [v] (println \"Got: \" v)))
+    ; eventually outputs content of input.txt
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
   (rx/observable* (fn [^rx.Subscriber observer]
-              (let [wrapped (-> (fn [o]
-                                  (apply f o args))
-                                rx/wrap-on-completed
-                                rx/wrap-on-error)
-                    fu      (runner #(wrapped observer))]
-              (.add observer
-                    (rx/subscription #(future-cancel fu)))))))
+                    (let [wrapped (-> #(rx/on-next % (apply f args))
+                                      rx/wrap-on-completed
+                                      rx/wrap-on-error)
+                          fu      (runner #(wrapped observer))]
+                      (.add observer
+                            (rx/subscription #(future-cancel fu)))))))
 
-(defmacro future-generator
-  "Same as rx/generator macro except body is invoked in a separate thread.
+(defn future-generator*
+  "Exerimental/Possibly a bad idea
+
+  Same as rx/generator* except f is invoked in a separate thread.
 
   runner is a function that takes a no-arg function argument and returns a future
   representing the execution of that function.
@@ -49,56 +50,22 @@
 
   Example:
 
-    (future-generator default-runner
-      [o]
-      (rx/on-next o 1)
-      (Thread/sleep 1000)
-      (rx/on-next o 2))
+    (future-generator* future-call
+      (fn [o]
+        (rx/on-next o 1)
+        (Thread/sleep 1000)
+        (rx/on-next o 2)))
 
   See:
     rx.lang.clojure.core/generator*
-    rx.lang.clojure.future/future-generator
-  "
-  [runner bindings & body]
-  `(future-generator* ~runner (fn ~bindings ~@body)))
-
-(defn future*
-  "Execute (f & args) in a separate thread and pass the result to onNext.
-  If an exception is thrown, onError is called with the exception.
-
-  runner is a function that takes a no-arg function argument and returns a future
-  representing the execution of that function.
-
-  Returns an Observable. If the subscriber unsubscribes, the future will be canceled
-  with clojure.core/future-cancel
   "
   [runner f & args]
   {:pre [(ifn? runner) (ifn? f)]}
   (rx/observable* (fn [^rx.Subscriber observer]
-           (let [wrapped (-> #(rx/on-next % (apply f args))
-                             rx/wrap-on-completed
-                             rx/wrap-on-error)
-                 fu      (runner #(wrapped observer))]
-             (.add observer
-                   (rx/subscription #(future-cancel fu)))))))
-
-(defmacro future
-  "Executes body in a separate thread and passes the single result to onNext.
-  If an exception occurs, onError is called.
-
-  Returns an Observable. If the subscriber unsubscribes, the future will be canceled
-  with clojure.core/future-cancel
-
-  runner is a function that takes a no-arg function argument and returns a future
-  representing the execution of that function.
-
-  Examples:
-
-    (subscribe (rx/future rx/default-runner
-                  (slurp \"input.txt\"))
-               (fn [v] (println \"Got: \" v)))
-    ; eventually outputs content of input.txt
-  "
-  [runner & body]
-  `(future* ~runner (fn [] ~@body)))
-
+                    (let [wrapped (-> (fn [o]
+                                        (apply f o args))
+                                      rx/wrap-on-completed
+                                      rx/wrap-on-error)
+                          fu      (runner #(wrapped observer))]
+                      (.add observer
+                            (rx/subscription #(future-cancel fu)))))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj
index c0d8974e8b..58ef044c9d 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/chunk_test.clj
@@ -9,13 +9,16 @@
 (deftest test-chunk
   (let [n          20
         chunk-size 10
-        factory (rx-future/future-generator rx-future/default-runner [o]
-                  (doseq [i (range n)]
-                    (Thread/sleep (rand-int 50))
-                    (rx/on-next o (rx-future/future rx-future/default-runner
-                                      (let [t (rand-int 500)]
-                                        (Thread/sleep t))
-                                      i))))]
+        factory (rx-future/future-generator*
+                  future-call
+                  (fn[o]
+                    (doseq [i (range n)]
+                      (Thread/sleep (rand-int 50))
+                      (rx/on-next o (rx-future/future*
+                                      future-call
+                                      #(let [t (rand-int 500)]
+                                         (Thread/sleep t)
+                                         i))))))]
     (is (= (range n)
            (sort (rx-blocking/into []
                                    (rx-chunk/chunk chunk-size {:debug true} factory)))))))
@@ -24,14 +27,17 @@
   (testing "error from source is propagated"
     (let [n          20
           chunk-size 4
-          factory (rx-future/future-generator rx-future/default-runner [o]
-                                              (doseq [i (range n)]
-                                                (Thread/sleep (rand-int 50))
-                                                (rx/on-next o (rx-future/future rx-future/default-runner
-                                                                                (let [t (rand-int 1000)]
-                                                                                  (Thread/sleep t))
-                                                                                i)))
-                                              (throw (IllegalArgumentException. "hi")))]
+          factory (rx-future/future-generator*
+                    future-call
+                    (fn [o]
+                      (doseq [i (range n)]
+                        (Thread/sleep (rand-int 50))
+                        (rx/on-next o (rx-future/future*
+                                        future-call
+                                        #(let [t (rand-int 1000)]
+                                           (Thread/sleep t)
+                                           i))))
+                      (throw (IllegalArgumentException. "hi"))))]
       (is (thrown-with-msg? IllegalArgumentException #"hi"
                             (rx-blocking/into []
                                               (rx-chunk/chunk chunk-size {:debug true} factory))))))
@@ -39,14 +45,17 @@
   (testing "error from single observable is propagated"
     (let [n          20
           chunk-size 4
-          factory (rx-future/future-generator rx-future/default-runner [o]
-                                              (doseq [i (range n)]
-                                                (Thread/sleep (rand-int 50))
-                                                (rx/on-next o (rx-future/future rx-future/default-runner
-                                                                                (let [t (rand-int 1000)]
-                                                                                  (throw (IllegalArgumentException. "byebye"))
-                                                                                  (Thread/sleep t))
-                                                                                i))))]
+          factory (rx-future/future-generator*
+                    future-call
+                    (fn [o]
+                      (doseq [i (range n)]
+                        (Thread/sleep (rand-int 50))
+                        (rx/on-next o (rx-future/future*
+                                        future-call
+                                        #(let [t (rand-int 1000)]
+                                           (throw (IllegalArgumentException. "byebye"))
+                                           (Thread/sleep t)
+                                           i))))))]
       (is (thrown? rx.exceptions.CompositeException
                    (rx-blocking/into []
                                      (rx-chunk/chunk chunk-size
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index f0c3242ce5..0ec806c6bd 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -112,10 +112,12 @@
                 (b/into []))))))
 
 (let [expected-result [[1 3 5] [2 4 6]]
-      sleepy-o        #(f/future-generator f/default-runner [o]
-                                           (doseq [x %]
-                                             (Thread/sleep 10)
-                                             (rx/on-next o x)))
+      sleepy-o        #(f/future-generator*
+                         future-call
+                         (fn [o]
+                           (doseq [x %]
+                             (Thread/sleep 10)
+                             (rx/on-next o x))))
       make-inputs (fn [] (mapv sleepy-o expected-result))
       make-output (fn [r] [(keep #{1 3 5} r)
                            (keep #{2 4 6} r)])]
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
index ae2bf4c81f..ba2344e4e2 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/future_test.clj
@@ -7,27 +7,25 @@
 (deftest test-future-generator
   (is (not= [(.getId (Thread/currentThread))]
             (b/into []
-                      (f/future-generator f/default-runner
-                        [observer]
-                        (rx/on-next observer (.getId (Thread/currentThread))))))))
+                      (f/future-generator* future-call
+                        #(rx/on-next % (.getId (Thread/currentThread))))))))
 
 (deftest test-future
-  (is (= [15] (b/into [] (f/future* f/default-runner + 1 2 3 4 5))))
-  (is (= [15] (b/into [] (f/future f/default-runner (println "HI") (+ 1 2 3 4 5))))) )
+  (is (= [15] (b/into [] (f/future* future-call + 1 2 3 4 5)))))
 
 (deftest test-future-exception
   (is (= "Caught: boo"
-         (->> (f/future f/default-runner (throw (java.io.FileNotFoundException. "boo")))
+         (->> (f/future* future-call #(throw (java.io.FileNotFoundException. "boo")))
               (rx/catch java.io.FileNotFoundException e
                 (rx/return (str "Caught: " (.getMessage e))))
               (b/single)))))
 
 (deftest test-future-cancel
   (let [exited? (atom nil)
-        o (f/future f/default-runner
-            (Thread/sleep 1000)
-            (reset! exited? true)
-            "WAT")
+        o (f/future* future-call
+                     (fn [] (Thread/sleep 1000)
+                       (reset! exited? true)
+                       "WAT"))
         result (->> o
                     (rx/take 0)
                     (b/into []))]
@@ -37,11 +35,11 @@
 
 (deftest test-future-generator-cancel
   (let [exited? (atom nil)
-        o (f/future-generator f/default-runner
-            [o]
-            (rx/on-next o "FIRST")
-            (Thread/sleep 1000)
-            (reset! exited? true))
+        o (f/future-generator* future-call
+                               (fn [o]
+                                 (rx/on-next o "FIRST")
+                                 (Thread/sleep 1000)
+                                 (reset! exited? true)))
         result (->> o
                     (rx/take 1)
                     (b/into []))]
@@ -52,12 +50,12 @@
 (deftest test-future-generator-exception
   (let [e (java.io.FileNotFoundException. "snake")]
     (is (= [1 2 e]
-           (->> (f/future-generator
-                  f/default-runner
-                  [o]
-                  (rx/on-next o 1)
-                  (rx/on-next o 2)
-                  (throw e))
+           (->> (f/future-generator*
+                  future-call
+                  (fn [o]
+                    (rx/on-next o 1)
+                    (rx/on-next o 2)
+                    (throw e)))
                 (rx/catch java.io.FileNotFoundException e
                   (rx/return e))
                 (b/into []))))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
index cd3cf59788..56ddfc9ff3 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/graph_test.clj
@@ -43,8 +43,8 @@
            (rx-blocking/single
              (-> (let [z (rx/return "hi")] ; an observable from "somewhere else"
                    (graph/let-o
-                     [?a (rx-future/future rx-future/default-runner (Thread/sleep 50) 99)
-                      ?b (rx-future/future rx-future/default-runner (Thread/sleep 500) 100)
+                     [?a (rx-future/future* future-call #(do (Thread/sleep 50) 99))
+                      ?b (rx-future/future* future-call #(do (Thread/sleep 500) 100))
                       ?c (rx/map #(hash-map :a %1 :b %2 :z %3) ?a ?b ?z)
                       ?z z]
                      (rx/reduce merge {} ?c)))))))))
@@ -52,21 +52,24 @@
 (deftest test-complicated-graph
   ; These funcs model network requests for various stuff. They all return observable.
   (let [request-vhs (fn []
-                      (rx-future/future-generator rx-future/default-runner
-                                                 [o]
-                                                 (Thread/sleep 50)
-                                                 (doseq [i (range 3)]
-                                                   (rx/on-next o {:id i}))))
+                      (rx-future/future-generator*
+                        future-call
+                        (fn [o]
+                          (Thread/sleep 50)
+                          (doseq [i (range 3)]
+                            (rx/on-next o {:id i})))))
         request-user (fn [id]
-                       (rx-future/future rx-future/default-runner
-                                         (Thread/sleep (rand-int 250))
-                                         {:id id
-                                          :name (str "friend" id) }))
+                       (rx-future/future*
+                         future-call
+                         #(do (Thread/sleep (rand-int 250))
+                            {:id id
+                             :name (str "friend" id) })))
         request-ab (fn [u]
-                     (rx-future/future rx-future/default-runner
-                                       (Thread/sleep (rand-int 250))
-                                       {:user-id (:id u)
-                                        :cell    (* 2 (:id u))}))
+                     (rx-future/future*
+                       future-call
+                       #(do (Thread/sleep (rand-int 250))
+                          {:user-id (:id u)
+                           :cell    (* 2 (:id u))})))
 
         request-video-md (fn [v]
                            (rx/return {:video v
@@ -74,11 +77,12 @@
 
         ; Now we can stitch all these requests together into an rx graph to
         ; produce a response.
-        o (graph/let-o [?user-info (rx-future/future rx-future/default-runner
-                                                     (Thread/sleep 20)
-                                                     {:name "Bob"
-                                                      :id 12345
-                                                      :friend-ids [1 2 3] })
+        o (graph/let-o [?user-info (rx-future/future*
+                                     future-call
+                                     #(do (Thread/sleep 20)
+                                        {:name "Bob"
+                                         :id 12345
+                                         :friend-ids [1 2 3] }))
 
                         ?friends   (->> ?user-info
                                         (rx/mapcat (fn [ui]

From 9bc5a8578b52f6865ca0dcd038f348e34bc3d1f2 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Thu, 20 Feb 2014 23:20:31 -0800
Subject: [PATCH 047/422] Implemented multi-sequence mapcat

---
 .../src/main/clojure/rx/lang/clojure/core.clj | 21 +++++++++++++++++-
 .../clojure/rx/lang/clojure/core_test.clj     | 22 ++++++++++++++++++-
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 5f007abbe2..93926a786c 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -597,16 +597,35 @@
   (Observable/zip ^Iterable observables
                   ^rx.functions.FuncN (iop/fnN* f)))
 
+(defn ^Observable mapcat*
+  "Same as multi-arg mapcat, but input is an Observable of Observables.
+
+  See:
+    mapcat
+    clojure.core/mapcat
+  "
+  [f ^Observable xs]
+  (->> xs
+       (map* f)
+       (concat*)))
+
 (defn ^Observable mapcat
   "Returns an observable which, for each value x in xs, calls (f x), which must
   return an Observable. The resulting observables are concatentated together
   into one observable.
 
+  If multiple Observables are given, the arguments to f are the first item from
+  each observable, then the second item, etc.
+
   See:
     clojure.core/mapcat
     rx.Observable/flatMap
   "
-  ([f ^Observable xs] (.flatMap xs (iop/fn* f))))
+  [f & xs]
+  (if (clojure.core/next xs)
+    (mapcat* f (seq->o xs))
+    ; use built-in flatMap for single-arg case
+    (.flatMap ^Observable (clojure.core/first xs) (iop/fn* f))))
 
 (defn map-indexed
   "Returns an observable that invokes (f index value) for each value of the input
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 0ec806c6bd..9dc7a98a3e 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -423,11 +423,31 @@
       (catch java.io.FileNotFoundException e
         (is (= :b (-> e .getCause .getValue)))))))
 
+(deftest test-mapcat*
+  (let [f (fn [a b c d e]
+            [(+ a b) (+ c d) e])]
+    (is (= (->> (range 5)
+                (map (fn [_] (range 5)))
+                (apply mapcat f))
+           (->> (range 5)
+                (map (fn [_] (rx/seq->o (range 5))))
+                (rx/seq->o)
+                (rx/mapcat* (fn [& args] (rx/seq->o (apply f args))))
+                (b/into []))))))
+
 (deftest test-mapcat
   (let [f  (fn [v] [v (* v v)])
         xs (range 10)]
     (is (= (mapcat f xs)
-           (b/into [] (rx/mapcat (comp rx/seq->o f) (rx/seq->o xs)))))))
+           (b/into [] (rx/mapcat (comp rx/seq->o f) (rx/seq->o xs))))))
+
+  (let [f  (fn [a b] [a b (* a b)])
+        as (range 10)
+        bs (range 15)]
+    (is (= (mapcat f as bs)
+           (b/into [] (rx/mapcat (comp rx/seq->o f)
+                                 (rx/seq->o as)
+                                 (rx/seq->o bs)))))))
 
 (deftest test-next
   (let [in [:q :r :s :t :u]]

From ea2fd75386fd034494be029bcd0cda9442c144ab Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Fri, 21 Feb 2014 12:21:11 -0800
Subject: [PATCH 048/422] Remove val-fn version of group-by

---
 .../src/main/clojure/rx/lang/clojure/core.clj        | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 93926a786c..7850d44501 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -478,8 +478,7 @@
 
 (defn ^Observable group-by
   "Returns an Observable of clojure.lang.MapEntry where the key is the result of
-  (key-fn x) and the val is an Observable of (val-fn x) for each key. If val-fn is
-  omitted, it defaults to identity.
+  (key-fn x) and the val is an Observable of x for each key.
 
   This returns a clojure.lang.MapEntry rather than rx.observables.GroupedObservable
   for some vague consistency with clojure.core/group-by and so that clojure.core/key,
@@ -492,15 +491,6 @@
   "
   ([key-fn ^Observable xs]
    (->> (.groupBy xs (iop/fn* key-fn))
-        (map (fn [^GroupedObservable go]
-               (clojure.lang.MapEntry. (.getKey go) go)))))
-  ([key-fn val-fn ^Observable xs]
-   ; TODO reinstate once this is implemented
-   ; see https://github.com/Netflix/RxJava/commit/02ccc4d727a9297f14219549208757c6e0efce2a
-   (throw (UnsupportedOperationException. "groupBy with val-fn is currently unimplemented in RxJava"))
-   (->> (.groupBy xs
-                  (iop/fn* key-fn)
-                  (iop/fn* val-fn))
         (map (fn [^GroupedObservable go]
                (clojure.lang.MapEntry. (.getKey go) go))))))
 

From 6bc098de7871abb7a7dd041d6a90ff088d68cc44 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Fri, 21 Feb 2014 13:41:03 -0800
Subject: [PATCH 049/422] Implement iterate

---
 .../src/main/clojure/rx/lang/clojure/core.clj     | 15 ++++++++++++++-
 .../test/clojure/rx/lang/clojure/core_test.clj    |  8 ++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 7850d44501..39e8cd1be1 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -4,7 +4,7 @@
                             empty every?
                             filter first future
                             group-by
-                            interleave interpose into
+                            interleave interpose into iterate
                             keep keep-indexed
                             map mapcat map-indexed
                             merge next nth partition-all reduce reductions
@@ -550,6 +550,19 @@
   ; same thread, so we can't do that here.
   (reduce conj to from))
 
+(defn iterate
+  "Returns an Observable of x, (f x), (f (f x)) etc. f must be free of side-effects
+
+  See:
+    clojure.core/iterate
+  "
+  [f x]
+  (observable* (fn [s]
+                 (loop [x x]
+                   (when-not (unsubscribed? s)
+                     (on-next s x)
+                     (recur (f x)))))))
+
 (defn keep
   [f xs]
   (filter (complement nil?) (map f xs)))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index 9dc7a98a3e..ef4f7b458a 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -348,6 +348,14 @@
        {} []
        '() (range 50)))
 
+(deftest test-iterate
+  (are [f x n] (= (->> (iterate f x) (take n))
+                  (->> (rx/iterate f x) (rx/take n) (b/into [])))
+       inc 0 10
+       dec 20 100
+       #(conj % (count %)) [] 5
+       #(cons (count %) % ) nil 5))
+
 (deftest test-keep
   (is (= (into [] (keep identity [true true false]))
          (b/into [] (rx/keep identity (rx/seq->o [true true false])))))

From 7919c0451d4d3eb1dcec6055d1e5cd0105bc6fbe Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Fri, 21 Feb 2014 14:22:09 -0800
Subject: [PATCH 050/422] Implement range

---
 .../src/main/clojure/rx/lang/clojure/core.clj | 27 ++++++++++++++++++-
 .../clojure/rx/lang/clojure/core_test.clj     | 22 +++++++++++++++
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 39e8cd1be1..39a164e6e9 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -7,7 +7,8 @@
                             interleave interpose into iterate
                             keep keep-indexed
                             map mapcat map-indexed
-                            merge next nth partition-all reduce reductions
+                            merge next nth partition-all
+                            range reduce reductions
                             rest seq some sort sort-by split-with
                             take take-while throw])
   (:require [rx.lang.clojure.interop :as iop]
@@ -678,6 +679,30 @@
   ([n ^Observable xs] (.window xs (int n)))
   ([n step ^Observable xs] (.window xs (int n) (int step))))
 
+(defn range
+  "Returns an Observable nums from start (inclusive) to end
+  (exclusive), by step, where start defaults to 0, step to 1, and end
+  to infinity.
+
+  Note: this is not implemented on rx.Observable/range
+
+  See:
+    clojure.core/range
+  "
+  ([] (range 0 Double/POSITIVE_INFINITY 1))
+  ([end] (range 0 end 1))
+  ([start end] (range start end 1))
+  ([start end step]
+   (observable* (fn [s]
+                  (let [comp (if (pos? step) < >)]
+                    (loop [i start]
+                      (if-not (unsubscribed? s)
+                        (if (comp i end)
+                          (do
+                            (on-next s i)
+                            (recur (+ i step)))
+                          (on-completed s)))))))))
+
 (defn ^Observable reduce
   ([f ^Observable xs] (.reduce xs (iop/fn* f)))
   ([f val ^Observable xs] (.reduce xs val (iop/fn* f))))
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index ef4f7b458a..e645db653c 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -498,6 +498,28 @@
        10 3
        15 30))
 
+(deftest test-range
+  (are [start end step] (= (range start end step)
+                           (->> (rx/range start end step) (b/into [])))
+       0   10  2
+       0 -100 -1
+       5 100   9)
+
+  (are [start end] (= (range start end)
+                      (->> (rx/range start end) (b/into [])))
+       0   10
+       0 -100
+       5 100)
+
+  (are [start] (= (->> (range start) (take 100))
+                  (->> (rx/range start) (rx/take 100) (b/into [])))
+       50
+       0
+       5
+       -20)
+  (is (= (->> (range) (take 500))
+         (->> (rx/range) (rx/take 500) (b/into [])))))
+
 (deftest test-reduce
   (is (= (reduce + 0 (range 4))
          (b/first (rx/reduce + 0 (rx/seq->o (range 4)))))))

From d19bc4263165984e9354f01e119bbc6cfab84750 Mon Sep 17 00:00:00 2001
From: Dave Ray <daveray@gmail.com>
Date: Fri, 21 Feb 2014 16:54:07 -0800
Subject: [PATCH 051/422] seq->o should seq-ify arg

---
 .../rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj  | 4 ++--
 .../src/test/clojure/rx/lang/clojure/core_test.clj            | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index 39a164e6e9..d2768d1b37 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -285,8 +285,8 @@
 (defn ^Observable seq->o
   "Make an observable out of some seq-able thing. The rx equivalent of clojure.core/seq."
   [xs]
-  (if xs
-    (Observable/from ^Iterable xs)
+  (if-let [s (clojure.core/seq xs)]
+    (Observable/from ^Iterable s)
     (empty)))
 
 ;################################################################################
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index e645db653c..d77b184bd8 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -166,6 +166,7 @@
 (deftest test-seq->o
   (is (= [] (b/into [] (rx/seq->o []))))
   (is (= [] (b/into [] (rx/seq->o nil))))
+  (is (= [\a \b \c] (b/into [] (rx/seq->o "abc"))))
   (is (= [0 1 2 3] (b/first (rx/into [] (rx/seq->o (range 4))))))
   (is (= #{0 1 2 3} (b/first (rx/into #{} (rx/seq->o (range 4))))))
   (is (= {:a 1 :b 2 :c 3} (b/first (rx/into {} (rx/seq->o [[:a 1] [:b 2] [:c 3]]))))))

From fefd35ba85905ab978f07880ed96f3c59e270e6c Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Tue, 25 Feb 2014 08:03:13 +0000
Subject: [PATCH 052/422] [Gradle Release Plugin] - pre tag commit: 
 '0.17.0-RC5'.

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

diff --git a/gradle.properties b/gradle.properties
index 2f793be8d8..fc88554485 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC5-SNAPSHOT
+version=0.17.0-RC5

From 4a93b4aadcb9119104b231247e827d4703b14135 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Tue, 25 Feb 2014 08:03:17 +0000
Subject: [PATCH 053/422] [Gradle Release Plugin] - new version commit: 
 '0.17.0-RC6-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index fc88554485..b78e3f0dae 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC5
+version=0.17.0-RC6-SNAPSHOT

From 7cf40da0ac74c6f1f442c87e3e46fbda9eaac8b6 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Tue, 25 Feb 2014 23:06:48 +0200
Subject: [PATCH 054/422] Added BlockingObservable

---
 rxjava-contrib/rxjava-quasar/README.md        |   1 +
 .../java/rx/quasar/BlockingObservable.java    | 612 ++++++++++++++++++
 .../java/rx/quasar/ChannelObservable.java     |   2 +-
 .../rx/quasar/BlockingObservableTest.java     | 382 +++++++++++
 4 files changed, 996 insertions(+), 1 deletion(-)
 create mode 100644 rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
 create mode 100644 rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java

diff --git a/rxjava-contrib/rxjava-quasar/README.md b/rxjava-contrib/rxjava-quasar/README.md
index 5c67aaee2b..a89ab6eb9c 100644
--- a/rxjava-contrib/rxjava-quasar/README.md
+++ b/rxjava-contrib/rxjava-quasar/README.md
@@ -7,6 +7,7 @@ Main Classes:
 
 - [NewFiberScheduler](https://github.com/Netflix/RxJava/blob/master/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java)
 - [ChannelObservable](https://github.com/Netflix/RxJava/blob/master/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java)
+- [BlockingObservable](https://github.com/Netflix/RxJava/blob/master/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java)
 
 
 # Binaries
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
new file mode 100644
index 0000000000..a161e184d8
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
@@ -0,0 +1,612 @@
+/**
+ * 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.quasar;
+
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.fibers.Suspendable;
+import co.paralleluniverse.strands.AbstractFuture;
+import co.paralleluniverse.strands.ConditionSynchronizer;
+import co.paralleluniverse.strands.SimpleConditionSynchronizer;
+import co.paralleluniverse.strands.Strand;
+import co.paralleluniverse.strands.channels.Channels;
+import co.paralleluniverse.strands.channels.DelegatingReceivePort;
+import co.paralleluniverse.strands.channels.ProducerException;
+import co.paralleluniverse.strands.channels.ReceivePort;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.observers.SafeSubscriber;
+import rx.util.Exceptions;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+
+/**
+ * An extension of {@link Observable} that provides blocking operators, compatible with both threads and fibers.
+ * <p>
+ * You construct a <code>BlockingObservable</code> from an
+ * <code>Observable</code> with {@link #from(Observable)}.
+ * <p>
+ * 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:
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.legend.png">
+ * <p>
+ * For more information see the
+ * <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators">Blocking
+ * Observable Operators</a> page at the RxJava Wiki.
+ *
+ * @param <T>
+ */
+public class BlockingObservable<T> {
+    private static final int BUFFER_SIZE = 10;
+    private final Observable<? extends T> o;
+
+    private BlockingObservable(Observable<? extends T> o) {
+        this.o = o;
+    }
+
+    /**
+     * Convert an Observable into a BlockingObservable.
+     */
+    public static <T> BlockingObservable<T> from(final Observable<? extends T> o) {
+        return new BlockingObservable<T>(o);
+    }
+
+    /**
+     * Used for protecting against errors being thrown from {@link Subscriber} implementations and ensuring onNext/onError/onCompleted contract
+     * compliance.
+     * <p>
+     * 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(Subscriber<? super T> observer) {
+        return o.subscribe(new SafeSubscriber<T>(observer));
+    }
+
+    /**
+     * Invoke a method on each item emitted by the {@link Observable}; block
+     * until the Observable completes.
+     * <p>
+     * NOTE: This will block even if the Observable is asynchronous.
+     * <p>
+     * This is similar to {@link Observable#subscribe(Subscriber)}, but it blocks.
+     * Because it blocks it does not need the {@link Subscriber#onCompleted()} or {@link Subscriber#onError(Throwable)} methods.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.forEach.png">
+     *
+     * @param onNext
+     *               the {@link Action1} to invoke for every item emitted by the {@link Observable}
+     * @throws RuntimeException
+     *                          if an error occurs
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#foreach">RxJava Wiki: forEach()</a>
+     */
+    @Suspendable
+    public void forEach(final Action1<? super T> onNext) {
+        try {
+            final AtomicBoolean done = new AtomicBoolean(false);
+            final ConditionSynchronizer sync = new SimpleConditionSynchronizer(this);
+            final AtomicReference<Throwable> exceptionFromOnError = new AtomicReference<Throwable>();
+
+            /**
+             * 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"
+             */
+            protectivelyWrapAndSubscribe(new Subscriber<T>() {
+                @Override
+                public void onCompleted() {
+                    done.set(true);
+                    sync.signalAll();
+                }
+
+                @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().
+                     * 
+                     * We do this instead of throwing directly since this may be on
+                     * a different thread and the latch is still waiting.
+                     */
+                    exceptionFromOnError.set(e);
+                    done.set(true);
+                    sync.signalAll();
+                }
+
+                @Override
+                public void onNext(T args) {
+                    onNext.call(args);
+                }
+            });
+            // block until the subscription completes and then return
+            try {
+                final Object token = sync.register();
+                try {
+                    for (int i = 0; !done.get(); i++)
+                        sync.await(i);
+                } finally {
+                    sync.unregister(token);
+                }
+            } catch (InterruptedException e) {
+            // set the interrupted flag again so callers can still get it
+                // for more information see https://github.com/Netflix/RxJava/pull/147#issuecomment-13624780
+                Strand.currentStrand().interrupt();
+                // using Runtime so it is not checked
+                throw new RuntimeException("Interrupted while waiting for subscription to complete.", e);
+            }
+
+            if (exceptionFromOnError.get() != null) {
+                if (exceptionFromOnError.get() instanceof RuntimeException) {
+                    throw (RuntimeException) exceptionFromOnError.get();
+                } else {
+                    throw new RuntimeException(exceptionFromOnError.get());
+                }
+            }
+        } catch (SuspendExecution e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * Returns an {@link ReceivePort} that receives all items emitted by a
+     * specified {@link Observable}.
+     *
+     * @return an {@link ReceivePort} that receives all items emitted by a
+     *         specified {@link Observable}.
+     */
+    public ReceivePort<T> toChannel() {
+        return ChannelObservable.subscribe(BUFFER_SIZE, Channels.OverflowPolicy.BLOCK, o);
+    }
+
+    /**
+     * Returns the first item emitted by a specified {@link Observable}, or
+     * <code>IllegalArgumentException</code> if source contains no elements.
+     *
+     * @return the first item emitted by the source {@link Observable}
+     * @throws IllegalArgumentException
+     *                                  if source contains no elements
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229177.aspx">MSDN: Observable.First</a>
+     */
+    @Suspendable
+    public T first() {
+        return from(o.first()).single();
+    }
+
+    /**
+     * Returns the first item emitted by a specified {@link Observable} that
+     * matches a predicate, or <code>IllegalArgumentException</code> 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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229739.aspx">MSDN: Observable.First</a>
+     */
+    @Suspendable
+    public T first(Func1<? super T, Boolean> 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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: firstOrDefault()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229320.aspx">MSDN: Observable.FirstOrDefault</a>
+     */
+    @Suspendable
+    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.
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: firstOrDefault()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229759.aspx">MSDN: Observable.FirstOrDefault</a>
+     */
+    @Suspendable
+    public T firstOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
+        return from(o.filter(predicate)).firstOrDefault(defaultValue);
+    }
+
+    /**
+     * Returns the last item emitted by a specified {@link Observable}, or
+     * throws <code>IllegalArgumentException</code> if it emits no items.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.last.png">
+     *
+     * @return the last item emitted by the source {@link Observable}
+     * @throws IllegalArgumentException
+     *                                  if source contains no elements
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: last()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.last.aspx">MSDN: Observable.Last</a>
+     */
+    @Suspendable
+    public T last() {
+        return from(o.last()).single();
+    }
+
+    /**
+     * Returns the last item emitted by a specified {@link Observable} that
+     * matches a predicate, or throws <code>IllegalArgumentException</code> if
+     * it emits no such items.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.last.p.png">
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: last()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.last.aspx">MSDN: Observable.Last</a>
+     */
+    @Suspendable
+    public T last(final Func1<? super T, Boolean> 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.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.lastOrDefault.png">
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: lastOrDefault()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.lastordefault.aspx">MSDN: Observable.LastOrDefault</a>
+     */
+    @Suspendable
+    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.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.lastOrDefault.p.png">
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: lastOrDefault()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.lastordefault.aspx">MSDN: Observable.LastOrDefault</a>
+     */
+    @Suspendable
+    public T lastOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
+        return from(o.filter(predicate)).lastOrDefault(defaultValue);
+    }
+
+    /**
+     * Returns an {@link Iterable} that always returns the item most recently
+     * emitted by an {@link Observable}.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.mostRecent.png">
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#mostrecent">RxJava wiki: mostRecent()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229751.aspx">MSDN: Observable.MostRecent</a>
+     */
+    public ReceivePort<T> mostRecent(T initialValue) {
+        return new RecentReceivePort<T>(ChannelObservable.subscribe(1, Channels.OverflowPolicy.DISPLACE, o), initialValue);
+    }
+
+    /**
+     * Returns an {@link Iterable} that blocks until the {@link Observable} emits another item, then returns that item.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.next.png">
+     *
+     * @return an {@link Iterable} that blocks upon each iteration until the {@link Observable} emits a new item, whereupon the Iterable returns that item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#next">RxJava Wiki: next()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211897.aspx">MSDN: Observable.Next</a>
+     */
+    public ReceivePort<T> next() {
+        return ChannelObservable.subscribe(1, Channels.OverflowPolicy.DISPLACE, o);
+    }
+
+    /**
+     * Returns the latest item emitted by the underlying Observable, waiting if
+     * necessary for one to become available.
+     * <p>
+     * If the underlying Observable produces items faster than the
+     * <code>Iterator.next()</code> takes them, <code>onNext</code> events might
+     * be skipped, but <code>onError</code> or <code>onCompleted</code> events
+     * are not.
+     * <p>
+     * Note also that an <code>onNext()</code> directly followed by
+     * <code>onCompleted()</code> might hide the <code>onNext()</code> event.
+     *
+     * @return the receive port
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#latest">RxJava wiki: latest()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212115.aspx">MSDN: Observable.Latest</a>
+     */
+    public ReceivePort<T> latest() {
+        return new LatestReceivePort<T>(ChannelObservable.subscribe(1, Channels.OverflowPolicy.DISPLACE, o));
+    }
+
+    /**
+     * If the {@link Observable} completes after emitting a single item, return
+     * that item, otherwise throw an <code>IllegalArgumentException</code>.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.single.png">
+     *
+     * @return the single item emitted by the {@link Observable}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#single-and-singleordefault">RxJava Wiki: single()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.single.aspx">MSDN: Observable.Single</a>
+     */
+    @Suspendable
+    public T single() {
+        try {
+            return from(o.single()).toChannel().receive();
+        } catch (ProducerException e) {
+            throw Exceptions.propagate(e.getCause());
+        } catch (InterruptedException e) {
+            Strand.currentStrand().interrupt();
+            throw Exceptions.propagate(e);
+        } catch (SuspendExecution e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * If the {@link Observable} completes after emitting a single item that
+     * matches a given predicate, return that item, otherwise throw an
+     * <code>IllegalArgumentException</code>.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.single.p.png">
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#single-and-singleordefault">RxJava Wiki: single()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.single.aspx">MSDN: Observable.Single</a>
+     */
+    @Suspendable
+    public T single(Func1<? super T, Boolean> predicate) {
+        try {
+            return from(o.single(predicate)).toChannel().receive();
+        } catch (ProducerException e) {
+            throw Exceptions.propagate(e.getCause());
+        } catch (InterruptedException e) {
+            Strand.currentStrand().interrupt();
+            throw Exceptions.propagate(e);
+        } catch (SuspendExecution e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * If the {@link Observable} completes after emitting a single item, return
+     * that item; if it emits more than one item, throw an
+     * <code>IllegalArgumentException</code>; if it emits no items, return a
+     * default value.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.singleOrDefault.png">
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#single-and-singleordefault">RxJava Wiki: singleOrDefault()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.singleordefault.aspx">MSDN: Observable.SingleOrDefault</a>
+     */
+    @Suspendable
+    public T singleOrDefault(T defaultValue) {
+        try {
+            ReceivePort<? extends T> c = this.toChannel();
+
+            T result = c.receive();
+            if (result == null)
+                return defaultValue;
+            if (c.receive() != null) {
+                throw new IllegalArgumentException("Sequence contains too many elements");
+            }
+            return result;
+        } catch (ProducerException e) {
+            throw Exceptions.propagate(e.getCause());
+        } catch (InterruptedException e) {
+            Strand.currentStrand().interrupt();
+            throw Exceptions.propagate(e);
+        } catch (SuspendExecution e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * 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 <code>IllegalArgumentException</code>; if it emits no
+     * items, return a default value.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.singleOrDefault.p.png">
+     *
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#single-and-singleordefault">RxJava Wiki: singleOrDefault()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.singleordefault.aspx">MSDN: Observable.SingleOrDefault</a>
+     */
+    @Suspendable
+    public T singleOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
+        return from(o.filter(predicate)).singleOrDefault(defaultValue);
+    }
+
+    /**
+     * Returns a {@link Future} representing the single value emitted by an {@link Observable}.
+     * <p>
+     * <code>toFuture()</code> 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()</code>.
+     * <p>
+     * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.toFuture.png">
+     *
+     * @return a {@link Future} that expects a single item to be emitted by the source {@link Observable}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#transformations-tofuture-toiterable-and-toiteratorgetiterator">RxJava Wiki: toFuture()</a>
+     */
+    public Future<T> toFuture() {
+        return new AbstractFuture<T>() {
+            final AtomicReference<T> val = new AtomicReference<T>();
+
+            {
+                o.subscribe(new Observer<T>() {
+                    @Override
+                    public void onCompleted() {
+                        set(val.get());
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        setException(e);
+                    }
+
+                    @Override
+                    public void onNext(T t) {
+                        if (!val.compareAndSet(null, t))
+                            setException(new IllegalStateException("Observable.toFuture() only supports sequences with a single value."));
+                    }
+                });
+            }
+        };
+    }
+
+    private static class RecentReceivePort<V> extends DelegatingReceivePort<V> {
+        private V value;
+
+        public RecentReceivePort(ReceivePort<V> target, V initialValue) {
+            super(target);
+            this.value = initialValue;
+        }
+
+        @Override
+        public V receive(long timeout, TimeUnit unit) {
+            return getValue();
+        }
+
+        @Override
+        public V receive() {
+            return getValue();
+        }
+
+        @Override
+        public V tryReceive() {
+            return getValue();
+        }
+
+        private V getValue() {
+            V v = super.tryReceive();
+            if (v == null) {
+                if (isClosed())
+                    return null;
+                return value;
+            }
+            this.value = v;
+            return v;
+        }
+    }
+
+    private static class LatestReceivePort<V> extends DelegatingReceivePort<V> {
+        private V value;
+
+        public LatestReceivePort(ReceivePort<V> target) {
+            super(target);
+            this.value = null;
+        }
+
+        @Override
+        public V receive() throws SuspendExecution, InterruptedException {
+            V v = getValue();
+            if (v == null && !isClosed()) {
+                this.value = super.receive();
+                return value;
+            }
+            return v;
+        }
+
+        @Override
+        public V receive(long timeout, TimeUnit unit) throws SuspendExecution, InterruptedException {
+            V v = getValue();
+            if (v == null && !isClosed()) {
+                this.value = super.receive(timeout, unit);
+                return value;
+            }
+            return v;
+        }
+
+        @Override
+        public V tryReceive() {
+            return getValue();
+        }
+
+        @Override
+        public boolean isClosed() {
+            return super.isClosed() && value == null;
+        }
+
+        private V getValue() {
+            V v = tryReceive();
+            if (v == null) {
+                v = value;
+                if (isClosed()) {
+                    this.value = null;
+                    return null;
+                }
+                return v;
+            }
+            this.value = v;
+            return v;
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index 97e9af950b..a4cd824f9d 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -119,7 +119,7 @@ public void onError(Throwable e) {
      * @param o          the observable
      * @return A new channel with the given buffer size and overflow policy that will receive all events emitted by the observable.
      */
-    public static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<T> o) {
+    public static <T> ReceivePort<T> subscribe(int bufferSize, Channels.OverflowPolicy policy, Observable<? extends T> o) {
         final Channel<T> channel = Channels.newChannel(bufferSize, policy);
 
         o.subscribe(new Observer<T>() {
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
new file mode 100644
index 0000000000..5c0afc9c31
--- /dev/null
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
@@ -0,0 +1,382 @@
+/**
+ * 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.quasar;
+
+import co.paralleluniverse.strands.channels.ProducerException;
+import co.paralleluniverse.strands.channels.ReceivePort;
+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;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.Subscriptions;
+import rx.util.functions.Action1;
+import rx.util.functions.Func1;
+
+public class BlockingObservableTest {
+
+    @Mock
+    Subscriber<Integer> w;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testLast() {
+        BlockingObservable<String> obs = BlockingObservable.from(Observable.from("one", "two", "three"));
+
+        assertEquals("three", obs.last());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testLastEmptyObservable() {
+        BlockingObservable<Object> obs = BlockingObservable.from(Observable.empty());
+        obs.last();
+    }
+
+    @Test
+    public void testLastOrDefault() {
+        BlockingObservable<Integer> observable = BlockingObservable.from(Observable.from(1, 0, -1));
+        int last = observable.lastOrDefault(-100, new Func1<Integer, Boolean>() {
+            @Override
+            public Boolean call(Integer args) {
+                return args >= 0;
+            }
+        });
+        assertEquals(0, last);
+    }
+
+    @Test
+    public void testLastOrDefault1() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        assertEquals("three", observable.lastOrDefault("default"));
+    }
+
+    @Test
+    public void testLastOrDefault2() {
+        BlockingObservable<Object> observable = BlockingObservable.from(Observable.empty());
+        assertEquals("default", observable.lastOrDefault("default"));
+    }
+
+    @Test
+    public void testLastOrDefaultWithPredicate() {
+        BlockingObservable<Integer> observable = BlockingObservable.from(Observable.from(1, 0, -1));
+        int last = observable.lastOrDefault(0, new Func1<Integer, Boolean>() {
+            @Override
+            public Boolean call(Integer args) {
+                return args < 0;
+            }
+        });
+
+        assertEquals(-1, last);
+    }
+
+    @Test
+    public void testLastOrDefaultWrongPredicate() {
+        BlockingObservable<Integer> observable = BlockingObservable.from(Observable.from(-1, -2, -3));
+        int last = observable.lastOrDefault(0, new Func1<Integer, Boolean>() {
+            @Override
+            public Boolean call(Integer args) {
+                return args >= 0;
+            }
+        });
+        assertEquals(0, last);
+    }
+
+    @Test
+    public void testLastWithPredicate() {
+        BlockingObservable<String> obs = BlockingObservable.from(Observable.from("one", "two", "three"));
+
+        assertEquals("two", obs.last(new Func1<String, Boolean>() {
+            @Override
+            public Boolean call(String s) {
+                return s.length() == 3;
+            }
+        }));
+    }
+
+    public void testSingle() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one"));
+        assertEquals("one", observable.single());
+    }
+
+    @Test
+    public void testSingleDefault() {
+        BlockingObservable<Object> observable = BlockingObservable.from(Observable.empty());
+        assertEquals("default", observable.singleOrDefault("default"));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testSingleDefaultPredicateMatchesMoreThanOne() {
+        BlockingObservable.from(Observable.from("one", "two")).singleOrDefault("default", new Func1<String, Boolean>() {
+            @Override
+            public Boolean call(String args) {
+                return args.length() == 3;
+            }
+        });
+    }
+
+    @Test
+    public void testSingleDefaultPredicateMatchesNothing() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two"));
+        String result = observable.singleOrDefault("default", new Func1<String, Boolean>() {
+            @Override
+            public Boolean call(String args) {
+                return args.length() == 4;
+            }
+        });
+        assertEquals("default", result);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testSingleDefaultWithMoreThanOne() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        observable.singleOrDefault("default");
+    }
+
+    @Test
+    public void testSingleWithPredicateDefault() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "four"));
+        assertEquals("four", observable.single(new Func1<String, Boolean>() {
+            @Override
+            public Boolean call(String s) {
+                return s.length() == 4;
+            }
+        }));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testSingleWrong() {
+        BlockingObservable<Integer> observable = BlockingObservable.from(Observable.from(1, 2));
+        observable.single();
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testSingleWrongPredicate() {
+        BlockingObservable<Integer> observable = BlockingObservable.from(Observable.from(-1));
+        observable.single(new Func1<Integer, Boolean>() {
+            @Override
+            public Boolean call(Integer args) {
+                return args > 0;
+            }
+        });
+    }
+
+    @Test
+    public void testToChannel() throws Exception {
+        BlockingObservable<String> obs = BlockingObservable.from(Observable.from("one", "two", "three"));
+
+        ReceivePort<String> c = obs.toChannel();
+
+        assertEquals(false, c.isClosed());
+        assertEquals("one", c.receive());
+
+        assertEquals(false, c.isClosed());
+        assertEquals("two", c.receive());
+
+        assertEquals(false, c.isClosed());
+        assertEquals("three", c.receive());
+
+        assertEquals(true, c.isClosed());
+
+    }
+
+    public void testToChannelNextOnly() throws Exception {
+        BlockingObservable<Integer> obs = BlockingObservable.from(Observable.from(1, 2, 3));
+
+        ReceivePort<Integer> c = obs.toChannel();
+
+        Assert.assertEquals((Integer) 1, c.receive());
+        Assert.assertEquals((Integer) 2, c.receive());
+        Assert.assertEquals((Integer) 3, c.receive());
+
+        Assert.assertEquals(c.receive(), null);
+    }
+
+    public void testToChannelNextOnlyTwice() throws Exception {
+        BlockingObservable<Integer> obs = BlockingObservable.from(Observable.from(1, 2, 3));
+
+        ReceivePort<Integer> c = obs.toChannel();
+
+        Assert.assertEquals((Integer) 1, c.receive());
+        Assert.assertEquals((Integer) 2, c.receive());
+        Assert.assertEquals((Integer) 3, c.receive());
+
+        Assert.assertEquals(c.receive(), null);
+        Assert.assertEquals(c.receive(), null);
+    }
+
+    @Test
+    public void testToChannelManyTimes() throws Exception {
+        BlockingObservable<Integer> obs = BlockingObservable.from(Observable.from(1, 2, 3));
+
+        for (int j = 0; j < 3; j++) {
+            ReceivePort<Integer> c = obs.toChannel();
+
+            Assert.assertFalse(c.isClosed());
+            Assert.assertEquals((Integer) 1, c.receive());
+            Assert.assertFalse(c.isClosed());
+            Assert.assertEquals((Integer) 2, c.receive());
+            Assert.assertFalse(c.isClosed());
+            Assert.assertEquals((Integer) 3, c.receive());
+            Assert.assertTrue(c.isClosed());
+        }
+    }
+
+    @Test(expected = TestException.class)
+    public void testToChannelWithException() throws Throwable {
+        BlockingObservable<String> obs = BlockingObservable.from(Observable.create(new Observable.OnSubscribeFunc<String>() {
+
+            @Override
+            public Subscription onSubscribe(Observer<? super String> observer) {
+                observer.onNext("one");
+                observer.onError(new TestException());
+                return Subscriptions.empty();
+            }
+        }));
+
+        ReceivePort<String> c = obs.toChannel();
+
+        assertEquals(false, c.isClosed());
+        assertEquals("one", c.receive());
+
+        try {
+            c.receive();
+        } catch (ProducerException e) {
+            throw e.getCause();
+        }
+    }
+
+    @Test
+    public void testForEachWithError() {
+        try {
+            BlockingObservable.from(Observable.create(new Observable.OnSubscribeFunc<String>() {
+
+                @Override
+                public Subscription onSubscribe(final Observer<? super String> observer) {
+                    final BooleanSubscription subscription = new BooleanSubscription();
+                    new Thread(new Runnable() {
+
+                        @Override
+                        public void run() {
+                            observer.onNext("one");
+                            observer.onNext("two");
+                            observer.onNext("three");
+                            observer.onCompleted();
+                        }
+                    }).start();
+                    return subscription;
+                }
+            })).forEach(new Action1<String>() {
+
+                @Override
+                public void call(String t1) {
+                    throw new RuntimeException("fail");
+                }
+            });
+            fail("we expect an exception to be thrown");
+        } catch (Throwable e) {
+            // do nothing as we expect this
+        }
+    }
+
+    @Test
+    public void testFirst() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        assertEquals("one", observable.first());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testFirstWithEmpty() {
+        BlockingObservable.from(Observable.<String>empty()).first();
+    }
+
+    @Test
+    public void testFirstWithPredicate() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        String first = observable.first(new Func1<String, Boolean>() {
+            @Override
+            public Boolean call(String args) {
+                return args.length() > 3;
+            }
+        });
+        assertEquals("three", first);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testFirstWithPredicateAndEmpty() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        observable.first(new Func1<String, Boolean>() {
+            @Override
+            public Boolean call(String args) {
+                return args.length() > 5;
+            }
+        });
+    }
+
+    @Test
+    public void testFirstOrDefault() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        assertEquals("one", observable.firstOrDefault("default"));
+    }
+
+    @Test
+    public void testFirstOrDefaultWithEmpty() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.<String>empty());
+        assertEquals("default", observable.firstOrDefault("default"));
+    }
+
+    @Test
+    public void testFirstOrDefaultWithPredicate() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        String first = observable.firstOrDefault("default", new Func1<String, Boolean>() {
+            @Override
+            public Boolean call(String args) {
+                return args.length() > 3;
+            }
+        });
+        assertEquals("three", first);
+    }
+
+    @Test
+    public void testFirstOrDefaultWithPredicateAndEmpty() {
+        BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
+        String first = observable.firstOrDefault("default", new Func1<String, Boolean>() {
+            @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 bdfd9fe1191ca9620c365e830b16ca3ad7414c6f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 25 Feb 2014 14:11:29 -0800
Subject: [PATCH 055/422] TestSubscriber: Default onError and Terminal Latch
 Behavior

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

diff --git a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
index 50bfabf059..97966b8ebd 100644
--- a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
@@ -41,13 +41,33 @@ public TestSubscriber(Observer<T> delegate) {
     }
 
     public TestSubscriber() {
-        this.testObserver = new TestObserver<T>(Subscribers.<T> empty());
+        this.testObserver = new TestObserver<T>(new Observer<T>() {
+
+            @Override
+            public void onCompleted() {
+                // do nothing
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                // do nothing
+            }
+
+            @Override
+            public void onNext(T t) {
+                // do nothing
+            }
+
+        });
     }
 
     @Override
     public void onCompleted() {
-        testObserver.onCompleted();
-        latch.countDown();
+        try {
+            testObserver.onCompleted();
+        } finally {
+            latch.countDown();
+        }
     }
 
     public List<Notification<T>> getOnCompletedEvents() {
@@ -56,8 +76,11 @@ public List<Notification<T>> getOnCompletedEvents() {
 
     @Override
     public void onError(Throwable e) {
-        testObserver.onError(e);
-        latch.countDown();
+        try {
+            testObserver.onError(e);
+        } finally {
+            latch.countDown();
+        }
     }
 
     public List<Throwable> getOnErrorEvents() {

From a0c80095d5781c3566e4c61ace730e5f634088eb Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 25 Feb 2014 14:51:32 -0800
Subject: [PATCH 056/422] TestSubscriber lastSeenThread

---
 rxjava-core/src/main/java/rx/observers/TestSubscriber.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
index 97966b8ebd..dd1f2b8a7e 100644
--- a/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/TestSubscriber.java
@@ -64,6 +64,7 @@ public void onNext(T t) {
     @Override
     public void onCompleted() {
         try {
+            lastSeenThread = Thread.currentThread();
             testObserver.onCompleted();
         } finally {
             latch.countDown();
@@ -77,6 +78,7 @@ public List<Notification<T>> getOnCompletedEvents() {
     @Override
     public void onError(Throwable e) {
         try {
+            lastSeenThread = Thread.currentThread();
             testObserver.onError(e);
         } finally {
             latch.countDown();

From 9b63de2f4366172084b93386956cb19c04f09301 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Tue, 25 Feb 2014 23:17:13 +0000
Subject: [PATCH 057/422] [Gradle Release Plugin] - pre tag commit: 
 '0.17.0-RC6'.

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

diff --git a/gradle.properties b/gradle.properties
index b78e3f0dae..a8d27ebf4d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC6-SNAPSHOT
+version=0.17.0-RC6

From cbbf5144e12966d4a58a64ae61726e9ad8fa9d80 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Tue, 25 Feb 2014 23:17:17 +0000
Subject: [PATCH 058/422] [Gradle Release Plugin] - new version commit: 
 '0.17.0-RC7-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index a8d27ebf4d..f84383b779 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC6
+version=0.17.0-RC7-SNAPSHOT

From c32209bff1fb346ddd70f8905843e58e1f07e56f Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 26 Feb 2014 08:30:50 +0100
Subject: [PATCH 059/422] Fix deadlock in SubscribeOnBounded

---
 .../rx/operators/OperatorSubscribeOnBounded.java  |  3 +--
 .../operators/OperatorSubscribeOnBoundedTest.java | 15 ++++++++++++++-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
index 969f0df8b9..f5a459ef5d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
@@ -88,14 +88,13 @@ public void onNext(final Observable<T> o) {
                 if (checkNeedBuffer(o)) {
                     // use buffering (possibly blocking) for a possibly synchronous subscribe
                     final BufferUntilSubscriber<T> bus = new BufferUntilSubscriber<T>(bufferSize, subscriber);
-                    o.subscribe(bus);
                     subscriber.add(scheduler.schedule(new Action1<Inner>() {
                         @Override
                         public void call(final Inner inner) {
                             bus.enterPassthroughMode();
                         }
                     }));
-                    return;
+                    o.subscribe(bus);
                 } else {
                     // no buffering (async subscribe)
                     subscriber.add(scheduler.schedule(new Action1<Inner>() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
index 9b55256055..7a38bcd8da 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
@@ -399,5 +399,18 @@ public void call(Subscriber<? super Integer> sub) {
         ts.assertReceivedOnNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
         assertEquals(10, count.get());
     }
-
+    @Test(timeout = 2000)
+    public void testNoDeadlock() {
+        List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
+        Observable<Integer> source = Observable.from(data);
+        
+        Observable<Integer> result = source.nest().lift(new OperatorSubscribeOnBounded<Integer>(Schedulers.newThread(), 1));
+        
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+        
+        result.subscribe(ts);
+        
+        ts.awaitTerminalEvent();
+        ts.assertReceivedOnNext(data);
+    }
 }

From 9e4e180290b5c1d9093ead591701caf1c919cde7 Mon Sep 17 00:00:00 2001
From: Volker Leck <volker.leck@gmail.com>
Date: Wed, 26 Feb 2014 17:19:42 +0100
Subject: [PATCH 060/422] correct link to maven search

---
 rxjava-contrib/rxjava-android/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-android/README.md b/rxjava-contrib/rxjava-android/README.md
index 7a9e9edc20..8b7309b641 100644
--- a/rxjava-contrib/rxjava-android/README.md
+++ b/rxjava-contrib/rxjava-android/README.md
@@ -13,7 +13,7 @@ Android applications easy and hassle free. More specifically, it
 
 # Binaries
 
-Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22hystrix-servo-metrics-publisher%22).
+Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-android%22).
 
 Example for [Maven](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-android%22):
 

From c298d5efb1a3b2d84183330358dded3cfcacfa38 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 26 Feb 2014 17:41:23 +0100
Subject: [PATCH 061/422] A number of improvements to
 OperatorObserveFromAndroidComponent

- move the UI thread assert out of the operator and into the helpers; this way, we don't fail the observer anymore with an exception, but the caller.
- do not loop unsubscribe through the main thread anymore. This unnecessarily defers releasing the references, and might in fact be processed only after Android creates the component after a rotation change. I had to make the references volatile for this to work.
- immediately unsubscribe in case we detect the componentRef has become invalid. This solves the problem that dangling observers would continue to listen to notifications with no observer alive anymore.

refs:
https://github.com/Netflix/RxJava/issues/754
https://github.com/Netflix/RxJava/issues/899
---
 .../observables/AndroidObservable.java        |  2 +
 .../rx/android/observables/Assertions.java    | 11 +++++
 .../android/observables/ViewObservable.java   | 13 ++----
 .../OperatorCompoundButtonInput.java          |  4 +-
 .../rx/operators/OperatorEditTextInput.java   |  4 +-
 .../OperatorObserveFromAndroidComponent.java  | 28 ++++++-------
 .../java/rx/operators/OperatorViewClick.java  |  4 +-
 .../observables/AndroidObservableTest.java    | 42 ++++++++++++++++++-
 ...eratorObserveFromAndroidComponentTest.java | 16 -------
 9 files changed, 75 insertions(+), 49 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.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 d55617ddea..a0236bfbd5 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
@@ -59,6 +59,7 @@ private AndroidObservable() {}
      * @return a new observable sequence that will emit notifications on the main UI thread
      */
     public static <T> Observable<T> fromActivity(Activity activity, Observable<T> sourceObservable) {
+        Assertions.assertUiThread();
         return OperatorObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, activity);
     }
 
@@ -87,6 +88,7 @@ public static <T> Observable<T> fromActivity(Activity activity, Observable<T> so
      * @return a new observable sequence that will emit notifications on the main UI thread
      */
     public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sourceObservable) {
+        Assertions.assertUiThread();
         if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
             return OperatorObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (android.support.v4.app.Fragment) fragment);
         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && fragment instanceof Fragment) {
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.java
new file mode 100644
index 0000000000..58ed484ef5
--- /dev/null
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.java
@@ -0,0 +1,11 @@
+package rx.android.observables;
+
+import android.os.Looper;
+
+public class Assertions {
+    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/android/observables/ViewObservable.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/ViewObservable.java
index 6e31af051e..205f25c944 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,15 +15,15 @@
  */
 package rx.android.observables;
 
-import android.os.Looper;
-import android.view.View;
-import android.widget.CompoundButton;
-import android.widget.EditText;
 import rx.Observable;
 import rx.operators.OperatorCompoundButtonInput;
 import rx.operators.OperatorEditTextInput;
 import rx.operators.OperatorViewClick;
 
+import android.view.View;
+import android.widget.CompoundButton;
+import android.widget.EditText;
+
 public class ViewObservable {
 
     public static Observable<View> clicks(final View view, final boolean emitInitialValue) {
@@ -38,10 +38,5 @@ public static Observable<Boolean> 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/OperatorCompoundButtonInput.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorCompoundButtonInput.java
index 9a61093699..f9973d5f54 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,7 +23,7 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.android.observables.ViewObservable;
+import rx.android.observables.Assertions;
 import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
 import android.view.View;
@@ -40,7 +40,7 @@ public OperatorCompoundButtonInput(final CompoundButton button, final boolean em
 
     @Override
     public void call(final Subscriber<? super Boolean> observer) {
-        ViewObservable.assertUiThread();
+        Assertions.assertUiThread();
         final CompositeOnCheckedChangeListener composite = CachedListeners.getFromViewOrCreate(button);
 
         final CompoundButton.OnCheckedChangeListener listener = new CompoundButton.OnCheckedChangeListener() {
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 1dcbac0014..563d80bf24 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,7 +18,7 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.android.observables.ViewObservable;
+import rx.android.observables.Assertions;
 import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
 import android.text.Editable;
@@ -36,7 +36,7 @@ public OperatorEditTextInput(final EditText input, final boolean emitInitialValu
 
     @Override
     public void call(final Subscriber<? super String> observer) {
-        ViewObservable.assertUiThread();
+        Assertions.assertUiThread();
         final TextWatcher watcher = new SimpleTextWatcher() {
             @Override
             public void afterTextChanged(final Editable editable) {
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
index 3e656ccfbb..0ad16b4cc2 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
@@ -19,10 +19,10 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.android.schedulers.AndroidSchedulers;
-import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
+import rx.subscriptions.Subscriptions;
+
 import android.app.Activity;
-import android.os.Looper;
 import android.util.Log;
 
 public class OperatorObserveFromAndroidComponent {
@@ -44,8 +44,8 @@ private static class OnSubscribeBase<T, AndroidComponent> implements Observable.
         private static final String LOG_TAG = "AndroidObserver";
 
         private final Observable<T> source;
-        private AndroidComponent componentRef;
-        private Observer<? super T> observerRef;
+        private volatile AndroidComponent componentRef;
+        private volatile Observer<? super T> observerRef;
 
         private OnSubscribeBase(Observable<T> source, AndroidComponent component) {
             this.source = source;
@@ -54,9 +54,9 @@ private OnSubscribeBase(Observable<T> source, AndroidComponent component) {
 
         private void log(String message) {
             if (Log.isLoggable(LOG_TAG, Log.DEBUG)) {
-                Log.d(LOG_TAG, "componentRef = " + componentRef);
-                Log.d(LOG_TAG, "observerRef = " + observerRef);
-                Log.d(LOG_TAG, message);
+                String thread = Thread.currentThread().getName();
+                Log.d(LOG_TAG, "[" + thread + "] componentRef = " + componentRef + "; observerRef = " + observerRef);
+                Log.d(LOG_TAG, "[" + thread + "]" + message);
             }
         }
 
@@ -65,8 +65,7 @@ protected boolean isComponentValid(AndroidComponent component) {
         }
 
         @Override
-        public void call(Subscriber<? super T> subscriber) {
-            assertUiThread();
+        public void call(final Subscriber<? super T> subscriber) {
             observerRef = subscriber;
             source.observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber<T>(subscriber) {
                 @Override
@@ -74,6 +73,7 @@ public void onCompleted() {
                     if (componentRef != null && isComponentValid(componentRef)) {
                         observerRef.onCompleted();
                     } else {
+                        unsubscribe();
                         log("onComplete: target component released or detached; dropping message");
                     }
                 }
@@ -83,6 +83,7 @@ public void onError(Throwable e) {
                     if (componentRef != null && isComponentValid(componentRef)) {
                         observerRef.onError(e);
                     } else {
+                        unsubscribe();
                         log("onError: target component released or detached; dropping message");
                     }
                 }
@@ -92,11 +93,12 @@ public void onNext(T args) {
                     if (componentRef != null && isComponentValid(componentRef)) {
                         observerRef.onNext(args);
                     } else {
+                        unsubscribe();
                         log("onNext: target component released or detached; dropping message");
                     }
                 }
             });
-            subscriber.add(AndroidSubscriptions.unsubscribeInUiThread(new Action0() {
+            subscriber.add(Subscriptions.create(new Action0() {
                 @Override
                 public void call() {
                     log("unsubscribing from source sequence");
@@ -109,12 +111,6 @@ private void releaseReferences() {
             observerRef = null;
             componentRef = null;
         }
-
-        private void assertUiThread() {
-            if (Looper.getMainLooper() != Looper.myLooper()) {
-                throw new IllegalStateException("Observers must subscribe from the main UI thread, but was " + Thread.currentThread());
-            }
-        }
     }
 
     private static final class OnSubscribeFragment<T> extends OnSubscribeBase<T, android.app.Fragment> {
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 1fb2bb8b91..7ee7149b72 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
@@ -23,7 +23,7 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.android.observables.ViewObservable;
+import rx.android.observables.Assertions;
 import rx.android.subscriptions.AndroidSubscriptions;
 import rx.functions.Action0;
 import android.view.View;
@@ -39,7 +39,7 @@ public OperatorViewClick(final View view, final boolean emitInitialValue) {
 
     @Override
     public void call(final Subscriber<? super View> observer) {
-        ViewObservable.assertUiThread();
+        Assertions.assertUiThread();
         final CompositeOnClickListener composite = CachedListeners.getFromViewOrCreate(view);
 
         final View.OnClickListener listener = new View.OnClickListener() {
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
index a5006bdf91..0591c6454e 100644
--- 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
@@ -15,7 +15,7 @@
  */
 package rx.android.observables;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -25,14 +25,20 @@
 import org.robolectric.Robolectric;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
-
 import rx.Observable;
 import rx.Observer;
 import rx.observers.TestObserver;
+
 import android.app.Activity;
 import android.app.Fragment;
 import android.support.v4.app.FragmentActivity;
 
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
 
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
@@ -79,4 +85,36 @@ public void itSupportsNativeFragments() {
     public void itThrowsIfObjectPassedIsNotAFragment() {
         AndroidObservable.fromFragment("not a fragment", Observable.never());
     }
+
+    @Test(expected = IllegalStateException.class)
+    public void itThrowsIfObserverCallsFromFragmentFromBackgroundThread() throws Throwable {
+        final Future<Object> future = Executors.newSingleThreadExecutor().submit(new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                AndroidObservable.fromFragment(fragment, Observable.empty());
+                return null;
+            }
+        });
+        try {
+            future.get(1, TimeUnit.SECONDS);
+        } catch (ExecutionException e) {
+            throw e.getCause();
+        }
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void itThrowsIfObserverCallsFromActivityFromBackgroundThread() throws Throwable {
+        final Future<Object> future = Executors.newSingleThreadExecutor().submit(new Callable<Object>() {
+            @Override
+            public Object call() throws Exception {
+                AndroidObservable.fromActivity(activity, Observable.empty());
+                return null;
+            }
+        });
+        try {
+            future.get(1, TimeUnit.SECONDS);
+        } catch (ExecutionException e) {
+            throw e.getCause();
+        }
+    }
 }
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
index 70a9c881fb..443901a1f7 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
@@ -70,22 +70,6 @@ public void setupMocks() {
         when(mockFragment.isAdded()).thenReturn(true);
     }
 
-    @Test
-    public void itThrowsIfObserverSubscribesFromBackgroundThread() throws Exception {
-        final Observable<Integer> testObservable = Observable.from(1);
-        final Future<Object> future = Executors.newSingleThreadExecutor().submit(new Callable<Object>() {
-            @Override
-            public Object call() throws Exception {
-                OperatorObserveFromAndroidComponent.observeFromAndroidComponent(
-                        testObservable, mockFragment).subscribe(mockObserver);
-                return null;
-            }
-        });
-        future.get(1, TimeUnit.SECONDS);
-        verify(mockObserver).onError(any(IllegalStateException.class));
-        verifyNoMoreInteractions(mockObserver);
-    }
-
     // TODO needs to be fixed, see comments inline below
     @Ignore
     public void itObservesTheSourceSequenceOnTheMainUIThread() {

From 096f44322e83095a260bf4b58dfe24f5565157e9 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 26 Feb 2014 18:36:58 +0100
Subject: [PATCH 062/422] Initial commit of the Android samples module

refs https://github.com/soundcloud/RxJava/issues/3
---
 .gitignore                                    |   1 +
 .../build.gradle                              |  19 ++
 .../rxjava-android-samples/.gitignore         |   4 +
 .../rxjava-android-samples/build.gradle       |  17 ++
 .../rxjava-android-samples/gradle.properties  |  18 ++
 .../gradle/wrapper/gradle-wrapper.properties  |   6 +
 rxjava-contrib/rxjava-android-samples/gradlew | 164 ++++++++++++++++++
 .../rxjava-android-samples/gradlew.bat        |  90 ++++++++++
 .../rxjava-android-samples/samples/.gitignore |   1 +
 .../samples/build.gradle                      |  24 +++
 .../samples/proguard-rules.txt                |  17 ++
 .../samples/src/main/AndroidManifest.xml      |  21 +++
 .../android/samples/RetainedFragment.java     |  65 +++++++
 .../samples/SampleFragmentActivity.java       |  17 ++
 .../android/samples/SampleObservables.java    |  29 ++++
 .../main/res/drawable-hdpi/ic_launcher.png    | Bin 0 -> 9397 bytes
 .../main/res/drawable-mdpi/ic_launcher.png    | Bin 0 -> 5237 bytes
 .../main/res/drawable-xhdpi/ic_launcher.png   | Bin 0 -> 14383 bytes
 .../main/res/drawable-xxhdpi/ic_launcher.png  | Bin 0 -> 19388 bytes
 .../src/main/res/layout/retained_fragment.xml |  13 ++
 .../src/main/res/layout/sample_activity.xml   |  14 ++
 .../src/main/res/values-w820dp/dimens.xml     |   6 +
 .../samples/src/main/res/values/dimens.xml    |   6 +
 .../samples/src/main/res/values/strings.xml   |   9 +
 .../samples/src/main/res/values/styles.xml    |  12 ++
 .../rxjava-android-samples/settings.gradle    |   1 +
 settings.gradle                               |   1 +
 27 files changed, 555 insertions(+)
 create mode 100644 rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
 create mode 100644 rxjava-contrib/rxjava-android-samples/.gitignore
 create mode 100644 rxjava-contrib/rxjava-android-samples/build.gradle
 create mode 100644 rxjava-contrib/rxjava-android-samples/gradle.properties
 create mode 100644 rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
 create mode 100755 rxjava-contrib/rxjava-android-samples/gradlew
 create mode 100644 rxjava-contrib/rxjava-android-samples/gradlew.bat
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/.gitignore
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/build.gradle
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/proguard-rules.txt
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-hdpi/ic_launcher.png
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-mdpi/ic_launcher.png
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-xhdpi/ic_launcher.png
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-xxhdpi/ic_launcher.png
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/sample_activity.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/values-w820dp/dimens.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/dimens.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/strings.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/styles.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/settings.gradle

diff --git a/.gitignore b/.gitignore
index f69630c23c..52b0ae57e2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,6 +39,7 @@ Thumbs.db
 # Gradle Files #
 ################
 .gradle
+.gradletasknamecache
 .m2
 
 # Build output directies
diff --git a/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
new file mode 100644
index 0000000000..87f0f5bbf3
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
@@ -0,0 +1,19 @@
+def androidHome = System.getenv("ANDROID_HOME")
+tasks.build.doLast {
+  if (androidHome.isEmpty()) {
+    println("No Android SDK detected; skipping Android samples build")
+  } else {
+    println("Android SDK detected at $androidHome, running samples build")
+    project.exec {
+      workingDir '../rxjava-android-samples'
+
+      def props = new Properties()
+      file("$rootDir/gradle.properties").withReader { reader ->
+        props.load(reader)
+        properties.putAll(props)
+      }
+
+      commandLine "./gradlew", "clean", "packageDebug", "-PrxjVersion=${props.getProperty("version")}"
+    }
+  }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/.gitignore b/rxjava-contrib/rxjava-android-samples/.gitignore
new file mode 100644
index 0000000000..d6bfc95b18
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/.gitignore
@@ -0,0 +1,4 @@
+.gradle
+/local.properties
+/.idea/workspace.xml
+.DS_Store
diff --git a/rxjava-contrib/rxjava-android-samples/build.gradle b/rxjava-contrib/rxjava-android-samples/build.gradle
new file mode 100644
index 0000000000..db342a5e2a
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/build.gradle
@@ -0,0 +1,17 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:0.8.+'
+    }
+}
+
+allprojects {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/gradle.properties b/rxjava-contrib/rxjava-android-samples/gradle.properties
new file mode 100644
index 0000000000..5d08ba75bb
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/gradle.properties
@@ -0,0 +1,18 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Settings specified in this file will override any Gradle settings
+# configured through the IDE.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000000..5de946b072
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Wed Apr 10 15:27:10 PDT 2013
+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
diff --git a/rxjava-contrib/rxjava-android-samples/gradlew b/rxjava-contrib/rxjava-android-samples/gradlew
new file mode 100755
index 0000000000..91a7e269e1
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/gradlew
@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/rxjava-contrib/rxjava-android-samples/gradlew.bat b/rxjava-contrib/rxjava-android-samples/gradlew.bat
new file mode 100644
index 0000000000..8a0b282aa6
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/rxjava-contrib/rxjava-android-samples/samples/.gitignore b/rxjava-contrib/rxjava-android-samples/samples/.gitignore
new file mode 100644
index 0000000000..796b96d1c4
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/rxjava-contrib/rxjava-android-samples/samples/build.gradle b/rxjava-contrib/rxjava-android-samples/samples/build.gradle
new file mode 100644
index 0000000000..1b89f83fdc
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/build.gradle
@@ -0,0 +1,24 @@
+apply plugin: 'android'
+
+android {
+    compileSdkVersion 19
+    buildToolsVersion "19.0.0"
+
+    defaultConfig {
+        minSdkVersion 14
+        targetSdkVersion 19
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            runProguard false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+    }
+}
+
+dependencies {
+    compile "com.netflix.rxjava:rxjava-android:$rxjVersion"
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/proguard-rules.txt b/rxjava-contrib/rxjava-android-samples/samples/proguard-rules.txt
new file mode 100644
index 0000000000..c423b03cb2
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/proguard-rules.txt
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/opt/android-sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the ProGuard
+# include property in project.properties.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000..6296812264
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.netflix.rxjava.android.samples" >
+
+    <application
+        android:allowBackup="true"
+        android:icon="@drawable/ic_launcher"
+        android:theme="@style/AppTheme"
+        android:label="@string/app_name">
+        <activity
+            android:name=".SampleFragmentActivity">
+
+            <intent-filter>
+                <category android:name="android.intent.category.LAUNCHER"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
new file mode 100644
index 0000000000..a3a0c73d72
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
@@ -0,0 +1,65 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Fragment;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import rx.Observable;
+import rx.Subscription;
+import rx.android.observables.AndroidObservable;
+import rx.functions.Action1;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * This fragment shows one of the most common use cases: listening for data emitted from a background
+ * task on the UI.
+ * <p/>
+ * We achieve this by retaining the fragment, creating the observable sequence in onCreate (thus
+ * also retaining the sequence), and connecting to it in onViewCreated. Note how we use the cache
+ * operator to replay items already emitted. This ensure that if we should go through a configuration
+ * change, and the activity gets destroyed, we do not lose any data, but simply cache and re-emit
+ * it when the views get recreated.
+ */
+public class RetainedFragment extends Fragment {
+
+    private Observable<String> strings;
+    private Subscription subscription = Subscriptions.empty();
+
+    public RetainedFragment() {
+        setRetainInstance(true);
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        strings = SampleObservables.numberStrings2().cache();
+    }
+
+    @Override
+    public void onDestroyView() {
+        subscription.unsubscribe();
+        super.onDestroyView();
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.retained_fragment, container, false);
+    }
+
+    @Override
+    public void onViewCreated(final View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        subscription = AndroidObservable.fromFragment(this, strings).subscribe(new Action1<String>() {
+            @Override
+            public void call(String s) {
+                final TextView textView = (TextView) view.findViewById(android.R.id.text1);
+                textView.setText(s);
+            }
+        });
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java
new file mode 100644
index 0000000000..5da3b3b7e6
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java
@@ -0,0 +1,17 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.os.StrictMode;
+
+public class SampleFragmentActivity extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        StrictMode.enableDefaults();
+
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.sample_activity);
+    }
+
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java
new file mode 100644
index 0000000000..e2b67b104a
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java
@@ -0,0 +1,29 @@
+package com.netflix.rxjava.android.samples;
+
+import android.os.SystemClock;
+
+import rx.Observable;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.schedulers.Schedulers;
+
+public class SampleObservables {
+
+    /**
+     * Emits numbers as strings, where these numbers a generated on a background thread.
+     */
+    public static Observable<String> numberStrings() {
+        return Observable.range(1, 10).map(new Func1<Integer, String>() {
+            @Override
+            public String call(Integer integer) {
+                return integer.toString();
+            }
+        }).doOnNext(new Action1<String>() {
+            @Override
+            public void call(String s) {
+                SystemClock.sleep(1000);
+            }
+        }).subscribeOn(Schedulers.newThread());
+    }
+
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-hdpi/ic_launcher.png b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-hdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..96a442e5b8e9394ccf50bab9988cb2316026245d
GIT binary patch
literal 9397
zcmV;mBud+fP)<h;3K|Lk000e1NJLTq002k;002k`1^@s6RqeA!00006VoOIv00000
z008+zyMF)x010qNS#tmY7ZLyf7ZL$ypVCqQ000Sga6xAP002k;002k;&Ux?!001N2
zNkl<Zc-qaJdAuc6b??7x@2WcI+;iuin;sYiWJUx>L`9r|n3#ts(U@pVoQ)(ZPc(6i
z8k}N`MvWQ78F(rhG(?6FnFXYo>28{yZ}%O}TvdDT_5P?j=iW=V`8=UNc_}`JbG!ST
zs@lK(TWkH+P**sB$A`cEY%Y53cQ}1&6`x-M$Cz&{o9bLU^M-%^mY?+vedlvt$RT-^
zu|w7}IaWaljBq#|I%Mpo!Wc2bbZF3KF9|D%wZe{YFM=hJAv$>j>nhx`=W<S%JW3kP
zxAC0SJC-=M%)~?<M!5JZ-{eDYxZ{AVNe(1HS3hztd1j3@5<&>is#KG!cJA5x!4)f)
zezMz1?Vn$GnZNjbFXH(pK83nn!^3=+^*kTTs5rV9Dq^XS(IKO!mKt5!dSmb3IVCxZ
z8TTk5IE)F1V29$G7v#j9d-hy&_pdg8?kT4)zqr>?`}I%W>(?GO%*C&}?Fp|bI*<U}
zbi+2P)hexq!x-r<S!L|f74?s7dic@nqR8Cz?hBt|@7%D%zu@Ewfwno4*BZl;0M$^T
zi=(HpypkDx38Q>~2&KZ$%^B6R&1~2kA{`CWy+>F-x=z-f{_&vyu_3yp{jtw(*syi%
zu3t2|4{c~LJXRt2m>rMg2V_kLltCZ<`m>qcI?BPP?6hf``|e!rZEFszeYQ3f-*nAS
zZ+h<E{@Gl2Py3Q+qWS`FZC5kiPLms%<ld^|7n6caM2uKR&*!+A3a3p!;E(Q&$r@&O
z8kQ09e$s5)y+uYRV^_1)iynMn`-gA2X6Mx(f6G;8g5iR9oFTOltAGFDyZ+|^^tC%D
zXly!$ZJQj=dnM+WgXY4wzc>1$mFwy+7156lkB(k6)!1fUbJCxgIBK38$j<WgPF4KT
zfv`f+iV`H?R57Vyb}HuHpz+PB)t`=KzkU0ydcIE94hvwOw&l@XH{5#Nqph2-Za%Zo
z$nRcv_>j5cC$r&YXN)nr#PY=tJaLc?C_o?j+8H3Q>891JJ9&$l-r+-SG#q)*;r52%
z@nlKflb65o%s*Jt)!pw1k{vIoQIvoJ0Y&Msiw0X!q<qB~st|^P`r0pZU-^6d$mM&Q
zcU*q&9Xp<J+jZ0LT)EzSrc$lgi(mUP|A+6p3{~N4A3rb*vIi2NFJJKjR@4&CJnKok
z=ozQ0Ozci}cen1I-Whf+TNR!AoKuf@MG~7=1j$wj21n0(GKC;A*sBPSC!l!1k%eAp
zg|44AT{pct&6_U^X72YkJ+R~GyM8hKz4w1`;!nGFD1PgUZ*+2Sms6gxiu$;6)wdr#
zAZt2c47w*=Kq8~8=OiKyWk#>J)_47G*?aJ6bJFLh_4b$5&1k5wN>du*>6#i7R9T8;
z7>EHOV=ue7mo77SJPwER4(A+s?n0JjYK)b}Om6n>ke?0JR=jTI+RFBg_iwb7k%n*2
zR_M0DJ9x+0zxba4(B1y^JQ_Nj6dlP5PGXvSq8fF#mxrFYj3d9(V#jJwt+IqU9+8+D
z6C6Us1O<r;^8#qGjcGQLli_gWWaKW#<vDqt<D4f?ojT{W*Y&17C)>I$d8OF!3+Hm1
z<!vvT(3}Y*73JN({lr5369(w!?kgFoE+g}fNj;UwZncTv8%&+GoTI+iV(Umw>W5in
zXV^%U35HooOpSmeqlG6e0kUMYNonKp1vr|My9}4-WO+uOxe_c-o&}%voNYHkqtle%
z5yQ_^oozSUUNu30EQSAl!Q%(%3G1NXENSMjCL*<W*^YF)$Dg{2W4_a3YGjsOev%{Y
z9yVjCp(HfeLm)$OC`#Y|^j&oTJP;5x2pS9_7&I6(2q72<fMOBjqe>Vx-Td2~rk(}d
z8pT!HZe>1r5EGuz`pgsg@^yQEi=BIa#meLq0!?{TZ}q#}=7UC9_l=w|wv+pP!g4#!
zRys6EN$Jv}#U47$k&)pDzvks}LGfPku6P9p!56Py)~1)W(11n7n}`Wx!=;_JTiu#d
zpCqx=hEk@t4sp?!j{W}wP@V-=Pd=T^>6IKBy;#mLA7hCe{V7B3@I7Ipa}L`MbF|YQ
z)$BNWsiEnoNHrtJli|n<Ln1BTGjcL@<j&)APo4){9`H_aPH_&hG-o_Ik;&v_(lo`p
zV2y|~mLsA_Ke>8cOnn4NyF=8MbVxgof0>Uv%wM_j94a;8(LMjl<nRf0cYc4^n%;7D
zEm`^zCwZ9bZMRw8M)NvHS3bzf_{EHJJiF5C2--t21Xa8$UIShOE_l2PIPY<}!{r|5
z9L{;1^LPiH-YjeDFXfr*Kg?lEUW#bKmc9Q08k^uX<T=Mr?daUrZut8_?eXXSN_XD7
zjFX?WjGM2X`fp^Aui-Lf^^)iF)S<8YGhX`*W3>L~E(99gJ*2%Jt<E%)JewiAhCoi$
zuE3`i(ljIMIkH|(nr6kTmlv-zBkg8nX-<~r<e4MSJTCLNJdkCM*o*<7>NtAkD@j;^
za~Y~&j6uY{=R<G!mHEK$U*d27&avbfeExkK9@jD-cNF{9E$1?^60D7E2)S3)vq$PH
z{*N&xbkbeM`yP2{vBJKTlUKY41UAq9g!@~6L#;ZDh?K8#j})|gg%Ain;C&#3fcGBf
zJ;4RCyoU*Oo_pA*nH)Zh2RCluvYTJW*iu8U>v5S4joH*RW_m9N{ZSN0HhAwFyJNok
zS9kx$>wMf%tUi&Eb`6u0lWJ|k?A-42(lp2UmS(PrAc(24wexRiHUieMwf$o%m6$xs
zp#-SdBUu2D5`v;(9-sm&kN2M74c&AvKe_v@tQ|dzJ2qSgQHpnUP(iQ?J%Il;Jdyp#
z7}cpq6Kdm+FS~zS4Eo;fuO=DFP*UlpO|_CNt5&NUqBvQWxmg7#ARvMf=%#H@p%RZ`
zjK$hMbNb+vVP3UlkfIt&ptJ<00Ic{Ka+lF+&w;OEs1O2#V8~O|R<k8DQ=Oet+srZE
z=hG9*B5}P)XZOHmU%ltR0rZHz6D7l|BbE_zh3RyfNMbfVxE&PhL+~QzCC0id#i$1D
z2*|*MKrmua6;u^5QuqlLu%|p!L4(e-sC@T66pRXi;7VqB&|pfz=!?%e$W!QcQr)||
zEpvOqi&XWhxMHm_!GHY2e}qUzjd7Yf$D^Hx*uL{oW;;`?UUCR$9dyM$80^=?cIw4s
zM5MG?!ZK<yO0Gjxs52Dr;E|cFnDk&Wvq@A1BhiUz-bRe`NQlIkA{Uqb;==$e@q!mE
zV3C47IzVV1AO(U~LI?$m%J;%2X~`&8fTvori}DqG@F8+}ILTOdmG@qf_*fK&B{C^Z
zGMYrjYP*qXwYiS<$F1jEcRZV2TODtI*?bPSPZYZ^e>*Gq9TIgM&UqM&bZOXBwnbC?
zDr))NR&g>lwVgcmnx`K1$)PTTw3m}-T11^ZkY{}jQ@lGD$XzJIcVFkYBBW=o_}TUU
zt@yd{Jz;@~72x#!RG(#ira6}v-*J#<{@@^OI-Q2T^}=IKLubsa&V-%WwlF1s7fz~u
zMdQTV7SnRet#^`VO0V7H(?59X{uy+S`(sorO@2-+qioUdo9+6r4#|jb=?t50oh42R
z{}I>Krut|YKkOc|O|M>y#(3YA;I(i+MiHSfwbJA$jIUr$Y2i|u)*>@2eUYk`j4C5r
z>61dKu!AqM_E7#DoDzbd-bfT%AYXUUB{SS|{b{`5^?wz1{PVQgTlvyqOX8(#GTz(U
zNPhnj>$lC`xaD56`TjW&uW8p~qikP*F8kHFM0frzdk%UNGjb1O$%uLK`0-)2UsZ3L
z#+j+CI_8k4VslL%$aVR@joX>M-@odbX!os$xY$HDIOCokY?{Q0v2kQErf|ZlN>D9w
zC+2}E&?rDdi#%))$p%P4C_xGXu=@U~_<|V4L|{>TP$XBp$5pCPXLzK3!;gP>7=QNi
zkNOur`>xY=@VSpB#LsN9JKpOz({ANcdv>?K+D_*_HZ<;9>kplj^Ph5!e&&a#?(3vK
z_Q@}D_M5kGcx^AuaI~qKYUnb1Mj-n;MURXa)+x7<z0Docp0hjm>~e2gbMW|gw?5Rg
zTOMlo>6zIJ$VNVgn(@kTSL0eP)nR35IHpoHM2W#h6cNmTm@-9`dFJ$;k(S`7Lg@RY
zp!hNmb9un!O4<wbI)P5hleP_cC(*Q7mBw6m@18x=Z~fV2_kHt+_g_HT4o_RU+W&0H
zlJVimXsveqoNRACKzpto=4QHPYI}P5TVJyL6%CNDT)tc9W>Wt05ANDGirv(B14gW|
zwjP}C9bK{J`qZ_S2o)b`RonR-b8~y8)$H0`+gg6>#^wu8eCp9xA9B>>8(KRizI?+^
zAJ#i>*({qM-c4gBB~5dzg(wj!HA`hkh!aDl5>u&J;>2K#Ax<n&%wmTP_`JyXeDJtT
z>2)2wt|L!9X;(=*jy!`r4_FhCBoRxNj<M>XNv(~jG<w@#|D==bKdf25?EA~t$t#wx
zT%N^A61&_<x1G{zwL-g*hN+!twDqCZi&gp8O3m78UHxCb<AKE{_U)U`WBUVRWab_t
z#soriUhZd?c%Nm)#t9e*33=*i&b70>Q|%<}%K6RimaBJcP0v}oCgRN3B;oiM)opj?
zXm;;tv3q-yy}NqMOr^~3&1lW$w3}UK_IT2sCrkYx5$&6e2A%g;QZUX~A&L!2rFd0p
z5%men@^zN_Xw2|v%*c2|wQfkN4r6u&k;LxYY+w3{KY#cie)!iz>(yAgt=&-+Sy2V&
z9BJxI+VMKQ%dvY~x>gmEijj3ss_*NAT(8d1@DQ6e&#Ln&6Qk>wHrh>;V2nvomC`8&
z(w?`?*_^3u-TJrMzv2~7dH(XLJvUOXk4U8oW6Ol)YsawhIB{GdvIzu1hzMTrE)cvB
z%2GxMpaF89<9uF(?cfN(BNR?wwWvCZ6e6<FMv8ZyEc0Y(VQ$@apxyA&ZguE&-HPYR
z*X-Lq{wbelLZ10j78H)%Wkq!$I3alPszL~Y%Vl4H3<)bHk7DDN8$_f6*rxYV+)QbW
zAyCw2JVmHgGcvgz(vEa8A4uCRj0I!b7%Lbl{Ee{&Qwl_5E!G&s6z0`;=Aa0s*ofd4
zMXi3Q_pX!-&f{EJ0_m4RawX3dmqM>2+G_{$+;`yjgLj{(^z*zzwd;K3RElb*%=??P
zm+lLY0@Y}^kVdMYX5M)YJ~8h=i(S{q#NfU0xPTao4WPDQL=Y_;vg=p%iay1_`<0Ga
zMG&<(pOU+bI2u9_g8IJBTqGX*3@G$Zc`pj0f@)vd2?Aj`ms>DHg>;w~p}HXV(*VJX
zphd;fht9qL3E)D8h$$A;SGl22Ygv>`iU=A)z=1<WOu(7|w!alcS|LHo@0aIX<c1AK
z3@%G)b@wuytY*A=D7$7iV60NDj1)ixzj!fWUL0y^p4#6u)uK$RiUuRYjFbv}J}UMR
zng<C)$N)spb~Ee?5GcWT1i_TjZV-7Fh_^EQO8MuwI|4dainOQ%MhYs6f=Kyik%8zF
zF^Cv)*QJ+s7>ZYN$|2`*$`R)?KD>$tw_e9h_x~eX_udS~Q%yz?48i*aIa+_wx|j{B
zsG7mwZ)6M3dmvgMC3K-66;ML(9o2xU!F8+qF)>v{1;ip)6v_I)6law|rd_Dx2oV|n
z(Qm_PUnTTuKFG)w%s|)lS!w~Lm$k|Al=0djocyHU;>1H=!N}0E0lSV^b2^6~^lUco
zyoH+|_!l<qyq-LCsK&z>i3#e<G@}3s=HCZ9T3)fjE>uHd4TJS8=CLaHG9H8g&h3Xm
z#>BkpUBAmae(#)qO3)ZMG3irM=5IzA^s+)w86=tIMT{&?Awux<(k2>U#n`c&@Z?u=
z%=#BoO-9Nc^?)hz*YW~~tU8rLR-MZBJsY_7fp2r~mY>q-O;L%5Fp?}V6CK=F(18U3
znxB8ZR0TT{)T64RDt!+yFgp!JXGP0|It0Hz2Em#YfRv>O>8A?J=Sz!nq<|{&mW=?~
zDQT{S6PH0|jwy37t+0Ob6izz)JdRlNEUbyk>-K?}FOT=Dj9SuS_0nTFd+A^D?Bo83
zTkicXcW=IuZoZd(Dl;&#`LI;_s?e;OH9quf?*XuV0O$Qh0j~HWKpA|PXV4&<S3K1O
zj2Miu7%|c}J$;NrE6!QKHntT|(!yEl;6_9FJyd9QW_bGH@8ng_`w~a4dk%uZ2Uq$l
zyPzzx_~`qpLiaevhgWmfsqf%TFTa9edl<d6QU3e<Dj3{b@m8~=gE-y?W^kW<e+nqB
zspN=p+ArWO21o-hIsJ5uiOSv8-h8ER9;k)(4OAyiFU)fhh(XKHEaWa{&5~32r|*24
zi$C@Twr}5BZh$RnJqzt{KSwBijkOUV{QUYWdCeQ2#{+loVRB?WS(eT-DJVu_>b2zs
z@W5<)dtovIR<mGD<u&|#Td7|q*ax6jKj%yA*u57c7HeZvrCXjz7M^gS&5M}YpUz)z
z5Mc(NQONU@=N$JAE_(B&xM+$$df(Id{8uhwW@Z*+?7%-g7N|lfhJnDm^_Tz2n=U+)
zkNnN=bLN>Z<Wm>@gvsi$^s;v05(XwF3$lJ;wzYfE`46fnT7>!qt|hWHRE>yQP)i8=
zVbC|O{Ud6%kwGcch>>|pE-=?cW;TDR0lE5Nw7l66lr-zIYT3bj^ujCn$b0{ZO;gwK
z#}}W(*T3~in$6ZCpbB98pftPTo;!K>U;H*7_}t4m;;4i9#^2t`pS<=jsnx198);d3
z-M6Mx{7-c0A-jhJQ`5mB<gsfJBaxz#f}QWO?2kdQtrs^|*uDx2Lt}BaFfg~UFvLpf
zp$DpVP_77`+;su)A?Ji6&*W3@xsJEJ;p5!;(7*7<?|%y4yzGmlX@)Tt5irKGapQx$
z_d^%(?!S6IW6OjueB|f6`wzdu^2xP$?@H4Em(QmS1K%hE&E|%Ntrd}YUi-|WSVR;-
zRlW1QPVTy>y8TBnfbr2~sER5E5oz}=so34cg)GYarRWi8w#W$%G{?Z*4xDb#LX1B1
zg!4G{m~*)H_J8J^SNt`XU-fxjea`>p_$Qyn*Dn18*WdPCp8oWw^XU)%kfRQHMgfQh
z1j_ua@O4G%QK;&YH3Y9(q!hkgOUCkcVH5N0Ug(EPX%H6qCfPqg))qrd#ec^47dBu-
z=sRkmjGS>3K(tfRTo<YCdB-qMSt-O~P)}s5oO$XSdG<-?^ONhp%r`Ip0H68F3`ZYz
zJYV?u4>;zCXO-74hV;y1!vCN}v|w?AWR$YpYXs@Dr?iNLKD9s|2)0aHY!TKTYhwMI
z7b#54h!H6rUU9+xnL$g6h?t?Li5guXPY1g)$bI$~rHWP%QkY<DtDO71ck#!s{UA?1
zWs*<5{|b&d;#s9n@<?$%`<_K)UL1!0nWeu=pu(P+Erfw0oUc?a+(1==_j$*Ahe#M~
zz`g+4l2C;Y>J6Y-U^0C(@*$ruN2*zn0QRBOeVpgMFbT%k!Dn1*u#%J^y)enX1K;0~
z<!N!*1-eGWprOw&Ax(Sp+I4Vm`<RpFd6wmQM$n)kxL*U1u?PlhB8-VT{iJ-pMyw0i
zG0!S%<1&nv7aj=4eNAk?K$SwVXxn&xjc#1b9EEPLQ`V5?O<z?81%5$vXvEY6u>%3Q
zP(b%}P!Loj6M{v96(Qa~K!bq-V-P89U_K)0zHC_F#L==3IPh2hHG6&?rxvQ%|EljR
zfGIDyu=rIrl1dyjuMfwuh?pXZmARwNZ?GbW;5BH5D#nN|WbGm+UGAh7_AcG>4&|{0
zrg?k@h8zm!0A|5Zo%X%g|2tBPKHHB6`~4h?I@bepDe6?^f<i|_<o4A_^FNCkyw`kY
zcCH&mF}WL|m(KUa7BdI~Di{)s#9hGelcX-L4T-7*CA9UicfZJK{lCsg^jp&ZHG>8w
zBnzfOf|j{kR5m6BLRr0$!RZ$PHSk*)tyjkws*DpyHIiiL*8o(Smx(OKT7@D&Y3OI^
zEUMtKa2*SLjt(eJsZsLsrgV`A+xL(~JN#JU6+L)gCe%VuSNbCzTr09w>eZ#779SKV
z)m)@#TNVy|q3Tz_U`^7MY`l}`GU~OlQi|*cprX?tm@tIV+8kOGkaa=9Y<{N|RZ)ns
zHlgnz2S%qwK9wXjest~Ux$YNNA{0?6Xpv{_mqYt8D`g&7Yb~>lX+HP&AK<=+Zl_kO
z6a2g`^4=9W92GQ3e9Mk6?DlzlkIM`iOzwk*5L81TcuyYkI-<3^@49_+^XC7&N}SL1
zh$kIBxb`9+v}acfV?<wf)<pmhUwp^U?o2atnzfSq;A{wpcM`I$Xk&)B+t#b!``Oc2
zxokY{<aN*#VV)rx6dT3NbT;y-uf2xLe)3FSeeQ)k_2lOi7NFrV;OIW!6gsGo1MN<W
z%dh-8-@o#U?3vrb5l5|@2Xv96HbiEW5N6^^XBk;l-rQ+at{AJYU0O*J_1;S-Ym>FQ
zN#04eHe0*j{pz=zOj3#EHLrT3e)O;3xqpCWrl$e)PcD9jQ4P-8_zyZg^M7i|*kOuj
znsvlwNUsy5+01^P_sqMOjXjxKwHn4)$87t-MWZZ*5Dbit4|D9vL+spsJ0JPd?{Ms)
zFW^<@yqjZ=IvG%$ck_Cu9|b8CvoV%5P5IZWzs>i4`~`N+-p`7a6RbLHJ;nxtSB#Mb
z`1I552=9DrYWFNZ{-=Mt;SVo5@3cmv`IZT@@>#~zCe-=qENxsn+uHfL`e?SbT3IQ_
zt~e)Lcirs_S5^X#?hDYmgV%8QQDe+?>*1&0e^BnaeZz(&D~3<)#QuUL8h*NlXgtr|
z&a{_Z)o9FK_U5<0!E3N|yY1P2g%J9s*?!zF78+NSb%!ix)tbQ09oO&|U$~Bwk35^-
zec9VN^xz{043e^xD}WEmzh8d^-~Pd8**<d@D-RmuxI+&fC~RYjR6@&CLR984Rwbx!
z)+$51{IzE%Bg^AW*FA8<yS8oW+M}OD90~c@MBP{HlW^&T<Rp6gBR^)-gBw}4a%}$q
zZP~n)M>bEfd+I?HuO~n4SksoN8LRPUy={E<@BjRMUh?X71Xaey>t^$&Eq2B7)u_r$
z|IQwpG52G!F$J5fRo1LqLB7iKz_!bI@27skX~+Eze|Y}IBuRp?hR7z|eA~7B<99#7
zrX4r2a_tCDUb_}Cg)g!OEVeJ5AEVRyb!9~f4OL68qhZZRP0l*>MdkxvxXeGWx$T>+
zI^X!wnYQDnwK9?i)j)eLXJU2Cw>~>R?72@MecvT7;h~2gATow_cbc)$Ws+xNSB{++
zo^tTp^y*(-Y-XF=$XyoBJnMN9+p!Qrep1)%ym_v7zZH{;u~L>T=4XP!f^?uC4ULUR
zdl`>x+DVkHVd;|9#N*oubBFQEyRT#UK^0c7T}l)eEEFS)qvZl%f>#I;iCwAWb=kW0
z(e#lm51o?d>D|kgtTscVQCNDAXMAjxSX&{_Qf)T((wMHWWLb<o=q9G`K9PU;#2t(9
z*eB7s{;CIg-b;?>z6WpPXP0(3_SBWwI19Vx?$i6WUqP$4O|wjNbYzst$z{58`cBhm
z&F(N-KeXFzo#aC|6BbC($As#B8X=}ggpDyQUp|Q>9cG$47#>TQn%T(eHA`5se7KnZ
zF_dj<Da@+uyAAeOi!{YDPQ=oDc6P?jwRV2BTGy{FTfW>_6NN0xS-oZ%Nj%PTpK=MC
zw*4IMGls_v)mokI)Dph*p<g~0j{kay^R@3ffjF)p2#w}ma_2D;Q%fcgv7GpnW7xZA
zMwX8rtHCsuZry$7Rh?|d$#FHfYOQ7>D<)7prEF|j6I$2=XF=Ua3z;BN^yt&H@G%7&
zWnL7*e0S9svjSP>kuc;VCbZXUN3G7D8`G@!Qnjt=p=7yC?QH0tsa@RsuPMLj@wf-c
z|LV)H$Auga+MTAU#>)eeuh_L`!<SPxd$x^4>qC=Ls|{m}Cy)|w6#aP}w6_-ya~9LF
z{dQAPa-|&ME858gIK=}lVK7MLT~Oye&UM9y?0X=8Qmvb*)=X}iv%Me)Gqav+FWdGT
zuk&#ak~?2Kzf}w)xZuKGx%+`1?Ec<o({tbcv1gsz>oq?*H@EjFm%C6OT577vWKoJB
z$A^sIasm!5TGOFF<zd7W&2M7`jG(5h@s!1~a`rlk0+GqdZI3MNDkl4nIH`Q*^B3K9
z`B}d=VOFnLCs{8KwV^t3oG?0;0KYjvPw0WVi!S*s;;6z*V;jzA)N2#cYNT-_^=y26
z+50!#_aA?m<_$MGUXMmc#~2<Sqgojzj;mN3&-cCh?QB!bHi|J=Yl&=BRs;nl5P~Cj
zDZO5YR%=e%t)8@I)7k21@0`E;;2qb&EU$m>GmHkKNTE7KW3nveUq1bt4Uj)!1_6BJ
zU6=EoPrjVdk+pQX+j-GTpQS&&^43tT43kuRlvE8fGdYc!1|m)3WCuwlqB>NeQc0**
zYE&wTj*QpuPLfJ)j2$(`sI@k@oR!^9d(3&Kd6r3*<)pooPNzq=)1%#NQ;nAsF*5VR
zOYXQC;B^<C9u3z=+}kdAC71ler354NT8|%`Ckzn4$1nUL@A>4*Sik--jy?J`uDj-!
zSep}9YT4*SOrT2I6MF4H+EZFRPh+}^b4@i8OYk9Y&86o*Y4(`Ax1W4#t<mhV;YZrN
z;7w<I``!m{|6Nr=6j>X^5m6LjZPb61LF2?qBy?B_?1YE!nej)R5c8qG`2s_uF`Cu+
z`X_$#2Ur#!Pw0WVd60fYG8A#y55LDyJ!Yt$5G6Efb<6Nr%-BTC_|llMB?%*A5%rOX
z`fyBbD5g@4Ns^)P;F7zjv{t6u?k1J0kR*v#Dhair3iXjH^^qz=!xd`vm`W`oN-Wj_
zNML7~t!rR<Ta}3=EBWI4AJ}i${%>bc|9I0mUjpEgOJ9XGg<eT2mRg8#i4Y}9oG4jE
z>2;vjDZ;b~V638P!uVuejytg~ci-I(n9#M6AR=mQG0YjoLKGPgFp(jS4Pn7UJR)Et
z<umVj;*WzLaDcw>-8ZsqWsRLXri#f_BSeWIat3P+Q3Td1#ws={2CLGpDdvrgP#KD7
z&SnaR^#_Bsq;Xt;kyI^}iX~1WYzdHamc$tH1#Mz6f<2(WuH^s%^yXK78Gyg}{;LNA
zoW%$)#R!a0wv&q%qj%+~i3^k&1jY!ljfi82Vr$~W5G6u&$Wp0VqR3*bDIWLE4Y64K
ze08)CmeFrq2><T^2;ljzS%$HKwFVJUV+zf(uuY+{P^l{3+v0JiR58ZmgAzrC%Fqx&
zGU6oC>QGFSDAk%Rhs}$r*rJVNuoO(~AJ!PG{T~d_i(dQ;OsQc+q&tww<xqHG0);A$
z6N9>lJV|`Bv$N}R$K=uxCPyc!RBBXfRjRcZi5yAQk|YKj*>d`|Xw~ckP!!SW%^gsH
z4oDR1AJt?S?}B;<&e0TPFsNAMQwxCt69o{uA>=K^qd1+MST3tptj8GHnN(upgb*ji
zq`i%b+{{=o7ByB78@8!x_Gs&uqLOKv_6{gO2b4jbc8YT@EEzqBp!v_c?XXFx9D<OC
z;4NxI#9*xraTNPr=p|m~esIjmOQ+%_Htj|fDnk+?JA|0<&7tAsE!I{iZ7jK1HIa>q
zb{!I|Nu<;4kZbyl3*LDg#$f7`nKwT9p9|2|t&fmAe64Of^c3TKI%Q?_^+uxaj|?xL
zw5U4G#YlpQDngbfM)q85qt=DJt|y5nG){VqE;V8I&WBCAH+|pe@QT+};^BWB8(lGB
zqe!DD7Gq<wG&R%HyXl(UA2|5XL;j^+AD4$7zRlN%M)}4i4<1l}4(RU>I`0pj%h;hm
z;n?F&(5YS1X4{T?Hf24&;~ic?rDC*Zgk;*ga9b~Je`?R%gBQy3U5$!cEi-#s>T+d#
zWH}Mbv|6p1R<`wiiPB32Gn*u}EQxC^LGJIR?H}~g*|#s5IQY`pJzcYP=0El5RWIen
z8*k;5(^qldFJ}(enhxl1pnB_vPi5uu!@1|-9|Owd=%J>WPwQ>dkLW|!5WV<$<73Xb
z{0CRJT1OpP567)vYea*J7*!3_M-nC`C)l*@dKzsw^5El5v)K$c-nf?sZ)?i>Gc=yt
zg{xL=urnv{!j}h=hh{KFAjIS@=h9C<bRd_+{{{YNd_enrvvL3c03~!qSaf7zbY(hY
za%Ew3WdJfTF)=MLIW00WR4_R@Gcr0eGA%GSIxsM(l48sN001R)MObuXVRU6WZEs|0
vW_bWIFflPLFgYzTHdHV-Ix;spGd3+SH##sdcWUue00000NkvXXu0mjfsl$*y

literal 0
HcmV?d00001

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-mdpi/ic_launcher.png b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-mdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..359047dfa4ed206e41e2354f9c6b307e713efe32
GIT binary patch
literal 5237
zcmV-*6pHJKP)<h;3K|Lk000e1NJLTq001xm001xu1^@s6R|5Hm00006VoOIv00000
z008+zyMF)x010qNS#tmY7ZLyf7ZL$ypVCqQ000Sga6xAP001xm001xm&hCs?000x7
zNkl<ZXx_D1X|x?xmHzfQr|OPx$a@)HCP|nQ5<;LsCJBhjAc80$(jX$JtzfI9m!M(`
zDoCSI=>!xJWW@nmR0Ns^Wrk)72_X;&VM@qLNZyn;-h1m-)j4PH{!#b7fObo=TF+Xw
z)_t{JRqgNW{e9m)=MZ*rJl6A%IHK!gcqM)U)>TjF8ytMTRLpN39jns9J?@oOe47l4
z1dw7d06;*nuu_+V$6Qs4K>#PCRHVFExV^duw#+<i(*6$thAv)qlPvl2x}A>4>?(j)
z*AHP%*L5@qEpM#j?*@5nOq@HlBR^5M@^_J9)U!&MV7N?QAAfFbdJaGWPgRws)6~+R
z-NrZmx<?+k?X>0V*7Od$!{dkY1w*wll3j_1b``)C%NHS6N>yBU998+?y%)4SU2YA}
zA%$NKSGVi)4!sVH=l1lla~XcBLKrfnO2~CXCa>$GlX_p?dYsM`3%)hidhs()bzlDL
zr7zEG>kK#SwpW`1YyR;!pa1&-`0t?)V)3FnK7V~pCo%hYIQUj+f?7Oh#@-(|a?XKA
zr;?n-<mNJLC=f*0js#<1XfX7s^WoFh6|SQo-m+%p`lnYt+IwL~m%g@82=v9Lukzox
zej%>>{Mx?{fOYn3n4;UD5a5kBx9Z>DQ1SETOzUjjZ`HF0&e`i-6T<17qM|ec7?fBc
z;0k&%hz+o?+KMG>1)PSqUSqTR@!luCa_YiGo3TkPUp^w8T}r$YFf$gPyy|ZYU`={9
z3c4MNG|FgE6ETxVuw_~St-lefEMgF+NTdzZD8wWJ0s<69@frs3IxH*_A4`(dIZhJT
z)TwApTxD36oOSS>-?;UKV^n{)k!mFpfWRL3*Rxl@V_bS?f`4@I!*C2lX%(H}L=`CT
z0BxGtLQ@`yX#0U)3`bO@9NHBjM^*Gw6<bk5AL<x^hrj`F%;cOXm$GsxzzlNU9{JSz
zUrsyXkm6kfBe4=Lh_!XtRPe~1y?+}3pSW-?0#nAswpLm}*UOe<LuoJb{=2H^-#<a@
zD(KTfL>4K=(1QdKEK*p+u<&qTSoUzKhfO`4Wz>@z)uK^Aw6m!k{QPq@f~bd?t)6?}
z1bJ=k7!E&fDxUmP-(QVQ?F@i8a-dv4%Gg64haX`<aQe3+i4GmGn{CZ{)8ak|wo@_U
z`;dr70*4qDu~@{MBC!@}?2slNHWkEif>yNv^E%Ea<=YJ4SdqH4e{1~Sk?qbu|M;*f
zbqpYh(szvQ9ev=Amrj8q0@9+|SbxTQw)=Lr&Hm@e_hY2mXXchai5dBmusvCYf%>!X
zK>#8PKtTjx&+y*EIR|SkT*`=|2>VPq0kb=fM~F#u|GG<9sj?zc-#-8BqmC*-%N5t%
z3v1um65bJjO9}`JV*qzjs9O-*vCma1qq%z0=Thg*sPtm8u4CiyU5H^JCTU0mH2?_M
zGn{jci{Y)p`kvomV&MR6*th{{opqpyh3Ux4m)!GykUSWKMk@t>>SyNTwj2L%XZ{Nn
z>Xv_j0zm+HA-wSFCJ4n;tqux{Z<*M!+ghP`mh}};q{({$d;y{&<a1?^QXmjS2oQid
zlSS`#WWrfSoYY`rjp|qe6Bvjyeq=b(gMF3jf}C7njMlc+>M#518E{~{H2e(KJ+~I!
z(QA0${wLzt8F#!r1DoX%bYVIIT!6Y<gOuu&5@WwTCSv8f$5fy@JU|Pp)v;Mni2y>1
zJctN_2;>9AahjEz5Cm@p&;a2*ykj`$0UrSH$QJ^n3By@S!UCJh5jS2|HIuruyXF34
zRDv<JonHqb75FwkBitYLD8jP455<>0v?9yEOYVFWR0jftU~yzAQIFKu_~N!vxLSpD
zIxEmBpAwnRC3gEyg%Yon(xeEA2t*11fhfB~8i^HvMIcQOp5dF9V>l<UsfSHG(nO?I
zan!rHTJ3(t&42azq0PshK23f2+$sFp3lVB#9{HkDl~FHBLD*-{8UXm=RgVGyX3T8I
zAqVY-x$jc`ct0yw+-+W|J-Bde$z2Ed>7DZ+tS31TC`?6B2!P-{Ai`NS%8sfWFCh_#
z2!sJ<26G0;dxnUBNT3Wrj-j+52u(2zc*4ieoxAxfi_hFMD8$Dt*t4hHU+Z6a>y4`)
z-dgRJ&wT2GICjQeJ2<d9{RH+24xs{$5g^jranDy3%%`g|+V<wi8*lb+wO6%GX#dUT
zwQX(P+gATPuK81gd?JMwp;D_szGx8U6tp2|qoC9dYKZ_M0%l}9Z~|u;Y0QWtk6Oi{
zIx3Qkg;X6OYkhRl`%dXvI%P)NN8UAk(tmX3y7E2AE8NrDt9rU?KR@%xsh=sJotEDD
zqV#O7W&rMa<HKlgnXHM(r)lz4rQB77&|A-Hcw~UKZ5qW>4|X4P=?_kA+q7QY|L{F)
z>E#!CslTU!sFuPzhBSJAZ4?NAGFdr600O~tQ;`JDd9Vkv#1X>KptUV8Q)hHgp)4=n
zf7k1aF8a|v_e`5zKCDz~Nuz3ARYohScS~Kpws!0=fL0XBO0`T-YycqYn}yY@ZV?g2
zlnDnM86|@t(hM=mC6W&G)j}8N_Fwtr#>s`2R4qD9xuZ_o&BU=o5&`up5LX5DnnxN7
z(!|510_PdtJ9u$`Fq8(A0!#>KLogu_1c1^6@0sdRitRngzWe^er2PiAMIqpkE7Xj4
zqSD0i@PNn2cHaUJ;)tnGEM^?Y2OX%5f<y>OPNhi#0IY;la!zy_Gm@B#Lw#(Mo_^%=
znu44{7-|HeMy{k$Y%?&%Kq&>KG_*4CK85oRio&-@sE4y2Y3h;2*%j9ragC&24JaC`
z`!uzlS%RjYWaMg=C2{s!Ax`QU03w3c0Yn(2{;azYNJdU3mn!CrxI&4*JCC^T#}y}2
zA`Q<LQGFCSJrSX9!Ep2%a$y01E@njb+)yQfa{^}t-UBSzw~Y>zFa=EsmQ0RGvftbU
zQ>{c90A|-98)Xj4nT0b0yyJf8t%xIraRd)QQ&z*I6o?d@PmrXe$eT_q-0f@}wCCAq
zEl$Ss8*j&&jkjWZ<yB}EAkf8ZUd4@r&y<S6jLfasi%90?jldxSc<)mJLqsE~<T3!A
z?Ykitv_b%gNKFI~NcI925C}xbc`q@mOd5#+@_^C`X;Md2ucD(o8w+<o2Mc#U4ejM=
z&9va%bI!uTJx;;;?)$L%wOg^de>GSHg|Kx;aNPWFa9~0$jGSbWOU>XjH6x<NdckwU
z2WHP)2qHt7e<~h-fE)TP0v2WwuCveXW!Y9pZ5^HEJ#o^z&&SNpLy!+!8}gZ{5)pyL
zBQ$v|+~Z`-pLGKIMqa|o^*7`B*YAc_`E2&3>Dc0w(iTEtcE6dO3<w0a@m^ssSv&pG
zh6kaQfmQ(ka^q;FK>#5TC{ScvW=I(b=Nv*)M5VtC-7j0@OiMO};u|K_aA+ua&Wy|G
z0O?p6>sL7#>4b<MFOQrlLn#gKQ^`J^RRCxBAR_FXOPzCI_VB*39(ef4o1s+*twKN$
zj~fs-v>E^@$`cedW&;pHYGbq)cE=gVUygN~?!_hF|0teV`9}~ml+s!M!x_o7(s*;*
zCVc-VU&If8em*{M)JJgGyiZ}QGSUDFC<*}~u!v@1)yzPXBMKoDa!^zNBmjHLN~pCo
z86Fi-BjwE?n=_NmIA?K7liV3M;v_;xTNl23?ow=ga}EA*-%{NF<S%gIdoRF23y%Z{
z=<C~t-~8uNboZ{oF-LwJ7yi={geH%>A9)Ej6(HYiJs85m`CL9ANNz_7Wfw>}W{H&o
zhy)^>0cdZXg2B-WvL1};5P}FJQvqpeDFK{}*W_F4Q?l}yJ$-+C<-Fxs|HfnZ?SC!9
z1CQT|j+S@fx%Cg={YRgO&z<v4<ij$Yx8o}3{SK+j#DhH%5+b5(O(El46b8H#5%Ta%
z5N>2Z>i~diz*O?*BnAkIbU{QcAP}Z33z=$xNR5+KgfMs35xDG&i*Vb0Kg44zZ^zZ&
zc>uXE4-p1))`B-&1MC}R(r5-n0MAaC)!S!3D{E#4D+*c5&ME_7bO-`vnhuJ0%rG^y
z*MSI{U{o_J!WqGvFVAW?BdzlmMhBQRZ2?B+Z$U21!?_gN1W=^F4PGQ^jHW1{`Cb9o
zLx~8DXBkZ|AhymqMH-oHxQxU~>&7f9WD8o#QYOvxW(yKUdVH3~XXbxdwyFjxt+lAv
z<LsW&*(AMXIG2u##dx`haG_8Lh)9o{9FKoX#FJ+RAPS1YW-FlpsKy5<X|SG{-`W<7
z2*fqaZb$tC4RA7E8qJYe&R_1GHF^`MM%$9rtZMSjfg}|H$=fE2AVO&^N>ZaWSag=@
z=8P$&K}1lbY?iX@ee4?s0wKUBJ964=H$0STaA3T?n~R$9CTTo$W*+}*eEXdRL>ghx
z0ulvhz0Z>9A)>e;5?WE{3wn~(Mxl@k5Z8vY60)g)Z7AM`NMj7L0~nqG?*MV$0cj#*
zg?t%+Zb&IZs~iSLH{&P2T8vGbH$W*3fW~XQxiirODk4xy!&-;m-f<)T^zbbx6<grh
zH?kOlP|U4g)8FmWV3kkGP-rFb1=xBK<cll+?H8vE|McEdNhu}udZQcN`0ATTQ}Bcd
zU9dK|ZTmKyr>J$2bI!+g&Q(Tb>mTpfw(MhPbbX*24<L410T?g~jL}%%eH&ISyBmiu
zJQE*1?hBYQdFtDO&Xmr;JH|s#+>YD+xC~pjzlg4B?I0><U2r4G3Pm2N4<t67ex{Au
zmb4b8EV5}8^~&HwBSX<8zrN-%<jaKC_B@`rzApoC)Q9#20J-*xyQz0uZzW&oJie=|
z{Y0W*eq6Vkoz369^!hLK3o8zTBI=e&L_m_s;PjbYNG4gV*?be$Tze<pv)?Ch=E)Z!
z2tpW>ZG1eo;$GZ-@3q)Ayc(TT%9uB8CcO9K>t$rJ4+!Ga!{2blb3*{mJ?rAx;e_@g
zW=}sb8SURhsg02gkr06Qo;))H{@ois2J0*E-a_ku;$#FwS}J2z^z{y5!Tf{u-m?$!
zW7XmPw~xK}Y|U*DV-zVxM2Z?xn6(ROnxdy?JIXW%Qzy=WHv^~-wPRiPJ(xPPjP?m_
zU@!3AH)Mt2y@NuFGk%)cvT4gxH~;vV!~gKarE2vv&(f8P@Ag++xft8kE4o&xvN3^V
zhgKTPzIFc&iMV*lvDmVC6ReMr3kzh>qKs;xT2uwI^KCQwiCuxGcI>;nX1mYH6|D_I
zV?e$kJ`M5;L7M=zY84}cF$$#|Dx-Bwp4<s#GKVK>xT+U;&*D<@0j8<iSgQK^yFUt|
zJHjxpJEy{TOqfQ@z|hcE$rXTH*oL8j7&lz82F<UIkF&nK51^2(s;q@gErbIsI%*L%
zZ|b2*#iJzO5|v)xcF#>tMo%x5%Tg?~5R?T=3cv%@lt|5rbf!U~$$KWHR3?X<ZO3>k
zu&I|c5%P}XIIb@4XrJ=aC`y!W*}^Y88R7A}hVa+MJ05U+?`P+M8rvjM6j3edroqA2
zxm4Kuj7oLnm$`fxbar$}K3^bGfWT*$Wd5R*hEfJ52%w-LATTp*YNZ}ksTNg7J=bnd
z-Pkqa!<Vb0PQAV+;?9{d3gJxLzWka09{>RO=D(kYB&|Wjqg0rvF8kum{NfucTYqrP
z`5U%u**G!G6{S=zQMp`3K3_yWUyzoz^2Q(tmC>3+s5Oq`4(BY=)S@2MFgiNo;u?&k
zg`0}`37-~9P0%vHiA@+H2!cEy8o#>wuOImB)G_Pj7yce!TXGVt#ORn<k`*uCiJ_r>
z(=jFB*q2Zp6$}lGp?}+$um^#4QjKaSEI75c$z6AAYL348>#uKEccl>fFbuUZ0R$d}
zZ~}6sT!$|qC`YPurgrtQ76=RC$YS~T-}$t1r_YJ6x+vSq`|<Dg01#s4^o4P;tkaIk
zIh0!oQH2pz1ofK0r6g&r?0r8PO^-PGTPT>xwOl@gGLU>BhcFBv<X}jH93&{F@Gi$a
zFO@NIw-nc0x^oA7y959LmfiAMm=I8gLE2N0)5sSzf<VI<h6w~j4$+uE2cZ7$Yy(RN
zl7=~jAV(;*7=$^K?eusJTPFkoL5qTC!8PC5`QU+_JYs5&FP(V<j3I<MgM2X*ZAg^P
z0>~FMie-ahi$Rz-LINpu0Hu~Za`}LYEdk2y0hQVU6k7}mB|~9e!x(}I6ii4k;VvE0
z?|KG+Oj%0Bi3m(dlp;$c5Cu`1C<qDpf<l@Pymi&IHUzY_O+XkFe6buNC|I8_Dy@}*
zb6^(I){r-Wf)|BKZSe08Ac?(v{_6)R2<nF)c=!v1-0nmoLc+!bVvN>M@ypLV(%bX9
zr_WVSKiJ10x1!vdPr`gLXF?@f1r%~#N8UkH?XgO1p%e>?-DLnfb<FzKF?)favvmqu
zi)GX*{&D!y0S2AB6Ix+ZhjLawTdfV9JO7~0zD=(UQBbT=-S+hsONI6Atz8Fqv`=qq
zZ=WVg<%goE@~`t39CXuObM~Q)n^tm|5AecML%S5uE^z<=7A`y(2OMyyw6{*D8!lh>
z=86?7j~f~sKElT8lSw^&-{|PJ_Z)D@o-cw6^yvN1aY@hS38meM!r|M7s_XW%93Aak
za$IUh=gpcu=jzR`4$^18^F8_11#h4-#Jd^}{s&{CB`(>qac=+s03~!qSaf7zbY(hY
za%Ew3WdJfTF)=MLIW00WR4_R@Gcr0eGA%GSIxsM(l48sN001R)MObuXVRU6WZEs|0
vW_bWIFflPLFgYzTHdHV-Ix;spGd3+SH##sdcWUue00000NkvXXu0mjfB?gph

literal 0
HcmV?d00001

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-xhdpi/ic_launcher.png b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..71c6d760f05183ef8a47c614d8d13380c8528499
GIT binary patch
literal 14383
zcmV+~IMBz5P)<h;3K|Lk000e1NJLTq003YB003YJ1^@s6;+S_h00006VoOIv00000
z008+zyMF)x010qNS#tmY7ZLyf7ZL$ypVCqQ000Sga6xAP003YB003YBc-z_Z001{w
zNkl<Zc-q~4ceo{0mG5uuy{qbk8@g}z?VO>>IR{Zx9EA~4K?jU8DyU!%BVu|c#=(H1
zIAFva(2=Yn8AKWhO=@Vm>As!A%_mpwu-+fLs?Ir051^0kZ=Q9(`cB=t=bYMm<@H-@
z?@QQC#}<A+X45yYn%|8*um`qa2)As07+Y6VFn`7%Q4n(>7(lHuiOKOg-hI-&yJQ@X
z>38Dx`mgcs{{O@!m2+^EdNUPDF+a6!8!8*d@!BI^jeED=gH;btqEI5d{e*jVDP7bq
z{q~MSBE(fsoQg6}7k95+<MvrH{UwJ@Ip`w~PJ8%kTDNX0h@wE$ayqeC_4pQi|BmDF
zniEdIRJ;>Ji!s3$poDp-qlOkXAwnM{3JB1P1P!!MLkm@C24>Si7~v<e-E6{9;ZL!`
zoQM6?rFdMw7Y+$tTzUfl;Pmpx<+vQP{h0k;E|*@q9Ah7{)~#`t#n2NCckpq&yPPg!
zcQN2k_bo#*HWzEn@0nSM8}Iwe=T{D`IayKRyW6&m&Y3%JkjIDX;;qNtfx#Jlc-sko
z1_0FY3t0Xo00Q6;VJ3#~J2bF~ELy}!$f8M2Y^NdIhCS))=@SV@20y_%`#Dt21OOm$
zF@z9cM_Atci<~Q8U?Zp(ZJgY6(Tc}6oVM;^^`1wDR$<ecmWT=xkKWtd<#gF?8t}-n
zCVIyX#Kz%!g&Ws)GO7G%&LVm2j5+;_X3m^>(J@mNzG-t<6(_#~IP~Z}QN`;~#%u^^
zBv=E1KsZ>EXwWhEA%MjWSj+&p1YiKMScFGKjPH_0g9QS9!hVpah<VJajz?P`#rol=
zaPr)fu>ud$BNHq6km8f&$y)VmTQ`qJPd+?0zVd<OngfpBgumWe;hFOURz8^Qa=Pp`
z4XBxw;Ke_}_=c%&aOs`mb7wF6&g7{3U1hR?D2m?r{X1@Z>*nDN_N;fDC>PCKgkkd-
zF&a`~zS4LCy*S)Om}M0r157c%Vz&|}g=6?|;XWKwAQT*MxQ#H?lrYWC!I5q;pTUZZ
zoF|S^mMxt;_qPCIXf(txX5a0Ww;uk~=vd{jwJXPI%UbvK`FqRT9{O`bUiO)BJM_2%
z(XOY<ZezggMGB%dA3`}^^VlF(1GH^T`F&&CS{t<1D3wcJ5)g~ueDtlhIT8m;)c1&C
zEpUvf!KfHd?d4E=BZK}!<NjYJxa^iiIODcn?04J2IOp~l-@iS^_pfT9a*0OsyfHj=
z)JC_wJRL8!B^orF#x<`<KBn%TxJS*32JF}DyHA>!tbcIB+EHv;)4J<VzieD|&@nw?
z`5m!a%X{M9n_DRN?RxU;1|Iw4vzMKMR;7q&$|xWWqJoxj(^+TKnbYU-PX_1os<@S0
zFV<~8?agQY&;myz!KKGa6#j`}Pc>*BV9|&y5&#Sa0{{$SB&foHK?p!lAcP=9mJn^Q
zEdF4f`u+CiwmYVjr%WuN^Du#n`yU&B^3IJzBL_Zu-$?zTyBfz|`{R*^-t)z|a`kd+
z3q1~f(<FZUl}G<^7ytmP82HhDy$I!j8b;RkW7>k6y5Nm3x1Yb_kKdg+KYV*sjIe!V
z{5>Bz^<6`n@li*u;}T2+4lyJ`2oxNk906cBFdVfoiU|zCpa}<N3kL@#hL8dggzJHH
zy<jdqWUTs4qdN5xD<A$pqod;=T=C#`Jn=x|6Qy$L!lE$ptDk((zWGB3KuEw@!cV^T
z$UhbXo@kwoy`v*AipTK7U;PD}w}L+T{ujs(ocmzk{KH0WTD(`^A&2d=!0b2USlPrj
z0az|#&;o%ls0)oM985lN2f)H0MimL_aA0@_SXek1r`bB=taV@=NOFCUqP%5zczgd7
z%eNL+JyO5!vd`!<K7MJRz2?^=?yEoBiyygX0*$J`XZ~&1#{avW0jv0IG%=1|3}TV~
zHtuV^4EyySuZrk1L%45tb?dAjss42*%_vS`hkokCTq_XCI<}BT1tEG+#54rxg+u{>
z1i&zeF@X)3#Clk0*p&E|Ev$2}*1}l_W2{Z$7(q~!&ar*`feE?ciQuhsm(q`Gl}fN+
z@eJbtu1z-J9Kjlg^G?2Vm(yjpIN`_LzXAXv^r3($xF(p5y?b9P1*F-Cr~YXsj=g)|
zS$n>$x7f>y=ZgXCM@>wqVLVI>hXL%1sn{O{%!kA@0KEW80E%#MFwm*p_a{<c02W{;
z;2eP+Ng*PcB$|_0i}`yN`H&YDzSGlN`oz^2+;3#5iP~f$K^Dvg%)lkr9lOhEv&%K$
zKJzNf5c{A)8*qU81=fi3XeRcSfHmV-f6jF5`E`p{aVsx((`i2uq8B503;@uF1t?>B
zD)9ll)VtgP1B?cSF@g0+Q1@mB1{Ma^85pZ!tc5iO#u!-ZV6}xY4oPBJCzg_?K&wta
zn%L5Rj?vAeG*Bm!j&+Mc0?>)WhhMvFm(gdJCt~yENoevA*5h{EDh@*#(_{(r%m&=?
zu|e$lr34M$iU-{w?Joo(Y{qhgD4~QIkSM}}!O$?MLZb<b1Plu=I}!;Ru(0V=EC`Ht
zl;i+rFbgmXILBTa7$6cP1XzXENbTNQo<1^NH%n&@%x*SDHWkP^?br~U)4P;DyHo=n
zOx}zI!SUGQ?!y*w8}{PYDhW0*HQqajJud-ZH(?p|W05Ff5W{#J0g4FFg8-#;fCPqy
zMk|ecI3GBJ;8LfXxn2tc!>I-s18e=OF&ai&7-M0rh0zYyI+(=47^@pK8?@?t)yRhO
zzs%pSswcJ+l9+kcqH%0n*9V;dpM3NE&pVBFsSjxAt=MWGLVz-sxL2ty_6bwL*y%l(
z^9>+yo3UI7lth3j7{MAa0$2!WSj1?ejxkiQ4K<7-K?@ef2cKYAaNFUg(T{h&499@8
zfO7<A0d`0w-%CF`O8o<YnE|FiD$*p~t9xfuE?#}lEI2lj2()!w82~V4(G$CbM!SRo
zw~xLG_f*dWAw<oLz;H|4SpS+42o5OGjPC^K#W0>ildBY909A~mi5d(n62vetXrh7`
z4HzV;U3Zyv?>JqX@EIc<!&!#4{?$3aT7WImdjxA4iEhGL1F(d13@`#I$q2#c_RrsR
zZmXq@R7NC;gH9Z_Ji6ciKMa^sI2ZsB(hOJ|Q^bR`w>rL17PGz;pl_gtaW`qV2(}?K
z7!zhaTCssiN~pzE)ZG|bt^v&&Iw!VCuMKp5YG@e$;~cE9-qBhIYucx?3~Lx{30fye
zS{fl{!|4FcxRUz?fTWbfM0}x+#ep9=eVP@JqE)w;wWx(pTz<gwPAj=981RDEZAX9q
zbku6&nAW#c*5eVYsQ27*FymcB($siZHR2HvhiKYy6zx9PGk70n%9ByXz8Fg$fkhR7
z^e&aN*eA_@Gpo<+WBoMVw<fjg#=<!Vlm2e4gR_7(354yz5pzC`17^Mr3#XohW-^KG
zl@%aFaL$smY^|lDvv$e;hc|u|mYA6Z>XQP1!_hCDgS-E@^?9S!F42HJ_S_#uc_5Su
zs5YV8=8;EdD(d~XBf)i7k@eOjOu}f!6L8G}mPQ{ykK7Z1=*K{C7^dQQG~*hqW*BXt
zwShMNOtkjDYl9@w(22=Uqtnw^7;U{qm`pPmt+<B4;*pr!e=MS)4^v7@aQu=_VoG5t
zlBD7N0$2$ltRVUFzUlh3Z9|b$kru6npPMz$Z`|^{GvK<XPDP_;acIw{5r$Kxf#$xR
zh3_Q}XC=Djnym`8T2&b1&}>!FL;E8XQ{Y&G*#ZExj-eADv1EkRiA9p=HbW9mXn&pE
zx6s<=(T*{$<JG}gLL(Uk0I;*LE=HhAm|i>-anb}*Q^f2@NW}!Ypi#4-44eZ5;wFGR
z2l-#ffa_PC34p;4_~V9Ch1H=Mop@k2T=ZsZ95<RZsyD_F#|>ER2~w$V2Qwf@K~R83
zvJIQ6w*fXxCEOy(CETXcuAvj1GDN3@H|;ZhZ>JU*V<1q%=E-}pVf-!#5kQI%P6I0*
zTLpFk*7~tCJ3&MYqC=<6ZM^c6Z@7>dv20Zp<}9uM?_~fH0U)$$1VND)+d76o^q=A^
zEr^rEHJg*7*_`x*)CPi!7_L8n$2VUEYYnzlmg6rQKZCm73TFhg)~N(r7^9)J_GT#Y
z=E!J+L>qrUGe4>H>r4xD=7=p^O5i)6{5&4r@Eg=y<GArJS780f-3UY(#+WoBQUJ&S
z%mnu)#%mB3V>oNE;R%JeoxjiXN3-XX0XM8Z3x+2kseod+K#}a>@yV^%M}^*#iQp1F
zAst%zV+r1|H5(QIra@x@LRv&YFN9=BDFGr7sAH&E#DX-22b|;do=c^e;n;zlgR|aA
zyY$*QZ{k|5CRq1iVqyY?LIkChclb`g8G$6Wu3oE&%0x0;uh6maSl?4UGb=(U=b9CT
zAAD)W^Fp)dRRgSbAYouM5g5E}`|w<2-3dk;YPD)2(M=f5sbl0cD<y<c04qnKl!OvR
z7^`8eOQkxq>unQcOk3Ku&N5x^1FSJ=M3mZon=-*VILENo0tgU=eUPES)PX*zAoL7o
z=^+bdICcU=mYo}9XOEjc^IkZoMNjft0EE-uvH$-*2E<7n^$EZlD+Y?kfE~ZUXxp14
zEf*&Z@<id33I5DX1hIm%7RDO5j+j0twy`;(?GD#nr*%04thF6sDCaqWO947Cf!P6Y
zU}iXHVXcNW-dw>EgTT(Y7k=$iK(SA|BR=ybI5Z(;@VwCMZ!$sa_=8wT7h@fN5QG4U
zvlvfCab)odtTZ3MLn~IoCYzzuBK6l5SDPdEd-X-eRX!@EFbu5#2NG>lLPR;HL-}yh
z`_wi&MC5}HqLgS1BLC{41#goav%lv!HA~s6mwsoR&nay7yEk7xf5<Xuf;Aomjhn_*
zCL3aM#60xy?b8o`aM@q&8{fYdWN{Lo|LnU_4trrSi4qNfpfKTvF`8`0@YrVb6b5kY
zv>)QejjzT(&AaOVO#?>xa{z!6%4qPn@N-<8|7}ThG@fYqze_s}1$89iq|O`10Jds>
zYaEiem4=mV>361M;_0g=f=i>8)OmJ>lG;J1CPwF4k%DWP#OL>1TN^ShV9rgEXOi~~
zo@v>AmuiBAwT9R;XvwTawOIhrs)H{7(gpbBM@FC!BA{L{Kms92D$+oBAOK+VhGBg7
zc3)5U{+-ADeGFL39|7~7nBW-O`9f^QpHak8ybYhG0{W>$Q)!!B3u9_nx2~CC?^LgC
zw{LpU1qHTp&{+jz9CbniodoVWt?PyotcB^iXFaoWV!JN0<83{suyab>OdC2+=C-z^
z*N%~DOvW?==a`rY)^SNHJ^KfD&w!Ai3aa?hC9_FWO<7cBACBb`&gR+lG2YO;P7w)N
z$40Dvd?O~u8W0k=<ocukHU>P_IuBrh5qCR6NJtRo;Uu{YcZwM}hWjy#XVYoCUvLpd
zn?q7ah~9Dw)-ffue$<-Vr!$MGYy)F7V6=nL-sT&_xx^dO37}>6x)aZ_usS8a%cMPf
zzwKh0F>OY;)b6|VyE8_(G-_&JBaQvN3G>W?H+4=hAT(PCWA*%fj=K_LBQ@Gqt;@M|
z0ZT|@FlvE~(|`wNGT+_rM8!xctgZCX?71^U5PB0x1YCU0k<X0*E6lr5P!R|c3`WdN
zs-PkQM0OPSIDiWVZaOg5&&<*xvAyLvZg|+r%CKS^_oF@@P|{Q(Gb=DjkcWePy%k;y
z(ul}2#ii2CU6G4*nc3*TbzIxA?s(lcEuF8N+k8$DQs?|N=hsN#X#qfhNP?ZDVlfD&
z4whxyAoODsjyrKL(N~^h6a04{gFX;o){Wb+{I+$t;<hLGhqskz@o$*vb>H~j9c;9A
zYgg6?07kd90N`nW-cG@|S^K;O3l@!{FPe@<ToZeQbJ;?&V0u*#7JjNq8@|xO#J`Wa
z74I6>H@;ShX>*$mw_$j6^H?+9E=;4JzVe!A@_?7{ll9hUq1mbgaVweTVAJ>>5RxDy
zfyg`1+@W^8a!MHF63fmz-L`Zicf>A}<lGFUj@fa?dwfZUIIWry0AfJ+N}9C}I&mB~
ziJA>NqK&zoP2oG6*0z51&Nt7Xq#*6oY5hmlvF>Uo>Ti(<_Xtp)F~;ksPsCeiHJgq7
zn$5=R4m)V>q0WihPCt1@ef7GAsEk=IlmzNki#xB|p40kiCCT4D^jduClFfL-Sv@e^
zq6;hk={{Bbz?2dOzty0|8!a3{^g%#iL_dXUZG5(F%43_g;A~0i{de7X?|+~1_Lqu}
z|7ndFoN~|&f4=+SEz(T;R$MDCC9*6F4U%CCGKx{`Arwmi!h%2$3aF4ga|D3|00Km=
zqm;J_I=921Ib{Opzk;3UNYv8Prgq*kOu|TFhq%dTH7uHSz{U}59Kkd~#0`PT>R4;r
z*3qB6=(O->fBDloG%$^<-m+w9!-M}_oKl}V(7!<U$r6DZB8iKLYXz>?8r*DX#7%u#
zqiRa;J8#t~r@W!xW`h%=JMerO17z636<?3BxmLs8J%@;Q_P#|mP2pQLx9yFwYiWt1
z2-pb64sjepH_KeDR;+F%^Cl~mpU+t||D;n6o^w|TFUFroZ$9@$!HJhX{Fh;@9jai>
z>Mb-fJc&3q&`AQ4jHsXxMuey+Q78!%N`#<5P)Z>xNCcroSP&p$2q6&!5-MaMt^Vc|
zPeWE~7&-y0wP4542_uOu;-<%xlGq|?I<y*$xM`qcM%=Q{iGzTG5CTyY(ySS?(Kltv
zy!o@I{`9_^H@^CXujzd&fX3RVhR*39Y|fow`m||{1S4t`&ROW#q1BAhY$j;dH5xT%
z>J|60S##{G0sLlSv?cqe2e#FWpP2z*0cQeKM=O$hoZYsudfZqvbY?RiHsquN31R{S
z0>CNg*igOhM72^+CdV655EMRErtjZ%@l}86Iq1lP-m}kvi!p0H>ql3u3HDgW*t#yn
z)(sXTTY<6dEliBY7#@kytXt?9ND{yq_^zwxbnKYQFtUpAP7eV{38;XeLZDCx5EUhQ
z`T~@D6^gwAJ^dOzQ=dY)M{-|ZKNTkJ85`G@zCy6ewr-p}R9j}CAtu5EK^OvzHZ~P&
zv|0v9lWAf^^R`XRg8}?z+r}m>+`HE&c+bRu=EMLn8`!d8f@lwkiS6ouM!Z2XVnZZ}
zg!InY5u5{zwn$nAjYgtc4ab!+w-}&k-kf6x*RNUKSE+8n)c*Nu!QvU%V{eOMG!^U^
z^=1XFra|0vXw`w*q(;4(pjowO)HLd~1dUpPxMh*F99k`pjQY$u%^949O_Q+9JP83v
zMUYBBDFGFD^A;5(!h-Z#6%nF>M4==R6@+I-Kv03VcSd^?Rj)d7Y^-%mlES^`(fP~X
z`^AHcjk>1VWK1eFkTUTo1_RDGXzjddYd9n=qGp}>?Ju|ouQ_`GKKQD?;zM6O@R=Fl
zbO;b5X+)SoAHa`qeOsYf6CCRVQYe6QZgVrcYP3V#vZz-yRmNighLdVfZ>5U<I3CB?
za1BBTNJStqiZBeIltd6Jgi(Orz6i7D_dzO&PzDe}LI~-70A!j0Gr$Bu<W5?<1kPCx
zys?knGt<NHPTYs8HqU;o^`^*Z-y@_GhdA~oB#9l8mO~PI1~lsi)@oEIW8thE003ij
zhsmS156T>U7AU}H@0rcd5CEg?Gc!Pt!ZA}W!(}(TI#qBn!3=VaL7hz@xpV7?oe3bJ
zdJa5tR(}-sRpORy7`8oOBALjM3<y#ZTEaqzboi7ySN}^6Ll6lFq7)4kAVCl${PS}y
zrnWF}JITu6hztegjQGyw`G$}ExdVd8@F~C~sUI-{#(=D0Xk*6!z*(o*5v*ef#}MR+
z&1rto(KF_QfQ(D&{W#Xo%mB{b&lz{U#Gxz7Xg`QMA`lOBIS~|{khagVmDXAhKM?t*
zC@TmgJkkA`5?o{?<&-Iz6QHM=^z3;A-(F&!@uT9lvH)l^1np23oQAHhouuWskj;`Z
z0XXWKvk+;#4At-0rlD3gtPXlSjVAtcS>)zi_o|!!u`^Dj6v?Eq9p-V)oXiw-F^3s(
zGX_Y(8W2ebDg9`PDDC6-s_6;lnFH5NW$#Km9BhYhfe8eO#59oT7@;ad$pDTmIw`?u
z19cu|KzBaC$g^SR+Cs(-IW&>YlaNb@;PybeXpvLjKQB`Nk&PJuv}<(Jc}K$MQ>Gn|
z$j(4JpIye)lw2u7sf`AlXgf>mCCs`G>9a1yW_B=TopzMlh^Axq!)1v$X<=+~8x#*>
z-jo->B!r2|b{Jy-R_(+sBeLrzen!~LbaDsrokMPDIlX2NOL%&ue{6q$N8;E;CZA#w
zaXtGW05mJzGXFnoKn@VMO;}oV$|Z`snBY<(k#9wosn*!G84wn5zQ5Mn^z?hY4@jTm
z+FIb!=Tn-Mwc<LO%?75Fmf+C6&%xnKUypKO0K*fjvFwST;E7FtK;3LdvCs!4Lohpk
zW`uO;AXo>{J2UW1DA?tu3mx$H*`L^tI?Z91X>{FLJiu_yR&#Cwa5{Qs25|buw&r+a
zojE^m|EX=`vJ8(D3BP!vJblLWa-a&W_FxFPjn3@1OY0pXv$fncA!a}d1?L=MU4hmH
z1LeJN+<~vh{tHh=Pia~%2s5VciBpgLERGs~6PB<3Z#=sGT1+;!BMM6hgJMd2(`B1G
zCAU+_^WY|py4pS^P4t{`%*u!2sbEo;eeC!O-<3yz@6H1}2KFo(&|%a3@0C;vsQnCX
zzb};*4=WJ>mMS1Aq-4&K#Y{ajtx0_W5y<flIhXMEmMyCFF|ZSuGjJFVTJ&1%zwl&)
zLD5SRTL=>E!VDZ{PF;$ZANesHv+rAR|EeqT*t+X5T3LfYMTmlO%4pjaGG=pN&O+S|
zMsyICJZwfp6nV*ZkR4H2Zk*HWP9M^FIM;pe=}?3SQi=9Bog~@tlSH0yWISNUd4!S)
z2{Tyhn4Pu649X_!Z6KweNkh-{b0j<xNhFczCR%YFipp3#<E1!k&(~wg?BgM&$_Y;p
z`S?<*q!Q`-=lXkQ;U$N@7f0@W79L;sCp@s~N^BW>3?N1!?Da?|o37v?^|T#kh>!=~
zUj1WZoFtOH{yC1AWgdBTa-i*yI|7N!S>st4(B@EHIuvcKXb&<Uc`iLJx8G8cn9?`D
z1t89BY^K$jQ)dT|U@(!_B5N>N-H!g^JRGv<H8^ySGcad*R`}*r;$;`%pQgJcQh8vo
zv*;~N$5H#9g~Rtc11pAZ#sjN<i`AR%hBkHdmIvAr+u@WuXP%Ced|(leuY9s0a|*hQ
z25rI0tan$4o;q)KsR`51W`cynyT3dIB84GI2&Rq|%bZ3$T`HVA9m-zCG5f!?`TM&*
z-|U=V+h%4q*UN`vhfww5^b<aX1=Ej4e|b(ub}%ypiDxAI(-;8)36+~BDFYn1$1AY^
z;+JFF_~UqZ&DFT~iC_C{+u7V~WYhEl@4OkwmU=isNP>OpLO^F|o(F{~cf1z(-Y(%2
zIFgPtZS5lWj)P}*sTax1<dhNi=}yc)(yL&W!7?)}w~Q6Uf;vOW&Nw@ByzB_pCa6@#
zF}$A86MEu1ws4M9!vB5kOO$5O)*3JzgdmjE0<3?WFgof{Oz@6A4{4`ffIt;<#s`4_
zOpx04PJ*=))6Q_zYZPFu)qrmVNcs9~3}9HRAxQbClhFWY@j%94?shtv1TdJHN>NZK
z6_m6>1a0l;kd}PHOh`-<{iOw1IQT+b^!>Ns%y%A!>;Lc@z)46U(~gGc42^aj)>#k{
zq*SO^8~DLbzkyTE+zXfe_>0(Q?kSKc!dQdOfFf;8L=g0#RG6NVh#>LU(5>X0>7I92
zMvR=HnWJ{8>B(MgHx#t9k|bmL)J0xB0T3t#$Z?KMba1{SBkYj6Ac$1ZzS*5McNWBv
zI^7xl2jC4SeG?a5a4qI7nTpSU`*k?yBQM2Wci-$WAt6#mSUlU20dUL=DJ1Ik27YtZ
z6?oHm$KaAHK7gZ+J_<kj)-CwgQ@;l3`e97cmY#gLzF){1o#zqG30RuQjV(H)J^Q^|
zxCE3ew0&yl-#U(+hM`ed%sELQ%A%llveNmW?j)Ir*|E)Hrqs-2tfsEP<bz5FdC*=j
z!bRubfV&>J5<kE8LVWsLufQRHd?ns++Q)FjVaI^TOSPaZIqN>0^Tlr|C9HAy{Y_Wm
zSJz&Qr#9b%Lk>I!A9>$ZIPS1hA%wtWWgPXYfeYFhaCd@5I}DR}-Npw)A_}u`)@SBf
zCeUFOoC6R*$*?2(Nyp3G<9-?g-uR-+ap6y2;E_lGBs!em4){nH@zV)p4N&L`gR?9&
zjhHe%r0_yBo&*3`XAr0eFFxu`IO@QE#!bt<k85uJCO&z|OK|w!uftid`VbD-|KOC^
zex;-k!ke1(8VuZW`|t6KtG|ks8*jlr`|O8Lo%tQS_^3Cb5EZ>9u>+An5<56z-;4V+
z3C)tn6uTmcdOXoX5arHbvK_{D<PoVFS!bBpZ&s9pi}b9C7$8Nl0}DbfZJjn8odaMW
zvA8VV_BNY1ZF%DzC)W`@WrPO+A=2!U9m>V2IPJub;JAZdhnw&H4z9oLyZGouSK;XW
z-+;HA@nI}kvZw#7wZ4fLz+aZ#fh&IXpLlfbAF#(>3-G~rei<)1;*A*SpOrI>h;pE@
zv$&r})|o>S?SV3bo#j|c(FO&&61G&xkY&~kcs+I6#Ib+2;SSn7GXwg2r)496ps>M=
zI)J{6xw$lVG9pt{-(^4mEC8FosUyiD+3mnOQBNO9wHYxubs^4t`4@4*p>M)X_kIW0
z-E;-s@$sMIWk;WbH=KSh7A{<jhaSBjm;LZUEPMEO*mIvbIPV>w#><X<8wLmF=M0u<
zk*6~|^#!HQ2qGh@Z-MlGV*=R5Npq4dQ$EJ5OFIiyJHt^2uygF309g8*I*+!Vr6>;o
zN+}=20uVx2fUFPAkcVM;5u`%}DXmsXNdiCuxOz6X9A4QWjN3`Jz5^qCb~|^*zIf{^
zFUE<7zZKWtekrcH;hVT^*_Bv4=TQ9h;Tth9vw#nr_bI&mgnz}%X^XogUW)&DJ$jCa
zb_hSa)S|$*!XWiIl;xzkx8|JaT|&mlg{a+%p9M9~;sg94+Tj$7E=07WD$^DFrbJ@^
zLQ$!dt3y|I$UePy+>!P0(_-UpMx@zo%7}%t55c)-eiyGe;a&LNl^?^hzg~;ePk$rM
zKI@AZoH{QhssWMABf0<S$N~hnBbbx*#B|galp-WawpUTUs<JyAPb*>`z++;^%uafT
zm}kV@W7=tFoDd?X4~aCx$`Gbbsofz=aE_UX5EY^V5rI2805Ubrq^%3YdJcIOrP;7!
z3u85w%sm`0I^th2cX0`?dBr&xoH`H2Bw%(BLOm_xeERpbr<F%_E`x+RahuG%NQ_Nx
zN!J(nD2ULVU}kB47KQ?F#xy4Ux2O37x=WHfX8@^OLWNKoOgc}syJB5`?W;-_j&&+G
z8Ra{Q);l`y^d|4*Z_jiHl4*s`p*q=wP8^I)JY*r|PQ%lk9a#ZCkLNoEL0z>8PgSc0
zr0O1Mra4`5n1OlOrSlwXW4=3LzdM_x5RhpK9)&%1BGf4j>pN?qS?2+zgUudntxx-;
z2)ca*x79vpBA$~1>~JuMgl~&63@NEyxqA+u1%Otofkva|%@lX~HqL!nXVFPW!Oo>E
z8qYB9_MAM(Xmr*vmc4e9e5VZPTpWQk3T~I&IOlYyA8<aLNeAK8ly+#tds+?wbV<<P
z&V~*m{jEnj#m;%P{VL^yONE@2QczM&AtL3gN}#TYrbClE`~rnxBmh9E5C9Ma;d5j_
z<^y1fXoo6X4#e#s#p$43r=8j%;>l6$JpKQBskgK1zm0pelY8Fa2xLiE_7`ioC6%Bo
zLCq`xfE~cb6q;iJfOQh<T28c1?mQC%kS`Geq>3~E(;W$QhLqV%s3Q#Pd=|I0WrxYP
z{m9>^18IQ$_kEnuZjVWCWOEWE(V?pVV488gW)ddnI+4hoJf5?%E5TXT<CFC!0L0q2
zr?=wnb;di_00;;Q`H<HG1APk`V5%dvX<e$85jyKMNQs#){Q`rV+@Tw7esC9){&xE9
zK%T!x3A*x`w!_V8*v^@J`I4`VNq~qcH(fgphw`~F^4}>8qyPXR6fXP4Cm>~aQT~4j
z8T^cv|JtYelpFKR-nQA^<y_lQO@=9&&VlWq*8ZkT-<huK{hN=!gZR!lfVkZ@m<`8y
z=c!Zyfh-{k%3d2B;EVtX7CFx|f6*a~Z9(+fq(l&xqnXLa{^KkZqdvUz%r78N&w&9%
zzHw@g<4#5p29AhqSHXd^FtQs`$i~v)GN{8=b%n6)9Dra<D}|k<-^1rwb)vIE_uL8Z
zp=#r!JgMN=q|sEz*x<p$ASj~{^&{U;$SHyo4N6hntpBqUl+0Qs!2(2z0ofSaNVPx}
z((su){QYbU01HS_K;Pou)4sD_Qe&nTkOo5eu2b3iDsESaIIY)lTF@6^+O<GkyvXwh
zXAp&Dtl#z!esS%E*gmo)ExwblVm*iOhM$8C%Lq?IP%6aQ^(*o9%P&B+K87F&bAYVv
z-yF1VK^yJ2v0=e7)N)?o%ps?vr>q8;*?1Gx4Y8y>s7AOR5*)4CvSmvGFs)m^mjC_2
z(^0QKOGy#{nstk!801$Rf4EeYqKzB0-dRD;S!bQi2;DJ5z%e_c8F7>AI;QmiP>6aM
zP{<h4Ra@>Dw2}f>-}+^|?~^CtC%^tW>h&t5^x5olDZ)IH8OjJRrNZ`+E%^H7pTOB4
zd>L-N`!^^Si@t^+(BX_TEXQM8k?IE=u~JgC^q7X}`E;Wy!Dc{(G*b)iw{X1<uE#l3
zvbq%|6we82leSrJjr>QFST{U2Bp$xAj>lInhY-&J4ZZj7hcNxrSt!yX_njL)g!;Jp
z>g0s@X9!sigGg)J63+QGw8juyExB0>s5)t7qvpPS)G;$3zWJ(ED3zw#vY7_s>hL=q
zrZ@@OOS8egIcv$%`Pj5>3_rg56ZqrpKfxLQ{9e5L#s7k0v6xoT9Au8|WKMYJqMt1{
zl~O`Vh0(F?xcc`$!f&ttE+*@nF=N&M=Jw7(5F$lqvj*f8OUN-Sh7vun7E~w%4Anr=
zto=$BsaTuTUo3}n=9Ef)Pq`#XP}3FY=A^WVS=WpwKODw;-F)t+PY{>?$6a=^au67d
zD0&VWaLq68#@+YbjHm~0*#mbHK=(E)!CB+m-L~3jIdJv)GM*R|wb6c2AMKOX;j*et
zkZ4rRw>Phz_>>b<6#yuyxWBvrf&yf%dU@1}4!a3PSYXUuI2DH;y#%U%8!r3R`|!R`
zy#jx_?YACb71F~U&UK0W4l!1WfcmOfv(>=QfBS8md;ZDz@$Wu|zCn!x4q1qqb9+$g
zZ!gH$5tO1GmOruMdZXE>UGVV_!3igw!xi=B@QK4?YtEmn4FA5>sy(W8^ATfOH&|Ey
z=t%v+7dk_~?U`8<{pFbs0M32Wr6?9kxb5l<&#nRQIsbJ0<k~Co`jbxvgylwaQr7Ad
z*Gi#|8Xep8t}y6(ffR*V>||h!8Pz&|T<hi!0}<Ww!Ec;QcH6A9jSS<I7j}Gjm$mw3
zjTe~|3qepJLrBKlg#(y1cL3YAtj5=W{0>}y%N2P2E8mafjyef|-+GMNnIb?L7UiI1
zfFy}=<E_8NudewPHjl2r?0Hjg@RG$Kk#2j*1cva70kg!aGfU4i;XK(&>Q$4R`fm%d
zeLdXL!=wW9DnY&f`RQ}6x@e!*Lrw1o?)omw`!76^ozqYe$-Va8!*1HR38%h&0bY3Q
z3wNrmJJo<soO30nPXSas4N+J`y;irSo=7Gwy*^3I1wZ@i@)I{t-t*$I#-lG@KYrhd
z!j<3bEN)Q+Cw_79Ur;O;@!_u?0T8va;zoCIz7qmKjv@--mlg@ZPyu7!f<YW~!~#s%
z`|%%_pM~?ka3+>Nat{I(=7_D2kO@LaNTG1co!8*pkG&FK`~JDG;YJ*A=mN}`-3J*m
zWI%rTQa}g-0j2!91V(2Ucsn`+$aisr<G2-TAq0YAf-s0o7?ed6h3bJ7D`7SC=3(ed
zfBsdFVAWHYFNAV-Xu}hDVEr{{ni0J2yhYEQ0RV8<Pk=^g2vd8fA<+rg2DYcKL@E&K
zBQJgrS6bMVnEKG4e~B7otW+SxH9ueN3|F~cYhr%it6()&!TE&5b#xAcyKOil>w<2F
zz(N2Z3n47#FPee<4w;4Z<G0|GUwt(`ebL*oW@sfuy4cP-gNGmcE8cVdY545LZ^d~0
z7!EvaKISZ#3Kcp?#Zbzx&XLkHK}gDp+-^F^>{yQXJ7XL(^U#w+TVe)CAma7wwnA&`
zNEq|A-|fw(op>-#J7IrRDn~F0ZP*45>`>~nSTg+}%$dFiuDo<;r*wYCH0J#OJQcSt
zy8(MI+7HD-8A53M*B9=`8RyO=Ye51bw22vE%&s;S);TO$v?mtru~68!=z`E3;AH*&
zYP?n%H!6h82<s&-yUvEf9r1W)c`sjoz!Hr{g0-u+fE&{=b)X*u3#xF9S-5}MlPLBj
zSiHw96w3-iI<%kHPPjV3#2lB(c3VkT$rOTFU=sqiWHxW!poWJxzIXM|rf==NbgoJ&
zWmD*N*!PgRAf*wg5)N7VZcNmMuzJG{h~o;HRgKHPupICG;^Fw_C!Tq?-RG1?zU4y)
zB2Wb+x``}CPvRC_x>7}nA{zB3uKmd>TzJ`AaMa-k;?_UkDrOJv<tD3R->bK_zCGqG
zS_LkU%CBS;J1kY&ktmtD%F}%AScAn1!`rH8H4Wx0=*Pr(4Xvs`-_#<6wCM`TZ0%Xc
zGcvoL<}P`1$bR{h)*8e`L~=G@3Z`1Es%^t-Rwx;~xY`;XE(e1!PIGm#g`0n~>A8^Z
zS&zRHO5FLeeB0%??zeX$Dg<aYVzF&}l=qmo=ZulD4YyaC8}}ALQwJdhQb{NU01glY
zL4NCkO!D)gwVTYkk~qIQ#c#5w0zg0@Zut&6A%(9Gh&HO*A^!mTl{z_$ZvB6%G1@_(
zfJn{)Y{A8GLyU~Cb&lPu*vRW0wdAIaYwW)J9ET^LScyBX9(`VD_PlP~x_GY{aL#Wp
z>6~Lp5Mj_)1LKZ3X`Rw+)CR1vh9DUz34tQm3ct0m>)7j`{o*_J`~IhWHtD(n@@Liu
z<d?Gw2q_?hf>IJfs&uKV^1Yquf(mfpYqG4sR>4^bYXo%SD_(3%E{<bcYi^f~cvyq@
z?W2_qzbO{V^3DgIvP&1u#>zF1W8SQ#Sn<HN|9uR&>DmYJ(pMhr_w6?cnyrMj9+v}s
zdu(OaS81acCULxf94EpU$AU`~1yd2KUJyrMr@*WL4&ZD`C|1a`X_f#Kh!uzeND4s|
zK!^~6B1joRsRATLkTQax2!sL%5r`rXhX99Qr{J7|(*o8guu~3BS#4X=*qQ+8$AU0?
z%kc2J-wEmyM;vj2tJfdHjVmfR<&b~DPcOaYd866$zIE{}*FTIGzI<QAaRXrxVf)yV
zETt5^rCH+_e)xC4df_V$7_!F9(I%d!Z3{+QkS!vVQxK^sP@)F{8L<LSd@EBXD8MNY
zg&+hV3L!)Ufs_Hl6J2BkM+D-?zn=sDoz63X*#EZ;DT5R~*Mg*bG7N%mPal|lPNg>X
zSQwP#o{JW_&%XCsocNlB*mrOaEXMKhJ<pHy1JAP$=sYg?>S=J!VWPSbjxDB7St7QL
zuB38tx;^Q*vuECT>rYp09eupF+#7IM2&owLAPW0Y2>PH@(RW6BY|`UFWWjJCB1Z&H
zyY$mMK&0y#gdk*#yJbgdwG)G~a8AS67>TZPy<Q{d^j%W%4+#8+R?BQTV826g{{ze9
z_rCauz3Ps);MO~aFj<+vkG}l;|5v45vUxWE+<D_lyx^bq1_1Q-4B)~KU(0JZK7sM-
zR(a3?2SsbvKJ~73LqnzU;TYA4m>TsKTCFNtdIGT-hjvvsZUMqUN&zJUgsK2R0ZCC1
zp(;?IN))ORML~%IRiHvtLaA6rp-@B=MF^t+Dj*2u;JAf2nMAcViqX-n*tBs2#<y8F
zx(VX(ht~bujQNG%U2?(w^`l-gCm0_aXXmv0{hdF+nx{6R5yt>Cmj8MC|07kNe(W+0
z$d2>B{7TH3GaqB46PPl!k3R6`%lVJXzB~Q)yRLm=<*NIqwHlV2bwf$)7i*C4n`{J;
zL=Z`Yp@32fg<=s>f%~VH?+-#XDM(EbLKcM}_Bn-O9lIrsMy+IxL!y&>3*#g<h~orF
zY|;%sEVMQ}(7%vFSrS{etvczD6K3DGX?061-nT~&t=x>+3ui(IzkR{wpI^Sq=(EfJ
zhs>8gdL6#`%d_!+-uDZ9``70J0KzDAK_s|XR#1u%MgltBpTQ)))uh#MXjVDhhMo}x
z7Ol8pbwj>u`8}KOKmH7arD@<0ply@je?RlTrd)mfFK>SA$p;T4NGAjdAMPrTiYf^y
zebf|20x}?k5s_d{65FZ|&KR&O?p=+s%~NpjOCnS^7ZAtIT}pglH~kwcsnS&<?7PF3
z%saXfL{usDDwKK^din#D`xJ^j5{0rvv8+%m`RhW-Uq?m1<&0Dz&wn}4Tl-h-82Y-)
zIGHvDdf}Yobr33!q5y?rgkm{DsT`tM4pA%zC=?aKNJ0hV8PNtl9mDbG-gPq^J2Y#A
zr~W(-7oUGOzWtd8cR6i#+rP5~+AZ3H1AAMg$b_Nrc#dXBB@l%0J6yFGI%XIRSn?eP
zdC`Ozr@!P#Jb1?)bokO^_zT~7w>bTbS2@EKBEdP1Bn0PBgumxA@4T2xe)}9)BAIuB
z`>yAoU4F-Iqsea3fD8i2@b^|SPErX{fj|_c8z~hf3h7zuktp^kL`5&LA_dWe^hEsn
z$Nmbf8IB9+EzII`PP&GcF4?yZLL&v*Sf&}V3R3hl5(o<dVJHwr0zpLScO%`f&r?GP
z{`)5RznKB&z3w~yVJcg7lflAX3WLBCB`gX=MS&m^hzi1+q@qL+Qil}#?<4}g{_nRT
z2z-~p;Pe42B#a6~x+R(4DJzKlcVs3kDhfoAf1V2bcjkSt1c+T07w-JnZ6@doKR6|C
z0|^x6rou7hlNN#?Qz=XYfSBPThP4uGsH=dImzT+xI-PSQC6VtFO{G2ZoBnxtLgdeP
z&VflF2qaw6y{nZ_|9~0*0H1u@4ef0w$rr-g_L@?A?O#=@5kWu*LvJpEP`2S^08(ZP
z$z8htkYJ@0g3z0@sNka=Z*Ed;2nB+W{1%ykfK(#g2O!e`0{tVJAi(4BSu{kj?T+Tu
zv65&z+HB*!AQDiahn7|7!$_HOK&e!D$pNMGUMLY3l;4LmN<SYEf`AZ&loMU5woeg)
zIAbaa`p5JE0C3SyPs8A}Iasu4FZ5uV185>|k;nk!v?nz)7gBm@m5MkF0!SIyT4SR6
z+ViGBn--t;wncE%0#EU+9-Y~5?gPS<iK)Mls;y}v{RbUF2>Q2=9tbG}TKf6@A2H8%
z>^2`zES69#^kHb|N%;0vvVw?h+QdlA;B5aOmu_urvpO*#IYJ;E*ITP%1OTH9KtU?v
z*PgPEWOhzU)d~W|5RQXTLInaUkRG<CboUcSV98#~qyR}YwTb<XFyy#V-@OdjZ5jX<
zpg6OD4}5j80AO`&Rud$F*k!9m2$b7nU(6za7*a`YC1Xyz+WJzlf0zLjihkdqcb#=1
z=Fgu`_dRw4gUo$VAtV(LO9gLc^6HyNB|q~y!aBC>&{{iLudV|?5HV-I<sXg#&4$4b
zzI7pbq9ydgw-6@B;_tPZl)!}&9NKI(kZ)a)AfX^t2q_Cr$+B^dg$(qiGT^3YE|gkV
zSg8QVypB-p3G9F0^c6(K=-b6ou%)NmACyZ2ItUA_RD>`rAPkF$qB07F9z=z*D@46$
z#^V&*;ct_`q_IY9cqHcj8M~GKyEhZ=Db7bweU05~;Tkbz8g3t6MgPu>i~D<L$%0a@
zl~f&^29biK2tr0eDhTZ+LnY(y4i3soNhlJeT>msey<WwM$GsTDf~$>Dp`}_M6@#}p
zXMfV)Gjmp{)C=okM?$bv3W5}@WzneDMI{*#QpBGh-n{vHhaI+`KtbF6j_*gSx_c9W
z-KGIj5=JH-!%=)57S4Ey+p=XuY#)2#8;yGF)x*PEme(qpgc(o)&r$);PznPIt{}8d
zwiw%Ze^OlW?nYeT-o65yW$q~~M%-$`I*lZ0V%4fgU92aBl;S24Brj?tTYeNL6SXib
zik{Md>?ux@g|Jr=gt4x5j}xuaO{4tjB}?}cebXhMwDcWVH#C7;ezj${GGLd((VfRt
zk9-#Q-SPlV*!Ln_bI+U5)Z1lTW81Xb3Xz(2VlkR}Tp{XTq+}==Zd0OL_f1xZZYqaM
z$80m8n72X(f|FK)sZ-~pS{cEdh5fK@9HXNXsMa@O!Mwwz3}Rcbi!oxB&F?QSIIdWj
zx>(6V<gDIYZ;s#h__}2eFCIL`#x*A#HC<S8NE(ECtpOn=e)hFhyNxEh)dbys{Y?M}
zH~jS-aL!_%1*h7_pZbIR*_Yzh8ShE{&{GWm5Ks>aVGmk*5<(bg6N3tnEv$EiVjmlm
zKuU#5Wh;L1&Bp-%AN|S+IN+dtu>8SW;MiEQQXoi>G#VR3kNlOA0hCa%=}ubL{Rw#g
z8>O^z*aor(V1b*ij4|}&n%zkb0KoqRbb1&ct<2Ko0000bbVXQnWMOn=I%9HWVRU5x
zGB7bQEigGPGBQ*!IXW{kIx{jYFgH3dFsPDZ%m4rYC3HntbYx+4WjbwdWNBu305UK!
pF)c7TEipD!FgH3fH###mEigAaFfey&@l*f+002ovPDHLkV1iQC3p)S+

literal 0
HcmV?d00001

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-xxhdpi/ic_launcher.png b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/drawable-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..4df18946442ed763bd52cf3adca31617848656fa
GIT binary patch
literal 19388
zcmV)wK$O3UP)<h;3K|Lk000e1NJLTq0058x0058(1^@s6=SJeV00004XF*Lt006O%
z3;baP00001b5ch_0Itp)=>Px#AY({UO#lFTCIA3{ga82g0001h=l}q9FaQARU;qF*
zm;eA5aGbhPJOBUy24YJ`L;wH)0002_L%V+f000SaNLh0L02dMf02dMgXP?qi002pU
zNkl<Zc-rl~dE6z(RUZ7Ds_wqqyU(iKS}ofW-sKH!>|h&1u(8czNZ4@#f$#wV0)!Ag
z0v`kdaZJA80Et<G!NkOX7mRIe39phYTb3+Kqg^A7W`Eba^ip+B{;00*>b`em&5Y!E
zUqa2Vr|;XhZ+9(EpYxohs)2tf|4`1N(7CR_lTdd#*A@G}sSVM&uD}@-3icHIEogT9
zb{>Rw-DkC7JJ-J|`dnAwG>h+a4T1&`?>~PbW?^0Atb+3d+gG~!HYm6UI6D8r#W>H6
zwno(1UHZ#kb`pT9jweMCgp$4I_j^Yl9Tqx59L1_@ipE2`9YIt*07QrZBrAJ*y<<m)
zxsK2o%*RQV@{W=~I}Pzp`Unz0x-Wg<SM0v$!Jq%t-+b3szbPHts6Q9Y0qDRz7~8FF
zwe$pH5%l`~XyGfr>Z$t<JoMB5>DT`3MX%djE2uvg_2DFw!uERrrpiu}Kng&7(Pi`f
z%{4psj+<Y8lbPH4O4T2|w%1Dz-1L!Sj}Q?6aJik%wP$S#v-t|mIR2%I^7RMM+jqfW
zX?-=LcYN|||AKanUejC2zwyG$=Efg=_u(6RgNRJQ_B7jYPRe$BN*}9KgZl78Tk7k+
z_32mM_}M#_zi`*xEF76veAAw{_WHfO3oFqQfF9gHg#eg!tq>%BfOWY=!RJ}WRO`2o
z1*lMUb-KNH?&zVBdgsT!`NuFndHUV=K5Xy1^CUJ_i+==wl8z4RzOBnn0#H>3{Umz-
zJ8!?|-doh)PR40G9!>P(O27BZe{#*QZ=5VJw-_$~=%T3#W&y^7A}+TCP6c*@eYkbX
zEh#tuyAV{f0OeIzB7&}!V(yLq<hj>g{i5VYjyy87Tbm<1bYOzN_?=_Fp<^s<tY+I@
z^7yioR2WbWM3LL5Kd+ZR@t&=lpZ_&0-_o5kQKS>uwJ*73eyMxn(;qx~m)0aA@M^#l
zYA-dSa!UZjq^Q&D$K91({r>LVgZ{2vbN!{I{$OFD*X#E>z4^IbZ`aD8x3X){UtZ~T
z=NCHNI8iZ+#B9Y&C55I`YJ(>R(A&MQw>;c1o&RzDE8e~}87-YSx<Q8@9;v^3_vYJg
z`}E=WD^j_LOaK%B?78mnFI9FDfWiTZOaaZ3#+)uZblJ7ht8^riBt1U=viPfS{NUz$
zj4g^HlL9q(ytGLGbO!TD@BH%@27_L2Zfh&;n!?7TVIFU+r^(vdxWB$WUf7&WmY4R~
zJyvH+haMjF)>p^L`r1ToZlp9B7s?t=6zSdt7cTYYmXc19TWt(`$<{E}iO}u#<Au%j
zEdG;^zwt*`F1D{Y{P2dXo*2^SZWuoF?%%ur=Q=&jMa~-lQaAv$eOueE>@-KBz)6%`
zL?%f`XV<^)z~5c{yk~##nJ=5XO6y1lb3OWrw_f$@Kla+2{^{Ieygb|}2tW=1y?zw!
z+qcj;`sgqkZRK{fRm98Zsq=pBS6=+|7ro$V*Is(b1y5UET)J@3n_EfZ?tG-<L@Nyu
zz>1N=WLa8FhMS||@e^yS2k(C1;k!O^!|k{I{%?K$P9Ce{EF3M&_w@WqQXD%xOpDx_
zvc8cBdU;mNecPL#f6bN8kH7Dcht}=p#t0AGInnR?{bRonCE#pgHvwb-40Zr`fE_^6
zX4KbPGJODxy@B308AS^}|9j8)(+jUuOLOz{h!fD?{`t}W{I-Ah#XnG*iuw6YL8545
zb6kj^`-bnh{F)#7!LRw+Yp%ZPWxJR5U#h4Fz(BB$9Gl3oCI*?XWWo>-6bLaibxEN^
zG3H34iv)8J5GFR`M^79(aMNvfe)K>5^7}q;+YPIC12DVy4)l1O7vo`}mUeX()=y^9
z$4`9wyN8p_3ywazE{7i2qWAyd+S@<={)4}(6m2ofNdQAQ31qPYK(rG9R1s1D0|3ha
z_B`jsmp$)We|+ITt?cdaU~W#bEY-jK=DWW0k^9yUrxUw=`P1k2zU8;x@Vb{=_w3g%
z&t0$w&@ecHq1<l^948?|8gmq55fK)k(FY*{V~9;Wf)S2@k%J)+u=^(vAm$hgn5Xmf
z0Q({6<Iu^~hyLcnxBRc4dGlYrCm+%J++wo0xt7}B|LE&~_|j+M+a9@pO->x!q8tBa
z^MQB#=X<^<>F9Bu*<%1g_2s$Swk|sjK)%kN2zLR@N3q&t3ZDNbKXUDlKJQiP^>Yh-
z=?}Ve|D78T{_Zb4@N4h-tMB;EXFv6sFNoAGvN$T6@&zvFq>8afJv;?nTmWDm07Ec_
z#RwJ?Fmf1dVhfKV!#cQx58y{vz$Kh43<@a(h<QN!^#U%zB#+FeK6&>Ce(c-d`DZV9
z>D7CF_IIB88xP;V#;Yecap1FC>JNV9(Dw{SoA;U=#{jGW7{RIA)AeJW)4|wjB_yX_
z3axZ{`uuDn3;*gjzv91LaE0uPlO8U(RLiTcdOh`V1yZ@kZs2yMNYOm5Mi-X>h+uFG
zV?2Zu$6+uo8FvJNE(w<d2cxI}<o>V0(>w-PYml3q6?d`Fy+mb``QrG=`_r}6&H43{
zLpgkKNbmdo)wh4<hC~086s-x%aR6Iz(#P|rZ7+TNVC=Ng22dZsQWUHGTI0N3`&O>}
zSO4XLU;e6>@8?SfD=Lu-ctR(XhQczQg%}rsv4$<&g%KVFK<Hu@df0;mOVH?{HlhHa
zzyupu$3qz7cnKJ8{j1fQWdU1(l>5BM1suuZ{64z>zJqk&)^&X3U8@H^{H{lSK2Fp|
zk@F(}Jom}4L%5GGJIx9U!wHoWaBd;#4L1vZ){FP;`{O_Rz8}3{ZwDvjCPmVRp^;j`
zRp{X=Sghd$K7t8Opo1kW;pymMHwfL<rG2Sj0YU<WE(CcgXWS;$Mqo>TFu?2p#DGFX
zDpoYfPhxp@f~P-s3Cf(G+;aWu^47-WWYW=bp4rfkv}2?Xu(SL?K+~_10O;@D*I!;=
zP1SGy{;U7#+uriszqq%5MURowkRC;sc4Gz4LW12`!{=}Up9dkqA}+%sE=7VRxS+Uq
z5B1<^RS(YL90RaOv4s?yurO5>1PW3LLxIDM2*4I#harf#<ECJkf?+Mg8pg``y!5r-
za`o3uw$#0Me(u;kgZWq&Iqw+a9G0B~paytE(BFUl+{&>dqv&sM{qFzp?XQ02cWB;a
zH`EvOQThy4@HDL8D^OsB!}ugJjL^sVn8W$#Vg<U2RP<3tDZ(H=!O`Ri##l#=QAwaF
z01j2UM#O_goDh;q7(v9TGh^KEnVE!!^2`_S`kG5F-`lz2y$3(FxRP|UiQQ5B2iQ3P
zYJ+F6|NOaKM;;yaZhhp3{_sUtKL0BrJwBm6r&n<g_TpJs#AO)bFpl7}h%i7GyU@il
z63ih&7la<1)DZv~1Y-z>U<|<+K`;Shj0v`oVgm+wHL?P#J~K*5QvpUwFiCYxMC!jq
z009W3jLq!+r$o<r<_j*o@&kYR;D?rWCEav~foLa?=qm6@gpLUM`_3EeI(m3C_`=a2
ze#bNRUV8;3k>hkbt>Xdg!ZldLMHu23PT($du?q?@I#?*dlORS91PzNE1``y>U{O@I
zl)I@5X&L0mF@i0vFwcoBZ2gHXm@TZeu-1TWdCW4bwGg%?x%O&I%5w!pX1ORtJ$#q?
z_|JXkr+#p8B{3VT`6_@hoJqf}z0%uV0)>vl4uJmN^9H+)9Uk>QclZbX_?mssxC%(*
z1RbE0xCaZk4D+}EW31yi?m~iP5Hu7z(C9+EzXmB%Y+{5pq}V`?F$$zG$YIOPATNQH
zS9VtY55bW@!m!j*h^16x0u~AOfC!h;NdOSB5$-LROP=$R3!d>e?|k^L=a=G6o;Enq
zwgeBby#drV*L%D6_Et_D9Y;6Z`(1B)*2UL8i=-nP^e7$29q3>e=5Zkm3{K!4D0HCE
zg@r|g9t46MDRPXEVOUC)6butM2y1YJ=DGy77DF1~VG)S+rn>`A1)x*yD<C-#iGZvT
z?l1DCS3h(Ap6mbe&<(x0C^pl?dfNeMy93CZ>fOP7ytJ{F#eedN*Ztf}pZV<9Kzf|g
zP#wb;V8IyR0w^Td#1UlJLX1TeNXy)N4TAy(DGVkhpRo;z0-%DB1aN9Q4#Q(CTuL1&
zEiVrcZUV-Z-v$1miW>>Q%oT_h_sBK7_pWT+a>LOtM6puLVo>{rwq4n-0II_kgpSfQ
zpQm>4uitvzYrp-QUi@QP7A%v|C-DGAIEDl(C15fPaRh`e1O$s5ga`tLK?aKy7N&%N
zqkpwU<wF!LkN}WCiB(dF8C+UdZes{@37T>*ZRx{ciyCycB-s`CK-P%ed!c^m#?j<c
z4?nQJ3V{dEwj|cuF(a`#?M2X?n@<)le%kzn-~G>@|4UjHtffM4;UtDQ3Wf%uQ&Qax
z6zl>I6WKx`1_lNhCde^CfdUp>ZtgrAP-0Vla^Km;cU+#!!VWwffTskAlQbSgD8C1+
z6)+PDW0B?~<V6NyRr-w_&;Wo4P>M7umaqHn<+lh&b90N)5}MhS+p26w2^0oPdyBg|
zOPgz1{LUL+_tr~xUwR=EsT?_mIEt}Zbsl2s!hkU@P9o1z%*(Ton2V4VTbS@MfCyF$
zga9e+&V~<X>K|GG3ddU<c$~DUHZHdcNL)!I<}$Rwz<9EWrRZ8*y!c9V^<JDD-VbXF
zKvbmyYxPFZu^n9bj9n|A`0Jw|?Q}I+BR)fMTS=kq7RqR(fGSPBjgwjO6K{FmH(YVq
zh0ilWER?GpBaH1PjA3XJq-u=9j4>xq$8!h2073+xh<G^rYdnztHahV<gat%^C;}0I
z$it}4g{Sfeqy(0D=b%?fp5JiEbpjBz!Bc`E%{K7Ti{FCt7G3~9{$F{S-~(U$7dX6r
zGZe+{9wjt{gn-zde?|6&=fCXYzr6W|gSTKh(7G*vwCzM9f_$IFUCBIvh1Y%ORX<7S
zOF@~+FhMFq<oN{FFieqQGFb<*Ib75KB><@CE~CJCo!20?7s3<<#<26z7=|?#wy-e9
zI^T?Sdt)rDamP*J&as6%=C=A=Hg$NyZ)}~^G1f^HYb@sD%W>Yq3t%O8^%H@J#cQ7a
zHpH|HVX8=V)d@seYmJwE<J`{xi2C!<Je)Nerpuo5vYh}FN}niBbZ_lgrhfGuFZuT6
z<&|aUnaPkziZma=6gjwH6otVgTf;@2Zz(Sll^KMpw7`Ifmr<C)0WKJ9|Jf9_-b}r(
zfD~-j)*v$8F~|aI#epi2Kz>gWm7VRzo=Abn9lL7p8!*X+U`v&04*^6BwCeNR3Sa%o
zH(vJ2@s>%5s6Er<oR{qcARzGj%q>Q90G6-&N9TVJ+n5dKloc7WY=kr&q9_VCXhvX+
zMNeHkeYNt5UQZu@ur8%V0EQMw!oO?j6iT1+`%sGceZ_g4>SF6a1<_a=KLEp7tD$cE
zyK*s#qJRjMTUm9drIb<{&v;?-LjdCboF1T_Mzk%Y&~^e)MV_Nrb=Qt(`e*<D>%L(y
z*Pk=FL7wHvvI!>XCh~k#4w|=ufX&IHjf)8wL>iB5-GEVcq#Ed20yR}u8%V}F@R-6@
zD$AYE4K?OBwzUeYEwM6W!6|Ni<o7_N;oLg4y1L_zFTxfCYq>J%rDXd81|jC&ynV_G
zUViZlM@|a)sP8!k53qdz<U2zFh!>XQK7izTFW>!b)<nonuJR&9nh%ktn=nP;%wr=k
zmJ!hacO3dt0Dy=yR0s+ilZWt`!@q<?&BGW|T28^hx1~-SL?w8pR9Gp2e5|Y5a{wmG
zl~oq00d70=KXCWazlI`5@CA$_13vWeKR_p*ug({)LL6}Fjua{2887O62LS5ybPv-L
zCeK;fE@pgXc@d#E8QFzbzTwJezv2!1ze`cqvNftODYASE#-tTbfDo7gutKhm;^9LF
zv1k4nNQ+GzIQr+f@$kPzC+WG9DX^|2@ESKf$f31WI|Lh+SFlwevC^`}YLi~XaifSj
zxaY`wap=Td&{)Lk`ceGWAHNyP7q1~nA`nqkHxUI$1h9rF42s-XQhdpsH}ZRo9gnQp
zKB=$U#f+~Abf+72(uu*V-gMsA0tzNCln}$1F$z0zG9FY-7Zd@AEF#szR`R#_%e&qW
zB0>^J=ynz$!eCZ_wa({4j(xaA7+lUzT?Lfpd-<^@B;Yb<qcZFL=0g_}08VP~ct;^K
zqZ2RU*yvNZ@750@9UClOJP*jAtc!B03oa9YNR@tYfQU$G#tUDy^3@-F*ZLnRtrE7J
zqRwDEXJtD8C{$lje?ID^6Vt!w%FZi_T);Xf;R3lCgV}(n_Skq7xgKO_)xpACuk;oQ
zqy!raL#%=bLy>~>$5kq#_AVlLoIQ{N&;Vr^0;Qz#e+viFD~N-M)O<()7KTy@<_Ejc
zPXvWA5DS0^B#!$yKa_&7^D()5lL7>LFV?RH@QzMbbtfYpp{c^oi6q(%00II6y}6#o
z&-=<NF6;DUuPLk*&b8$X*5+jdtL`s1_)>Nul~RFAT=_xqt5Pvo6a?0N2Xe6kp;k3e
zTS6W*Wy+yQ02<U1iP`DYO4XGTsY>zi;0k~wBv6W+$BL!0z#RBYCE+|qM2M4~y+&hh
zx5%hKlLwtMHMXq)q$3rZobj@6IR7~;1~3J&wXl+w<QO$*P-Y`jlS8_JB~*lm2w(-K
zQdW`oHJ1-Bp(%lap=bapltPsXn^tF)G?E%Ho*4VTA<a-OfI#iJ&(_vijZRk+NSo;C
z&s%!h?VlMQBSIu{?)^dA0YDZ1>Gk7exS7#YuAYB>QEWg_p@;yM0uTm~0*C`C<Q_iq
z4`B!<DgPF4(g!LF0H8o5<!RL5KF!Z12&&H#NF>ziYzj!y08*7?Uy}dO>+E7|rESIm
z;3~2YhzN;T?7KL5?(Lt!^;)aAT*%@7Y5;{uP;p1a06GiH$rYv$5M@w`N-iTVc2)ku
z0l|TXLv<EhkR`Z5a3}XM;GU(*LnU#7uR_4Ij!8wVThgcnC=SkH4keTGV%I=)_qHVw
zx3=U|E&+|01xb&e1~07*KbAvr*0Cpi7278ZKws*qkk+|wNfeO?z<j3{?JsP^R#K%(
z*6f3y6#%FPMMVOr_V9X4aLFTxd^$Xp8mqRthysZqA%LW*#!yNJ)GE!Vv^FfXD%CXz
zO`yJq|4l7BgX{UIeCY<TrSHj0A|3O^06L`Lt*|zLPPP1=v^EMppK*C20Yo$QZ6Gz1
z|5_3#ofPWwr=Gt{DHU@bS%HRu0TDrY%2G+7a`TLa%FB^^+KGIUSgqcix(fTQRds1r
z((@<@BvZ(P{Jx>mX7VGH^L(TkOAkqUc|Rv@ecm+JMnOrWMR+&RABdzwG#9l(>u;qL
zDIy{f5oW1pL%PkUhA>*q{&EAT0fJ!PemZ=&acf_lHyK%Z%2mrtAO*07KtserNFY>$
z#!Dfm#<-MDts1chTN^N?G%7`uv(lvcT{xH(j>7m<%e?ohtupJq^(1Hji9^ohe*-Te
zQSmH6kXJ1Z6Ar8j5E2oSEH3osN0ae!)XVgt+(*kR{bbj!x#ZZ9Ew#Bdso31yd`!Fd
z&&k@!Nw%??=5Q;3gxQW~1fsJAP?$YftvMLSI^Ml^E}k27G=!8m2_Tb6W=<R*7FlXc
zP<a3#QUqbK7hS%z;ylcnL<m-D?nBB00QE7{MpP|b+-H_Rp_LrR5oa%Pyh>?FpaxTr
z3Rsl~9HHuRr|}Gl#2iSgN~fU#uBIyVjS-NjQeQe5D@^G2BZ%Z!+SQrgcmRTW>AYla
zp_3$0)LUI0nYGpN+}FJ3+NZqYYo2!DVt=u}F&<7n`k{Ls{?G?L^AHhXu%HJJH5qLc
z6Vy|O{8*e8h|UH;jr0ouajzeDckP<%J@W9H96q!ms28dvxP+(_K(c$^oKDBZWVn_2
z)wonCBRC&xBSjBUvc^TGh*`*ig{nEBrTB4vA#!TVap<!1gU_|Mx(SYub5o$=+C{=a
z4=*6o--o)+`=4sip*}DCTy7MCSITTjQ6*FrlvaGnr2|<#A}~c^N};L&bmtel-K~ub
z&-<$Vmww>C{@4#*cID!$yB*8}1x7fE0t#>X@n>Um^335~cdUK*H-6%?zkTx!58gdk
zh`XcBVzV3<oC%1|)C3Hdt&K&{-L-o#H{8sW>geVF_B-G8n(JPC;j5N+B~OhKT4DgE
zh=yxx=DyE<{?PS5^#kwxi^Go`Jv_hIQJd@8u&j98>BNg!RxJF`PrdOcE`Ij$Z(Z0^
z2y;eJq@c6{DKAAz$wFS*1fSc-Q4{N`>Mg5Z{5f8;p$V2ICkmuT03ez1+0hw4)!AEK
z^_~T8N|2up&9(oB4Nw$>B4bQO1|kKram;t!#Q*jB_kZyZv{oZ)Ih|kZBwHJqyyF8u
z@WWsK>Z|`HV_hr?um}@~PU2pSv4Mh(6q!-hD2z6QZv5cZ@BY8v|CwK#Ta0<QQLF<9
z7xsKo0aQyKLJUD~*WSU>$zvn>)4%*@-}{=czv3sf&SQfDIdWJqPq2mKe1Meckg^L>
zq$_gsM>gO7FTd%3{>O#o4sWhy!}8iat<@e8USaNCdg+ym&-v;%?0VJW9(!Tj0R{^|
zZ=lib#fTG)IF6unZHf^As)}(T@c9Jbn$hejS{+D(rguOZ0oj=V0&3udJcyg*x*g25
zMo{F8G-ae?gLKT8Yysn;!TM2k&lhf5{qV#0uiZ+-2LW0ak&RwIQIm1bfAaAk`1db(
z$<iB7nmf#%=qkN{eYA-4KuGW~K8xe_USyLTS(+kE3z>{_&QqiByt#P)FMj{${-6GQ
zRE)RGI?iByqB8|hwc`59?*8)XiE;AT`+w$bmtER<*;rC*P*6hiY7XZiLKnwyKORj#
zk32OPjYd3~j79Ohe&j%M;D=xP;cx5DaXKEF34mBfYS|iIdd2H5ef9HRcEOuC8=Rl5
zt-$6HAPh@GSlWU_Bj`?s-n?LbF+q0_q0?1}6GD^#Q3Q|@DCPDJP_<)-9;@{&M1}sJ
zT9t($sR38>8mbppV3#$(7BB@+<UpPZ@=P!pS&TLfvXKVo9l-QJrU#qF$a6-PkFk{=
z;o*4efrsus@!yXh8Ge=s8$>i=7QFeVUizBX{<FnjL43lltnAe*bC;om4sr}(q(E*m
zr0E2c$r$Nmf;7#MO>&Hf#*VfMed7nRUwp?~@A|_iQbS{S3yu>#ZYgxS94I8s@xoGP
zuzF%l@4fANe|g`f(aR3<A*&E+rF!VG#s=RHfH1PFuvrf#&tY?`#3&R+!pXw%r~dR?
zuYKFE{>Uxg+v(|fwvZyX{BM8zWncf2mp}JM4t^o#!}n&A78|s&wuU?J{v7fQC^Gl7
z7KO{jQJN4%geX=>x)C}(jc#9|Kd+E<HIhz*xTDbNYIJ*1c}zh^3R)AC0#roR-&)tm
zk|6T$RiT@zgL00$)VWCoqsT3?)FK@l<e5P_F~~EEY+^APTBIZQInPXWzBSI0)Da<y
z6rzOC>vizdE1rq@{tEUiUqqz%vi-Xs{QvIy;ypio?_GyJ*6T-u@u;wuUaNli@S#U!
zW%q*KqyqWm5k!%OQW4lPilRW4WyrG}X=;$A1+vs&GB$cL6yE<7`WFEHyf>$KYn>;7
z1PY&>Ck#LyM4E__&GoGNb#J=rIp<w5_l5(<?=aS;k&7rtu#!Vl2Z}Txt}%ITkxm4o
zp+PnoskIZSMLfCgtN-y8Uwi#~@4aDeF^-ZXUViO&Jncs=8eC;A+J7wi*z(6Px^oT3
z%?L~T1t*WB7*7~!?$+Ef##R;&v&$q@h#FIDECXVF9Ly6_)O;#%0}v5NQA>3No@}XR
zl2%fw4txeeOc-$Uyr9ZiAWExJ3Nn<^u5U^+(&b45Ac2m6G>dS{7e9!>0%2uuLKk0h
zAz(J`rPtzT?!7CziN(gdckf%=+T6GxSu>VsqO(-c=@ig91`(C2(V!>{ilRV~7sxY<
zB4cDJA)9C!Zf)+q;Nsm^9yxsCwh|BRJeMa2K)penjEA|r{PpL*;o!l$F-cc7mDW6w
zqenyr1Pu`aTR~A+<Y|t{B*kQ$V>~ok>jYO^)BDEj--}O9Mn(T6ue|sv$BrF^S-DZ2
zKYuk|_lh^-(91p!lUt0oa%`N;apK4j#~z*F=%F!=KRUtj!zngS=Ga=d7;OTRQI0$n
z*sNSj%&Qg#zO0MC3t&ZH1yCB$0z?rZ?hra1Mt_dbo70$Iim|k-gT-A5<`*N(FUJ_n
zN9gt=DD8Mqk*BzFu$S(+ZGAC`l6}UEC-aNl<>A%@(MbTJk&Z0lB!||jjsuERS(2tO
zC<;cNS)>z-@g}gf#t_&AYY?uu|G3K;tFS22F@QLtrHdXt_#jAus;3zmZn-~Q`ZcJU
zwP13KJTEXA8x%RPxt`+WiR?T818b06a`}0et({oMaC8_OOUEJH1z@1GLDK2s@=LD7
zGp_0(qg6l^5EwU51}IWsJW4SdW*84MOoj%dVUFQehS64rt*s1`VS#jFkfmIymprv7
za=(gLU=bNdh`od&I4J@Es#JARtPm#(QRMbsRd%`>oqmK~U!ymOkaRRUJ&j)9t5A(7
zcIwmmNr~3Y5J^*uY+{h73|j!;4tjl!&Gjwh#TdKx4K6r*XnasdG+-+*1*pgwN-2m~
zC|w7ft6;7b7~}ehErG29M7!)qHv>3)*T<6vpbAJLr4!5cR65o$CarR8h}=?e<no}(
zAflVbYf2EM6LzF}D~BzT4&1tOYHqNwXKQ@~JuaxoPB>|%7+Px(ZQ>Y?xxrHrl+w^D
zLKG#4q8LfsLpNE(+};H7`7vT0Bhejb9YK+*Cj0n*PDs=<;j7#mpj-wfgB1f7H=o{c
z2Fp3P%zyTAF(Psa^yO3@V{8QoYo(krWKa|qMPaHbMR{sVHC(60I&P)FrUNiw4Wr0Y
zWLbtRwO|H1-Dm~Cqfw-~PMwzhT&<8s4hoe87)W6WLNc|I3L^)=X@KZVRTzo$)M*Hj
zh|{;!KC6uDK)f~L=aUEdzi!<8+i%o(XzgTVA>#tp0Hh4GBIt<Ar(Tu3!n)KBG9XGT
zE>l@qrI|(KL9I&vqYD0Zd!>|<loikMnTqZjjrdlTs=>kPW6gPBRXS^!=2|A3g+3r}
zzE|riT2$aF%5@csj8Ww7{32uIDT6I309r>X3DZPE@3zkw_u-RSaX#;xGKJWBO753O
z0#!f)6oq~f3cYjH0F;NS*iq?Z^G^gr1Ec{VVIpCI6{o8q3Zwv~7)mQBWudf!RyEmm
z#1~LXRgOfT|D!4Zc?rV~TvA8*oB7aE*V{+$%Te*kUR4|nfr^+)<3QuMC-hZXhtHKR
z=Z{rRL~q>{1U3=C1hEVjTP|2dC<CKPDT*LLUsi2sA|;HZ_+&dD&Jhj_gfl3o1E8im
z*LNU;n@R3c=Jt9gTr;)7=l!BSR>pKl0YcWWSOZwNC)2t4eN2hLL?CNn;H?(aAfhr|
zwd5;x;57hC%OtNHLbJjcje!U~&_Nt4a2P_+h<{a5p|SX8ur?6;6<w)X>c#Eb5}I1B
zJ=Zd=DQcvMln?8ytjb2aygN)PMZtm9`J~0d>PRIZzTzxmE3OkFjRGOm_@a&}21WZ&
zX;Fw}12DO#6OeN1fy*KG^ALo}m3_SGp>oY1@^UzcRX~ELEO-v6RX1rKtWuI^3`iq?
z$nV>dsRBXSS5<al;B@rK6&@_%cV*jzgZhBL)*1j%T4`b1>g*aEQ==EuI|Lpx_)LRZ
zXRN|X$w6#U=qk&&eyTmnsZs|BdJdI-E}N@dJk^S@2wMeK?g{lRS1zL&ssx5xWy60T
z0L4o;@{+5Tc2#t9mei@;%~KuUNb#T<9_e6^+dy)9Cpb6QDli4N^^0Fsp!AwIh@<&7
zDFxL?{15NpheF6ny(uu&DvVj|<97T!Q2_E)p?YzzI*}_7Jp$EuIuJ;SVBl0Kf!Gw*
zFay>lK@q`q0EnQtw3WQt5+{-TeVuCZ63BzPM7mc4b)*zQjRKHO1FO;f9DMBu-%6E(
z6sqe`D$6Xgizcw@-wAx)v;@EPI+@vt9UZBtQIFu7VVi=y$A*NgbG92f0$&~gRZGHI
z7){~g+`&hoN>qhu4K1&&5J9za4IP(|;DKVN))XjkbqUJp7G*C6mQ<M=RHyz(Ab_aZ
z$&K37e}zJ8#@CH@R0gNC_7$iCGFuY!DoHT_Pdz_A?6*M5wEEE}sGU-65gG<dt*Pq=
z#ab~_lUp8VIdchAB8VBb%qbS~grwDp;ospC5saczP>KPzhHdE6Ab)B@x=pLCTG~+E
zNhPQn^ro&l8i{1oXj`?LBGUe{p=liMy}Ae_O+z9Dk$SK+c~6+<Uu88?&=%iHm*5@6
zI+k+gK$Y!?R+HKxma1XpwH#o%Hj7TLoGE~+hmWn8u=l;rrWR<zk*I!LOAD$3l`PCm
z2rV8D1lMM9s;h#`Y!C%K7)TOo0;PcrY94N3Jme^|Np*d%spveKeK19{g8ry1y09IA
ziYiID1puYWJOdA&KowF2s`?&n3(eQpTDDZBZk`^H&SZ6tk`KG8SStlW_?EpLJ`Ihb
z3ao&jF-mErO8|)v1crn$RD)p>V0hVj@IqN#-`|V-Mprckwnn>Dl0>Qj#bbddtW=01
z)ao;=O!L9Q^x#&yyD3$|z9&UxJ~UDLI`!<?W?dR?I<G>loN<8gtVy&8xXKW0w9*es
z5R+-EHs2_Klp=x!Y{3>11!S|u3`43@iS#npC(xkO?)Bhi(neo9_a|h@GwK^23nkB#
zs%xDe8lkfi*rx8`8{0exE+vpwq^B|gLg{`Au!n&5&-<DB63=*jAYW-~xbWUu<|)9V
zezKc=)ijNTh<q|bEkxQ+Xp>(wrBGXKR32fpq*YkKkVVfBGBcfWZMB5v4J7=3>gLn^
z*QkHkPhnkx8#?fnff@ycDa&{II#ZGo%|2oyXUu_47eJvV5&&ck7jEiF^OR|Q+x$E9
z>xnph4gf`N43$$^+G4)h<EX$O;p~Ty+=dmAM!#0-EL5~@H94#9?E!Ctw4VR&uhX2-
z8eU|U*<BrPrE%BoahwGJlu}v{c)tS<Hmm>J?GyotKrD+rh5PYKmNQA`X!fHB6Ez8F
z=qhhMShXiMJinZEQH8PUaSw@f(6L@e1@WwqIEKk!66n@2alYB1{>ZetkW>Bb8`*gB
zn;>X_Gn5Ga@33>4&g1}O^?b6aYLa-rYJHDZ-%dFyTlMw$KNl)Y0KhGPO;s%$BELdV
z-54Mk;IiXb039jiuIJ475Ph{}681#c3GF94s7LGmvv}C4q-R6PRDh6X9opatpM2j0
zZeAw@LUn2o>#BHFL(_ULNv@9oXiX8dAL+0u;ZqFMk{WgU+`0~I0~K~!Qs`{_KmY(!
zNZ}Vcs3mW0K{XUao2QhY6;+aljAcfUM^p(NFWG7fzPgqV+E$YX;UjCaD_s-&;G6cN
z->7yt;(=VLIEueU^Si0bg_3v*%r$tc2dtE`u5D7czpArPbGB@YTQwf2#*<y$SOlf(
zvh6Z`eB}v{KqUuiRJcW!DluF)hRXVS^%q52yX#roCbDe^G$P>sobvBVtAzKR#R+Ce
zvMFxDEjR@veinF|Kxwk8@L_13*eH!*oElDdfZ0U}b?N#DFIB6@n)mtagIVYhcmSOl
zi9YMO@oY;DR62pHRkh@?Ya~^7l}|YN>(x=osZ}qejDOWXoxW~^CjsqYlg6me7^t?2
zdrThGJhy?#5M+%A{|qUGdf=sXeCki<P%SSjsv$XLW|J#G&jcsCB$G4cK&K0!HuXbc
zY(eekDrm?Qc?+&k^#cJ~l}{77tid3evAkOi%BHXlz0jz9M9qP4-?r6XeUaHI9&O-E
zT{7S)ZL_;Eu7S^?jo-HU9+GnrRGFUsH0DZbOBCrSRDD%fq3o}QC~w}P45pHcGJg3(
z8C8u<ZVQlVity@dH(KonJT%WMqNtoYH96avmP2r1p=LO=Ue3j(a7cr8qC#`Ms6u_Y
zn!S}`zD05yz>(H5sm;AI7~kR}?RM9L-SBZWyR?C)c1S`g0+(hy3pW~iO0zu#ZVSO8
zQcfLc_srufXS2|_<3N@zh2})nl7KW<0mEq`;FVYv$`Gl-pKYK`0k0w90-YZYR9KxE
z&XJ}DXvz2LI!#p6q%`mW&C*Ma-_96SG(mG}H6no_QJ<wt-`Ondb`}_0dbN~j;4gLe
z$0}z*qTSvUY#LH#s$(kJ+ZeSeOSmHCwoZ`^n;j6?+R_kU8WXkJtNv)$J!G71HCtc1
z;XXjqMKQ%wDz)4gqw4diiE(|bq0(mbldFS>wT?uWZ*OU}OQvoS(uo>SWmcWQHu%J8
zN})53#`_ON&IOSQdab3hS~}Q!f17z*0<B$gluH;7oDvddrb@L?c-86D<U~!Mrhjq+
z5*>V3buT?8-ewZ&h9+nMs{wSc+oT1eGEYZl47k5$4Pu1)xboW)NQIKOO~PkVfS_)r
zVKQrhsmBeXv$4Vi0E*0*+UoMpi5q10?|cXw77)ZnHN6#9t%DL0Psd*>e%Tm%K@eRn
zuUn^W)bgZ07W&?*-=C_Htvb&39o6@4fTtmSLbWOt>!1oqp=1qi86?EPcafWw0i~eB
zNhOVdc8eD^)oh~;ej$Y~Gl?$mR~Tyu%>k=2|ETp;1f3d^PXLI@^vohRE=j-9BVmJU
z-_a~7)cOhy+2b9E;q|Eb-OQHCV;pNsuId9-Dz?t^X`gdy?o?HIT5VPn8c0Ef-Po3{
zjl{j+e$`M2AbfVO(L5UtBmj`5rXW(a>TMIaHka||1lOYKztSV^vztyCGN=zs4P<zO
zscxA)NYmF0q{U3}AB+TiT4_+lpbo7|S8A<AbsF_=*&wa9Qa}eqPtED7DnZj~E$pkB
zvz?U$I_uXx*}~e|mI~St^n9JW+iXPLfdU<ACxME<6Ya&lA0~f(Fq^^m?5q^ia6sy9
zIy0{c_;9dh0ID%o?U|s{yo1oJyRU!U3BkCx9=3K{yl#{-{2o5E&EHKY1I^+?ZlWTJ
zplPQKqO%2%<he1_u5j4#t*W(aS*xA$H_TE_wJ1+$q&_tzj<k43*g=)4J+s=?wc2KH
zcuvC#3r94twi>?(rA&BCLPMZYh3V@Azyq2_K^f(%dQ>YFHGVf6bpb!D@fJMHXZ5z9
zv$4Vi1mu~u&XL%1@Xi8E_(#ht?5(h(Fx(LT{<DPHjrH$+CSpAg%w1d><g+Q~n;F&h
z9IPg}4n9cDE2bnxo7aRUc-UdBSsSg(G`pwavS<L)*(NB%J;XF6I@+qdea{wAXO;rB
zpr2K($1G<hfwTs)NnsF7SLQa#!;T2#yo7^NDtC~Ng-r)%n@y9M&2(1@K-M_F%_u54
zG-Ci~bE}zL#UGo+!7Gl0lJ_*#dgGi~9A$bu#bu29sVqvD&v6C1DNs)JlVkK$)<Kv|
z>&~ZD&O`!LH&cp`XU5d4!pn3&w#0f<d{QOewI=NcB3v=d3lMRFrk-`tvYb2-uOv>(
zjP)HxryA+@ghB*>X{n#K3I^b&=mbBk9+2vpk*U6zImj|=G^=Y909z%?&};#~Qm>mF
z*2mw>k3p%Ti{S9AaemBlR?&E+71A`fp$$JpPTM>pRAJ4U5&#srwP8Y7WuAv8PpQFr
zK?nb&lb=u3N(U91Q32oUG`nJcP(vTo%qP1=mS+Mothh{rsr>^98d3SUyn^ztMVQey
z%}|CkfLTku%8__R1R6L?4x|)GmKJtuFdoahS|cB`ds|#I-dk=#Cs4_CDpD%$QLFTQ
z`I0$5MpF`}&Gm7LN>(Sg2IDb$V=60hMw=T}8n?jMQ1fjf-q3H>|5Ak{nu4vZQ(F&$
z>r?XeC}s@8<1S|<frtosW-R&n?>;BFU6lq_Li3~UW#ve;6os8RQ(H>u5x$KFfO{u~
zs!tM7ouSz75#M_au@-c6ICq{}bqu8}!u!>it}fRCOL*A*Os3Rg<IJ$`Qw^Y?Cpmn9
zBSOhtT_Ysfjj<8$NNkhn(<*00qDhftlfpupsjJPWPa4m|l#ix0hSKQW8T_C{G#mb*
zHsP%+(G=2+Yn=MKrsN1F8@9((nmI_J1?2A`?fQk+uYTK>%B|ao@1Lec5G;Gt><2Ve
ze^>`^)q4rleq0`JIjeLIMTE&XH;&FyBZ}Ib0^FS4*#t#Jb_f8hu`-pQ)@t5N-XOub
z!KFiIWnF{WKR#8Qt0@FzCYYKks<rwC>JgUq6XAFASax(}oDdOt<tO!vrzMbZ?*D4R
zhOiIYf<^?EB@Y_>Wm93L6+n^|g(Xn^a=@CcwmP=ywdFw2h)5L+v+UR9m>$GRfCtuA
zm{8yL-Asd_<~OrJG~<OU;q|C)UL(vj#gUqXx;2e^O4^02i)H%ujeURs&w)Y}Ri*w0
zq9<Hb%4>xRU`<bSvl)-0oRtJ}LCxHXkgY1~b*ry1rr(KGb#XZfuQai%e(>)XtmSOo
zO;bvwrE=<y3hwzOx~2iJnb$*2P1<U*MTFZP@L6G%3JHSQQctGu6?`ri!>c?SwL#J7
zl$Nw_XoLEE;qpyA=Y#{fakc>2>glZ-@8eT$&y`hGPNzM^s1~_#Z__Kk5B)(7Y_0pW
zF45?0ZVqJCZxR5r%}dZ!Pu1S%^t8vQHFhBns?=F<oqEzEH6-wq!@MPis~XjMikZ1+
z++TPqQ=wU@rlxXhcT0-KLVGg?<uS_HrL;N#8MY|UoF-QdP&>%!-|U9~M1gjwU=rpH
zg(5lpjenZLfp4@vcrs`Dr%u&Vfs|-SqVV@KdV2b0ENI<Cs^xE_b?xxF9$(>cDJK;$
zivh#{FeFse+@`#hUn#bdK+Wk*zMj4hY=JG;t>H3MkH4Jh@-B|Vxm17xLV2Zs!%8<A
z(B2S80s#vQ2+Sx9k>YwFn(wVRRrW#+KWPBZtI~QPX8byU?v%&2MX<vKFPo~RiK^hC
z58B$SPrE(Ts#fTea?A0?aI4$F0Fc$A{6)9gyk`I{HOS$Gn|*IBizx`B4ZhD+Ny3+`
zJgETkO=NKZ%8DGDAVnfhLexoxZr@x(8I8~G_11)RY*%#z2E@iu4}e?x*1gPG8aHky
z(9h&Kg68uSoD`}vzm85*lC&vBc}_4jxX~Gb=m<HUKjs%bZ(6Cf<eXB4tuO=th*eP3
z0U#DY9(R=7eEq{8<a8;Yj4fNEVR8*&4dDpx1=x}M+bS@-t;m6N%-CE{DIM{lyYD!9
zbEl`R$mzW&>`Va^Hp`BOc@Dtbf5+y>#B@;PR@iX;+G<;Nx`YdEmy2r~L7rKRhX(m5
z*}DI(V|R9v!~!s#WFT61pi~SO?wL~PGdW+V0vcO`yR=S1>!jAL+L8u9Wh1xOFKSDj
zP<qXrS{wpo2A>K~Vpb3oU?v8T3)5(0c>KhJx2s>vMzJm?Ju}z2Od{Hch;}2QUC`JC
zO)CH|gY$XhlP<<vk&HH!B_wp`P1(N##N;WDahflh^W{u~sRDrWtjLnCrvLsQZ+OS|
z{hMpPd1G?C)9cM^kpi`k!o3>FE#*(J1)<0Zqb)*_C3ZZ@_3EMM_bkR+BAo<466p>P
zy31h7L8Kd<JT*D6s#54hm>o0?!ys+aTF(y)ymDbz2Ar(@DyW&f$A6qbup7O2iXLu&
z9&Q2h;noC19Rv3!8>^J!Pki*YzlDA(p7z4w&vug`_V2lZRRk~!VzDqq0g)WJNyTPE
zkciR|+gm<7{P6>~AG(8xh9cr$cX`@8NI%{aTV3h9Ua^Hrv$5iI;r8Wy`Wr@DDbIJV
z6mXxi5il7u(ve_16ih~h$xtI3CSr@2N5i4sJkovlXFl=3A1bYE6l-e=tH1u6ulwe1
zcRpekGCTsv)T`0MN9*eplJH$$;oo(2AFC;k=hzI%;ISsthu!&YebxTHMRh`}t^DlY
zpTWkx1|c11$S2Xshwk3^-#SvMH9XW>@k95YIQYoj@}ZUevWugQOQIyw-OhkI$$%oA
zkcg1s38m@K9DZ=~1MmLb2Y>d_hfm%^pbZh(05C@VzSPqyXC;9E<RUUAqOBW0e%t3y
z9(&4neZ@<oe}8av=fx}Ym!aQ%ifAb~GbvySFblyNRTM)SkB8>u!^vAe_vr`zLPx5w
zh9`=s2SAIkQ7Y>C+0M1kv5a;30V1jltyyaWIXw80qK3=A+6M<3nUO)N$t>_Rq)7mR
z5Ij>>RZC3~WO_c0G_N=9Z<3-M>=eMrS{^B-`l~0`%sYPT<j;4z-F?q|@xf~@ynNw`
zxy9~oVer;QcH-dO>j!TA<dHk9H7DXkS+=w$BAX?6!q;3r=_<@OhvD?*L`0NQga;oy
zc<;S;tM7j9i!XlZ_~QFt8+Y!1YLavZieiWWrm!ZRnETg{+3Rop#Ie81i^-bSYGU2H
zI+@%|%Z`ZH#-ddaRO=r$)Js!!`FFy%f7%%2aIiv^g*H$;2%1stsorgq-C5rU7Fa8c
z)gtU6@R}E{V}2?JV2P-Jd(*OI=9C%ZIMD;4BERt?4<EkqBlvK;mfgNKROnHW+hO_J
z6s0=EX#&TWCjvkK+<Y$1rARuoc*`g6{}4Wjk0|u#mv?oSJ3Z<aIT!1z*=AwJ>i~)<
zCPSn)t>qEi6QC7Q7eL0AGab`3%PB>XlQi|T8B$He_(2b)QiC`(_|FufngWMB&hJj;
zYx0PvveQBfwH>9ONumWIr}Ko@z)7OKJf0T09Ro;+5G$o3rAd{(Bes@{bZq_kdHLJ$
zHQ%Q#eSouH-X#PP11R#$rbN_>6Ws%)leLZUNnUj+K9MF)IyyInOiaNkAZghc0g#9w
z2asi{SsQd|pUatXZ#-61r)so^Jsb#6hU+1le!|-(H4rRRITI<<xivFYSnG2r>8kUq
z^TK#pE!tc>%t!CTx%VV2LTu<5+~mR#L|pDO09pjvT2|IJl18`$OSqkp_c<(QJ2TZk
zRNe%%aJ*=eXC^AIuK|!)NMVKDOBWGt<?CiZSyto#?4u8_-FnsX?yDuxF~R^VKncp1
zuDI?N&vD9RvU(E7ENL^tk_*Xj%MTMONcTBh17POmt1w0FtE!1q(^u7WHidKX1%TKp
zUk4C?Eku|o8>`y^fGvCJ;ek-~V{7ww3^#5aKjU&HR@h?!$~VM=BZqq`(qPL_i_p;f
zN!D_tBbq;XWW4_D7hLv+wAkXp43$U@ke`uCe)eId%7S_04eW%+rpv6E8mF4Q5wvjT
zblGy(5@9nuRSoB1!@KQNP3dB)-z8=ZU<$!xT!=7bpM2lyuc{;;StFaM`AcYi`*8@j
z@SHPV%4JqL>lMmcl?fYQ(0mGJofj78VU6STz!x95_sGK=H+Pqk=NFlVC<Uc0L<_X8
z4J)^zJxUW_DnHNkErZ3SFuO+XXSFm#=m>25C^$AtZME$5TG#|lZ=3L_`HwKe8g`D>
zoROsl>6nGZsA9bE7r8yS9+4iGk~}28;r>+lj!y_^!tz8)pmrq%vqk5r#3lhy##luP
z{gX$=4_@=!i@$L^9$8~k#cWZ}4Xe3L6(*qIGd#%-u|l(JIo0L0t>4U&XeGJLGVvR(
zpR%3}^S-v~d`@)r>Ps%8<3>>Aj4WkjsYQ{yKvxnEM(_W_M}JNy#n2SI4rfJ$&cAa~
zo(urB%j0GE9vMn26&*XeI@-T)-(+Qf?}ek$mKCsaZ~P+&tMc8U?y61&xWB7Z2@iy_
z2GWpBUZylT4Sfl9Hx<xrfGc=O+!SD_3~Z9Czqr?2Iz}ikmS75?$N`f9MJ_Ofz`B%Y
z+wFDqou9V<=Fq{T_XyJ}fFYdv3g>j4lk(*N(BmmhlU;<8PTcwYXYRZA>Ze_?yE7+O
zk4BpoP!2>wAS6)Kae+ft<$#o%Ex}Z7Tv~HADGdfyYQ9-T@Wlbp4Zf=WM)_JZ|K3;k
zGCdXiUYF<B8=y+SYgixDv~Dv-!CC?vf;HqqJqEDWOE9tBUZf8l(EsHVAHL^rbfmVJ
zWdlz7<T%S|$xlStE&%eS0+O{Xoo?K@`4e~Fbmdi74(68CwWHBG3oEb)i3JpO5UD=2
z>VXgg62ZNw#YLoDs)HLmumW2rz1XS}bRqD{0WbG{&>^b6j%WzGznP=ze&7fq?*1e(
zAaPlr7$h---DgPT>cvqN9cM!&pj_14XO}B&rQ1*ReV@Z`eB`eV{O>4IBWrjSzz9v}
z-#<v8vb3qKSi>gi#GPAjyzlb~_S|>jWxKA+&1R>_En6cng(Yx=SkIMPABqwvByIo^
zLm>i@OKSi$2o7Kn_cuzZ0ns362Ld<`1W^Q(*8yS>#ZK}efl>*G{1&@o6oab!M^zmN
zC74+|5S9RCt4gp%AkrW(3l$P4qQrELeDr^<{_D?u^1)9;ks2BYo*|qi>s8k|1y6g>
zwnOpyL<2|w^Z?Aov0i53#Ypv5UjJRs`u_R7Td&T{h7tx8MM#nX<_5bl-(Nw}>4HeW
zV!%>>#X!VD;5N@W!zfhf3h+d{3f7XU_oW+wyeomc#3)sqx89^qyKSbiFs$W9wkESd
zVN$l7lF|iPLz4&Z$p7?xfAYmYixZl##hSIejv72|@9{Ywu<cet5XAtx00u;~5XEYD
zk=uTxyBEFb%`f=A{_gebtZWGj$QnSaE(X12%n$Zp&|gFx#{dLY3Rs($pfYeTr(yUk
z&dP7(XLk5#f4Mn8sq$~-Hh4hQzzS!ggy9Nz(CwHltTiZX3Tsj@O&~BBZ<%8UKD+hj
zH@xS84_nSp#);1I%&x%!$E&T-bU)|d0iHNN&=XmF$JpR+77<(I*2ZzPrzq0nW<0o4
zCf)1qz5hY1?485nN*BGpfN2eD!*#4}#fYOh^g2uEbr#S`21uf)6cP-}PBK|BkoH??
zOTUqmH6=hwFewipB9KyW@m~cMf-6{IO_*W0fH4`2O~I6cbqe8$j3*;H{s@2WvwwH=
zy?5X7=&eN9j5~V5h1$q7JA{jS`EXB|@U<<#18h$K0ZkA!-0#-f2!M_fWW6~+N5GMT
zTR3>n2BKJFak+<;Jp(K(5mY>eQ4?(DM}SO$5JOW3TK5p^E~2P|SSQd?1g#?>r9~-4
zq4ZJ8gT)_HwWHhT8bcuBBpQn?rCbgx87xv1oFXeG7;X-+zBa__u`xDI7LtxEJ$hep
z!$bESzrEAdn|a13^3?hiix4<x74UpA%XS42P<K@5)lLDL05Ty(lenYM8)%6Wq9SLQ
zT(Ge=!O5dzh!CP!q1%tqA0+6{#Td*d=ni5eNrWiY(2<5#x+XrNNKpi(bYt_XODP3`
zMI3jawF2Nl!?4!C6b406AWJihhAD;{V+^-ajE6ZUqZ~!<!c{to5a|d>S0U->0>E09
z+T#G$P^&A?b<R5A`DB*u3?QHhqA<o*M6u$yBk1-tiin^!q0oXTc1ile&aYx}!Frlu
z^;j0H%Pb%WNNZ>fBwYdW#k<Bs`|)mH(_lW1dvkG@h+qmfBBG;6^@hU<o_gieo_+A}
z%@>VEBj>X*3}Y<V`m6w_#*|jjT0?7s(r{8P^6P1PvJH@;6u^jxMj|rCw1;`yNu984
zcK`v+xOo*05#~JZD0FRHc{J2*8~)k1w=5%3Vk|Kfvn0z9gVAJ2_N^qwPqrCj%)H2w
zk!qyZI<k$(zDBZSi^MBhNVY6lOG*^7mv6l9`TqFM`ObOH^PKZs*L^?txu0{Mzpm%n
zKJv(}ibtV0e{BXWT$%aTRE2zLOvRxp#E7aR0V#FVPew}CfV?vuFKVSKZ#)o(J^+2|
zEL>ijW%hfEHlL-3YVh*a<~C%@imdWk8nGHR_I-HWlp;NjAiJxEU~R*$5~f7;^P(2J
z72b@QANR5V=#{f!=b_SFf~F3J<xw&GXt54~o?tONH08dR5`zX&O#_e?C_tniYgJAG
z%J6T~crvlf)YUz4=&=Ho#}dC_xkk8Xm^?o}J~h**L1$_++@zSpORkD(g=&46XY3%U
zGr4Z9d{UPOgDEpkQTogf=@JxE!6L8VfpkuWdz(a5E_dQsN6YvN&Y#VvI2-72z>jl8
z>>iEoQEU_6IQlwMm70IIpSz#?ICq7Mi*3o-6eTaa2v;Y6ef`3mXcw>iSN_$v!i^>f
zpsL?kbuwTpF<d|7oHxsFH8W%7m&ILWpL1I74o@Kz%Zq5pfpOQ74SRf!t7Nx45Ll}C
zdCpMdmO^#Jn<r5(4K1d|drF1`@j76>t$?&$6s}AR8^@REY7xyEjUJeWtOz*|9vDNm
z{Q$c-it&%!+zf)bdF(mga=(rojI1Laa`FW#c+i}JYL*#Ue{rRrebA#AmU`w7V_HUW
zeN>Mmf5X;i!NG94^)@UjPES^zExk#!0ZYx-;YH%7j02=FcDe`QHtgIl4D$Y#%u_H(
zAc>@N*eRvOD8V?Hyi5u}sXQFi>QK5ifxthsc4^6ajU)dF;ksgC;iB?Quh$up+Yyip
zvuC*TR7`x>O6*y)e?q?H&Qo7!V0h>dZuHT)(GWmY=rKc~6m%|Q#{B5Hs(LS}Gg$2z
z17e`{N@^vMHeWk%Zs+mQ@N9HG^zwO8b_?6Yl#f_}iGx5?j&pGK$%dO`e#Fcdb;^<r
z>P_Jy7SJK2jiU!knKJEj{j^=?{gvP|zIJvmGaJ0LZxHyP_fX1pA@O9_3lbg=%Mk^K
zW*p@fimf@VROqZ(D_=gb4Id%i6Fg;-h)7T6mU1_)&D2B7&D9VNZopQ2NCT5QwHT;v
z(|G4<%4!!2@%?=y=P}Wm000|`nxU4M`&!TBn=dk|<5;I9j~_J0C(jyyo5qQ=?kDFY
z?R9vtJv!p~7U`|c3OyEFmML*0LCpx0P_3e}2%+5UZSy-AdCMLrXP}LDDyh<OHd68I
zE^~TC<`n7VhwWKC3wb^X69!}+{~gocs5!5KnC_0jC8%9Z_S)l|cpU0F+_3*a8k6GZ
zS>a>85a4R%Z4u&ADo&S|{Y(7wNXbcJw`pQjTlrHaca&@UB^Bs`VjrX{C|5*}BN9Jp
zZAZA}kbQq7nJE-~e?5wKtYlFGu(OrxJ#VExD94{4ul(-kqD`uCg?LX(>cN6}#}i(0
z^aZ_4UgZ_v(nsVErq|eaTwqyN^<*4ZItNalbe>-g*ib~oT$G;R@oHaeKc*bBZ)ea}
zYW}yA{RL*1?S>FbkSlfQU{e~ipSzPZRf6#r5QQdj6ghheMs(`d4dn+EaarHhjxqaf
zgTK#U`KZ!o<{xeyk1?^-5sn!T8EV{d*Cf}6>wMLch)9nG5@2#ok2Iw;3&#?;-$`a+
zS57={KkD>x<IS}|F$Tj;2*6$>Z%Gj?X2eFvXQEL@&RbxuI4exUv~R+`pG^&mZO*qT
z)><ijJ$ySMZn3amS2=i8T~`!SH@Un*tRMg7g|0Ei=;+42tSq=(mGjKE*j^4>9F+qV
z?dP36KYkDx;wZ@4QXZ<dI<omn`QZ3WaJ*P=5Ot0ftIsGEx5HFG-r>n9Y+aL}Nwh*&
z+(Z2&YR!csV*&aP*q?uWdZ=g>YvAI>hetp3$+>swRcesoi$dOwviQ?`FAo%}*Yjg7
z6PNUZr-W|nXHsi#n!jEzU&>Srh!{S++~lu!Qvbc|8ntLF1s3-}A=U4b^xY$P6}FPH
z|A;e=k<0Jg)n^q2ixV*sz&$GbsjwXnc!Vg8`4o08Fu!S3%$ue7d@8Li*L67)wE7db
zd~GOpeQ)-aAFZid2BtVSPZT&IqJedXbwIyhtPW$(Bv9p8Z4#r1$7pi$uM$X?rVJQM
zV_oa1LfxV<`^LlT5BP@<IV@dMd(qK!4{lO_Do1-seqk-4<BVb!2f7=WSdwnc(xIXQ
z8Oi$0J93(yFYOC5->NNd<#Dy9Q>i|J>q5s_Z;evts}~i4tr?65cmC?;$c?u}>QAdT
zGBl2LncX;1kXfE^TF_4+azantNH~Mna^QB74AjNb*g7ro>E7xVJnVPjZT%8);ytsc
zA>M5jp<;l$&|IhEu~69d=3sAnXhC0oQ_z;+<+RBg+Dn%GQaQs}xXSuSlD|yW8$I_4
zKGWOpecVh3KXvcc8AQCKXPY;s%}G_}UiKv6=zJqiK*q`dLxe~q&Iw1*^@FEB-YAN%
z#%(08A%}IcAuTTyxnQqMv4LU>Ix&M7aTDfYh0*a#y1y5MrT4nW3|7AvG3|{#op5JB
zZI&qN>r<4>f!N;berv<2ms@HsBoR_^iGPn@fxq7P^G8not6xh=Ye_t&x%!FL9>GS>
zr@MC_UbJZb<<h#^>3X42quWNGPSke#Ud{_<9+s`?1JLBvPKmrU`#Y>;-|WyIGzYzl
z;bzz6w(l5Tms|MrlW3O<tl(Mui)yCUFmB^R_}7@A>)Q&#VcK^Fqn(D{_wZ&wHb#@$
zCbd+T$M~v5g4Xbf?>C!;f?T)T9V(l@?3&GAu71)SY}jfbs~m7x9)s>yDpS^6YMoyv
zXoY=t*$C?!neh<+TJvI2HBycBQ9gCPk^Pixp?98{Pw@sOP}kfO$DZ<2#eX`eH-s&<
z7qq<nZ2|vsSm$b{ax6qx+EF)cek%Ydd^hNHZ<MAzbr<>CaL#PJo-Zexx~6xkH{GZw
zCc!5lphQbH2*&madGEpUZ|CTwUK>rjR96lPv&e-DaW<|`ZT@urL0eCP-AWd80b26&
zcAyI%rM_P2Msh+;9WHW$A)Z|y|6q_iYn(pql!xBlIKSIcYd?`+))d(>R4u{5w9Y;4
z<T)4OW9{i(*<bg~GvofkmBo%3zEjeD<XA>&Bt2fIA@#Y2*7aTLFjCb4jC7^TU4m2}
zv>h1UNRQ)v7kg>x-1p5lBi+X@nfG(4jPESBs~Apa(7&aNT%}Bkyik2o34dHIUH{YL
z**g{8V;Hxi7PUs+j-F~we5@_#o5rAEz2<cYt(R!`TOaVU50xo%DRLbAF3_-C-kQC3
zQ@t15+TqRV@|m10qmQY7+ymg(g;i_Ux}UTCnGR4*9I3``M3CYJ{JVJVE$`btN$vw!
zH!29A5J(gpp$SK#phyH-LkEq}`m{$aXLFA4b3E7_G=T#Cm#T))R70X{|D__e)eu@}
z1fqP$RrY@Zi2felo+1C_{=Weeh4XprfQbDQ&U*WS0NgGRqy)k#{_Y@!8t6|Vz_I=W
z8WAK>1K|$-6koV00aV*BgQynhM)C;qCV0UO0|P;7pn4D+rcyu<PVgrZ{Yh{`GTD^i
zPhuwn1Jwd41h_ZB)z6JaB6xumS2r@*&zs;z_4X&JyZeD8kC!<#A$BDK|5QR@cM3ot
zP>zmRw(k`H+26EglR%2C_dcS5K7~}*L_rV_*p^v<@IGuq07)S5&#aC>Abr0Kbg?0k
fedym91iL@%p^iY2K86jjF~HQs0{hVDO4NS<0ONux

literal 0
HcmV?d00001

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment.xml
new file mode 100644
index 0000000000..0fc012b481
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <TextView
+        android:id="@android:id/text1"
+        android:layout_centerInParent="true"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content" />
+
+</RelativeLayout>
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/sample_activity.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/sample_activity.xml
new file mode 100644
index 0000000000..5900d1d74e
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/sample_activity.xml
@@ -0,0 +1,14 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.netflix.rxjava.android.samples.SampleFragmentActivity">
+
+    <fragment
+        android:tag="retained_fragment"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:name="com.netflix.rxjava.android.samples.RetainedFragment"
+        tools:layout="@layout/retained_fragment" />
+
+</RelativeLayout>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values-w820dp/dimens.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values-w820dp/dimens.xml
new file mode 100644
index 0000000000..63fc816444
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values-w820dp/dimens.xml
@@ -0,0 +1,6 @@
+<resources>
+    <!-- Example customization of dimensions originally defined in res/values/dimens.xml
+         (such as screen margins) for screens with more than 820dp of available width. This
+         would include 7" and 10" devices in landscape (~960dp and ~1280dp respectively). -->
+    <dimen name="activity_horizontal_margin">64dp</dimen>
+</resources>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/dimens.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/dimens.xml
new file mode 100644
index 0000000000..a0171a705d
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/dimens.xml
@@ -0,0 +1,6 @@
+<resources>
+    <!-- Default screen margins, per the Android Design guidelines. -->
+    <dimen name="activity_horizontal_margin">16dp</dimen>
+    <dimen name="activity_vertical_margin">16dp</dimen>
+
+    </resources>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/strings.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/strings.xml
new file mode 100644
index 0000000000..79ce6bb997
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/strings.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_name">RxJava Android Samples</string>
+    <string name="title_activity_retained_fragment">RetainedFragmentActivity</string>
+    <string name="hello_world">Hello world!</string>
+    <string name="action_settings">Settings</string>
+
+</resources>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/styles.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/styles.xml
new file mode 100644
index 0000000000..b07e679474
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/values/styles.xml
@@ -0,0 +1,12 @@
+<resources>
+
+    <style name="AppTheme" parent="android:Theme.Holo.Light">
+        <item name="android:textViewStyle">@style/TextViewStyle</item>
+
+    </style>
+
+    <style name="TextViewStyle" parent="android:Widget.TextView">
+        <item name="android:textAppearance">@android:style/TextAppearance.DeviceDefault.Large</item>
+    </style>
+
+</resources>
diff --git a/rxjava-contrib/rxjava-android-samples/settings.gradle b/rxjava-contrib/rxjava-android-samples/settings.gradle
new file mode 100644
index 0000000000..f3a182b826
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/settings.gradle
@@ -0,0 +1 @@
+include ':samples'
diff --git a/settings.gradle b/settings.gradle
index 5be4134cef..3a1052e1b1 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -7,6 +7,7 @@ include 'rxjava-core', \
 'language-adaptors:rxjava-kotlin', \
 'rxjava-contrib:rxjava-swing', \
 'rxjava-contrib:rxjava-android', \
+'rxjava-contrib:rxjava-android-samples-build-wrapper', \
 'rxjava-contrib:rxjava-apache-http', \
 'rxjava-contrib:rxjava-string', \
 'rxjava-contrib:rxjava-debug', \

From de3184475b48efabb99aea51b4b015b9ecab2f2f Mon Sep 17 00:00:00 2001
From: headinthebox <emeijer@applied-duality.com>
Date: Wed, 26 Feb 2014 18:53:19 -0800
Subject: [PATCH 063/422] Implemented Skip using Lift in Observable and
 OperatorSkip Deleted non-time part from OperationSkip Moved tests to
 OperatorSkipTest

---
 rxjava-core/src/main/java/rx/Observable.java  | 84 +------------------
 .../main/java/rx/operators/OperationSkip.java | 75 -----------------
 .../main/java/rx/operators/OperatorMap.java   |  1 +
 .../main/java/rx/operators/OperatorSkip.java  | 49 +++++++++++
 .../java/rx/operators/OperationSkipTest.java  | 31 -------
 .../java/rx/operators/OperatorSkipTest.java   | 40 +++++++++
 6 files changed, 92 insertions(+), 188 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSkip.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 893ec455eb..c244fb5001 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -49,87 +49,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;
-import rx.operators.OperationAny;
-import rx.operators.OperationAsObservable;
-import rx.operators.OperationAverage;
-import rx.operators.OperationBuffer;
-import rx.operators.OperationCache;
-import rx.operators.OperationCombineLatest;
-import rx.operators.OperationConcat;
-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;
-import rx.operators.OperationElementAt;
-import rx.operators.OperationFinally;
-import rx.operators.OperationFlatMap;
-import rx.operators.OperationGroupByUntil;
-import rx.operators.OperationGroupJoin;
-import rx.operators.OperationInterval;
-import rx.operators.OperationJoin;
-import rx.operators.OperationJoinPatterns;
-import rx.operators.OperationMaterialize;
-import rx.operators.OperationMergeDelayError;
-import rx.operators.OperationMergeMaxConcurrent;
-import rx.operators.OperationMinMax;
-import rx.operators.OperationMulticast;
-import rx.operators.OperationOnErrorResumeNextViaObservable;
-import rx.operators.OperationOnErrorReturn;
-import rx.operators.OperationOnExceptionResumeNextViaObservable;
-import rx.operators.OperationParallelMerge;
-import rx.operators.OperationReplay;
-import rx.operators.OperationRetry;
-import rx.operators.OperationSample;
-import rx.operators.OperationSequenceEqual;
-import rx.operators.OperationSingle;
-import rx.operators.OperationSkip;
-import rx.operators.OperationSkipLast;
-import rx.operators.OperationSkipUntil;
-import rx.operators.OperationSkipWhile;
-import rx.operators.OperationSum;
-import rx.operators.OperationSwitch;
-import rx.operators.OperationSynchronize;
-import rx.operators.OperationTakeLast;
-import rx.operators.OperationTakeTimed;
-import rx.operators.OperationTakeUntil;
-import rx.operators.OperationTakeWhile;
-import rx.operators.OperationThrottleFirst;
-import rx.operators.OperationTimeInterval;
-import rx.operators.OperationTimer;
-import rx.operators.OperationToMap;
-import rx.operators.OperationToMultimap;
-import rx.operators.OperationToObservableFuture;
-import rx.operators.OperationUsing;
-import rx.operators.OperationWindow;
-import rx.operators.OperatorCast;
-import rx.operators.OperatorDoOnEach;
-import rx.operators.OperatorFilter;
-import rx.operators.OperatorGroupBy;
-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;
-import rx.operators.OperatorTimeoutWithSelector;
-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.operators.*;
 import rx.plugins.RxJavaObservableExecutionHook;
 import rx.plugins.RxJavaPlugins;
 import rx.schedulers.Schedulers;
@@ -6274,7 +6194,7 @@ public final Observable<T> singleOrDefault(T defaultValue, Func1<? super T, Bool
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
      */
     public final Observable<T> skip(int num) {
-        return create(OperationSkip.skip(this, num));
+        return lift(new OperatorSkip<T>(num));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 5267322e96..31ffa1c90f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -39,81 +39,6 @@
  */
 public final class OperationSkip {
 
-    /**
-     * Skips a specified number of contiguous values from the start of a Observable sequence and then returns the remaining values.
-     * 
-     * @param items
-     * @param num
-     * @return the observable sequence starting after a number of skipped values
-     * 
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229847(v=vs.103).aspx">Observable.Skip(TSource) Method</a>
-     */
-    public static <T> OnSubscribeFunc<T> skip(final Observable<? extends T> items, final int num) {
-        // wrap in a Observable so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new Skip<T>(items, num).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.
-     * <p>
-     * It IS thread-safe from within it while receiving onNext events from multiple threads.
-     * 
-     * @param <T>
-     */
-    private static class Skip<T> implements OnSubscribeFunc<T> {
-        private final int num;
-        private final Observable<? extends T> items;
-
-        Skip(final Observable<? extends T> items, final int num) {
-            this.num = num;
-            this.items = items;
-        }
-
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            return items.subscribe(new ItemObserver(observer));
-        }
-
-        /**
-         * Used to subscribe to the 'items' Observable sequence and forward to the actualObserver up to 'num' count.
-         */
-        private class ItemObserver implements Observer<T> {
-
-            private AtomicInteger counter = new AtomicInteger();
-            private final Observer<? super T> observer;
-
-            public ItemObserver(Observer<? super T> observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onCompleted() {
-                observer.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                // skip them until we reach the 'num' value
-                if (counter.incrementAndGet() > num) {
-                    observer.onNext(args);
-                }
-            }
-
-        }
-
-    }
-
     /**
      * Skip the items after subscription for the given duration.
      * 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMap.java b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
index 6418005521..233e2fcb70 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMap.java
@@ -61,3 +61,4 @@ public void onNext(T t) {
     }
 
 }
+
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkip.java b/rxjava-core/src/main/java/rx/operators/OperatorSkip.java
new file mode 100644
index 0000000000..020c488fa6
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkip.java
@@ -0,0 +1,49 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.Subscriber;
+
+/**
+ * Returns an Observable that skips the first <code>num</code> items emitted by the source
+ * Observable.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/skip.png">
+ * <p>
+ * You can ignore the first <code>num</code> items emitted by an Observable and attend only to
+ * those items that come after, by modifying the Observable with the skip operation.
+ */
+public final class OperatorSkip<T> implements Observable.Operator<T, T> {
+
+    int n;
+
+    public OperatorSkip(int n) {
+        this.n = n;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new Subscriber<T>(child) {
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onNext(T t) {
+                if(n <= 0) {
+                    child.onNext(t);
+                } else {
+                    n -= 1;
+                }
+            }
+
+        };
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
index 5999e07fee..c7dad11ce1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
@@ -17,7 +17,6 @@
 
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationSkip.*;
 
 import java.util.concurrent.TimeUnit;
 
@@ -31,36 +30,6 @@
 
 public class OperationSkipTest {
 
-    @Test
-    public void testSkip1() {
-        Observable<String> w = Observable.from("one", "two", "three");
-        Observable<String> skip = Observable.create(skip(w, 2));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        skip.subscribe(observer);
-        verify(observer, never()).onNext("one");
-        verify(observer, never()).onNext("two");
-        verify(observer, times(1)).onNext("three");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testSkip2() {
-        Observable<String> w = Observable.from("one", "two", "three");
-        Observable<String> skip = Observable.create(skip(w, 1));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        skip.subscribe(observer);
-        verify(observer, never()).onNext("one");
-        verify(observer, times(1)).onNext("two");
-        verify(observer, times(1)).onNext("three");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
     @Test
     public void testSkipTimed() {
         TestScheduler scheduler = new TestScheduler();
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
new file mode 100644
index 0000000000..155faf21eb
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
@@ -0,0 +1,40 @@
+package rx.operators;
+
+import org.junit.Test;
+import rx.Observable;
+import rx.Observer;
+
+import static org.mockito.Mockito.*;
+
+public class OperatorSkipTest {
+
+    @Test
+    public void testSkip1() {
+        Observable<String> w = Observable.from("one", "two", "three");
+        Observable<String> skip = w.lift(new OperatorSkip<String>(2));
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        skip.subscribe(observer);
+        verify(observer, never()).onNext("one");
+        verify(observer, never()).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSkip2() {
+        Observable<String> w = Observable.from("one", "two", "three");
+        Observable<String> skip = w.lift(new OperatorSkip<String>(1));
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        skip.subscribe(observer);
+        verify(observer, never()).onNext("one");
+        verify(observer, times(1)).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+}

From dbb08348f9928000c883a9157840b3b3d5ba4ce1 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 27 Feb 2014 15:17:24 +1100
Subject: [PATCH 064/422] add Observable.startWith(Observable) method and unit
 test to avoid breaking method chaining when want to startWith an Observable
 rather than just an Iterator or specific values.

---
 rxjava-core/src/main/java/rx/Observable.java     | 16 ++++++++++++++++
 rxjava-core/src/test/java/rx/StartWithTests.java | 13 +++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 893ec455eb..61d0e1d180 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6431,6 +6431,22 @@ public final Observable<T> skipWhileWithIndex(Func2<? super T, Integer, Boolean>
         return create(OperationSkipWhile.skipWhileWithIndex(this, predicate));
     }
 
+    /**
+     * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit items
+     * emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param values
+     *            an Observable that contains the items you want the modified Observable to emit first
+     * @return an Observable that emits the items in the specified {@link Observable} and then emits the items
+     *         emitted by the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(Observable<T> values) {
+        return concat(values, this);
+    }
+
     /**
      * Returns an Observable that emits the items in a specified {@link Iterable} before it begins to emit items
      * emitted by the source Observable.
diff --git a/rxjava-core/src/test/java/rx/StartWithTests.java b/rxjava-core/src/test/java/rx/StartWithTests.java
index e2a429723d..4ea4c7cde0 100644
--- a/rxjava-core/src/test/java/rx/StartWithTests.java
+++ b/rxjava-core/src/test/java/rx/StartWithTests.java
@@ -45,4 +45,17 @@ public void startWithIterable() {
         assertEquals("two", values.get(3));
     }
 
+	@Test
+    public void startWithObservable() {
+        List<String> li = new ArrayList<String>();
+        li.add("alpha");
+        li.add("beta");
+        List<String> values = Observable.from("one", "two").startWith(Observable.from(li)).toList().toBlockingObservable().single();
+
+        assertEquals("alpha", values.get(0));
+        assertEquals("beta", values.get(1));
+        assertEquals("one", values.get(2));
+        assertEquals("two", values.get(3));
+    }
+
 }

From 0b6b4650105aa148ec3f69740c09a53b2631888f Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Thu, 27 Feb 2014 17:26:41 +1100
Subject: [PATCH 065/422] add space to a comment to force ci rebuild to see if
 suspected non-deterministic test fails again

---
 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 61d0e1d180..8a3bfa95de 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6433,7 +6433,7 @@ public final Observable<T> skipWhileWithIndex(Func2<? super T, Integer, Boolean>
 
     /**
      * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit items
-     * emitted by the source Observable.
+     * emitted by the source Observable. 
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
      * 

From 9f8e3e8226cfd845b9c46cf2b2c7ba4e296b5bc4 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Thu, 27 Feb 2014 09:59:55 +0100
Subject: [PATCH 066/422] Simplify version property forwarding

---
 .../rxjava-android-samples-build-wrapper/build.gradle     | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
index 87f0f5bbf3..af1f33cec5 100644
--- a/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
+++ b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
@@ -7,13 +7,7 @@ tasks.build.doLast {
     project.exec {
       workingDir '../rxjava-android-samples'
 
-      def props = new Properties()
-      file("$rootDir/gradle.properties").withReader { reader ->
-        props.load(reader)
-        properties.putAll(props)
-      }
-
-      commandLine "./gradlew", "clean", "packageDebug", "-PrxjVersion=${props.getProperty("version")}"
+      commandLine "./gradlew", "clean", "packageDebug", "-PrxjVersion=${version}"
     }
   }
 }

From b780143add1c649fb6b594adb94e247157bd3b84 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Thu, 27 Feb 2014 10:10:51 +0100
Subject: [PATCH 067/422] Fix project import issue in Android Studio and a
 compilation failure

---
 .../rxjava-android-samples-build-wrapper/build.gradle     | 2 +-
 .../rxjava-android-samples/samples/build.gradle           | 8 ++++++++
 .../netflix/rxjava/android/samples/RetainedFragment.java  | 2 +-
 3 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
index af1f33cec5..de7ef0162c 100644
--- a/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
+++ b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
@@ -7,7 +7,7 @@ tasks.build.doLast {
     project.exec {
       workingDir '../rxjava-android-samples'
 
-      commandLine "./gradlew", "clean", "packageDebug", "-PrxjVersion=${version}"
+      commandLine "./gradlew", "clean", "packageDebug"
     }
   }
 }
diff --git a/rxjava-contrib/rxjava-android-samples/samples/build.gradle b/rxjava-contrib/rxjava-android-samples/samples/build.gradle
index 1b89f83fdc..9a080128a8 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/build.gradle
+++ b/rxjava-contrib/rxjava-android-samples/samples/build.gradle
@@ -18,7 +18,15 @@ android {
     }
 }
 
+// make sure we always compile against the latest version of RxJava
+def rootProjectProperties = new Properties()
+file("../../../gradle.properties").withReader { reader ->
+    rootProjectProperties.load(reader)
+    properties.putAll(rootProjectProperties)
+}
+
 dependencies {
+    def rxjVersion = rootProjectProperties.get("version")
     compile "com.netflix.rxjava:rxjava-android:$rxjVersion"
     compile fileTree(dir: 'libs', include: ['*.jar'])
 }
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
index a3a0c73d72..0db00e3ac8 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
@@ -36,7 +36,7 @@ public RetainedFragment() {
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        strings = SampleObservables.numberStrings2().cache();
+        strings = SampleObservables.numberStrings().cache();
     }
 
     @Override

From 6b25b2304b08dbaf9f4d52054f06d743a9fb4a22 Mon Sep 17 00:00:00 2001
From: headinthebox <emeijer@applied-duality.com>
Date: Thu, 27 Feb 2014 11:31:40 -0800
Subject: [PATCH 068/422] Fixed state capture bug. Added some additional tests

---
 .../main/java/rx/operators/OperatorSkip.java  |   8 +-
 .../java/rx/operators/OperatorSkipTest.java   | 102 ++++++++++++++++--
 2 files changed, 99 insertions(+), 11 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkip.java b/rxjava-core/src/main/java/rx/operators/OperatorSkip.java
index 020c488fa6..cc0ec068c2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkip.java
@@ -14,7 +14,7 @@
  */
 public final class OperatorSkip<T> implements Observable.Operator<T, T> {
 
-    int n;
+    final int n;
 
     public OperatorSkip(int n) {
         this.n = n;
@@ -24,6 +24,8 @@ public OperatorSkip(int n) {
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
         return new Subscriber<T>(child) {
 
+           int skipped = 0;
+
             @Override
             public void onCompleted() {
                 child.onCompleted();
@@ -36,10 +38,10 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(T t) {
-                if(n <= 0) {
+                if(skipped >= n) {
                     child.onNext(t);
                 } else {
-                    n -= 1;
+                    skipped += 1;
                 }
             }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
index 155faf21eb..f0a9706786 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
@@ -9,24 +9,39 @@
 public class OperatorSkipTest {
 
     @Test
-    public void testSkip1() {
-        Observable<String> w = Observable.from("one", "two", "three");
-        Observable<String> skip = w.lift(new OperatorSkip<String>(2));
+    public void testSkipNegativeElements() {
+
+        Observable<String> skip = Observable.from("one", "two", "three").lift(new OperatorSkip<String>(-99));
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         skip.subscribe(observer);
-        verify(observer, never()).onNext("one");
-        verify(observer, never()).onNext("two");
+        verify(observer, times(1)).onNext("one");
+        verify(observer, times(1)).onNext("two");
         verify(observer, times(1)).onNext("three");
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onCompleted();
     }
 
     @Test
-    public void testSkip2() {
-        Observable<String> w = Observable.from("one", "two", "three");
-        Observable<String> skip = w.lift(new OperatorSkip<String>(1));
+    public void testSkipZeroElements() {
+
+        Observable<String> skip = Observable.from("one", "two", "three").lift(new OperatorSkip<String>(0));
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        skip.subscribe(observer);
+        verify(observer, times(1)).onNext("one");
+        verify(observer, times(1)).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSkipOneElement() {
+
+        Observable<String> skip = Observable.from("one", "two", "three").lift(new OperatorSkip<String>(1));
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -37,4 +52,75 @@ public void testSkip2() {
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, times(1)).onCompleted();
     }
+
+    @Test
+    public void testSkipTwoElements() {
+
+        Observable<String> skip = Observable.from("one", "two", "three").lift(new OperatorSkip<String>(2));
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        skip.subscribe(observer);
+        verify(observer, never()).onNext("one");
+        verify(observer, never()).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSkipEmptyStream() {
+
+        Observable<String> w = Observable.empty();
+        Observable<String> skip = w.lift(new OperatorSkip<String>(1));
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        skip.subscribe(observer);
+        verify(observer, never()).onNext(any(String.class));
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSkipMultipleObservers() {
+
+        Observable<String> skip = Observable.from("one", "two", "three").lift(new OperatorSkip<String>(2));
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer1 = mock(Observer.class);
+        skip.subscribe(observer1);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer2 = mock(Observer.class);
+        skip.subscribe(observer2);
+
+        verify(observer1, times(1)).onNext(any(String.class));
+        verify(observer1, never()).onError(any(Throwable.class));
+        verify(observer1, times(1)).onCompleted();
+
+        verify(observer2, times(1)).onNext(any(String.class));
+        verify(observer2, never()).onError(any(Throwable.class));
+        verify(observer2, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSkipError() {
+
+        Exception e = new Exception();
+
+        Observable<String> ok = Observable.from("one");
+        Observable<String> error = Observable.error(e);
+
+        Observable<String> skip = Observable.concat(ok, error).lift(new OperatorSkip<String>(100));
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        skip.subscribe(observer);
+
+        verify(observer, never()).onNext(any(String.class));
+        verify(observer, times(1)).onError(e);
+        verify(observer, never()).onCompleted();
+
+    }
 }

From 955bc509d6ced282c249d5714673ec35f0061380 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Sun, 2 Mar 2014 12:40:50 +0100
Subject: [PATCH 069/422] First implementation of OperatorWeakBinding

---
 .../observables/AndroidObservable.java        | 23 ++++++
 .../OperatorObserveFromAndroidComponent.java  |  1 +
 .../rx/operators/OperatorWeakBinding.java     | 75 +++++++++++++++++++
 3 files changed, 99 insertions(+)
 create mode 100644 rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.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 d55617ddea..723ebf40b0 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,8 +15,12 @@
  */
 package rx.android.observables;
 
+import static rx.android.schedulers.AndroidSchedulers.mainThread;
+
 import rx.Observable;
 import rx.operators.OperatorObserveFromAndroidComponent;
+import rx.operators.OperatorWeakBinding;
+
 import android.app.Activity;
 import android.app.Fragment;
 import android.os.Build;
@@ -58,6 +62,7 @@ private AndroidObservable() {}
      * @param <T>
      * @return a new observable sequence that will emit notifications on the main UI thread
      */
+    @Deprecated
     public static <T> Observable<T> fromActivity(Activity activity, Observable<T> sourceObservable) {
         return OperatorObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, activity);
     }
@@ -86,6 +91,7 @@ public static <T> Observable<T> fromActivity(Activity activity, Observable<T> so
      * @param <T>
      * @return a new observable sequence that will emit notifications on the main UI thread
      */
+    @Deprecated
     public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sourceObservable) {
         if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
             return OperatorObserveFromAndroidComponent.observeFromAndroidComponent(sourceObservable, (android.support.v4.app.Fragment) fragment);
@@ -95,4 +101,21 @@ public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sour
             throw new IllegalArgumentException("Target fragment is neither a native nor support library Fragment");
         }
     }
+
+    public static <T> Observable<T> bindActivity(Activity activity, Observable<T> cachedSequence) {
+        return cachedSequence.observeOn(mainThread()).lift(new OperatorWeakBinding<T, Activity>(activity));
+    }
+
+    public static <T> Observable<T> bindFragment(Object fragment, Observable<T> cachedSequence) {
+        Observable<T> source = cachedSequence.observeOn(mainThread());
+        if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
+            android.support.v4.app.Fragment f = (android.support.v4.app.Fragment) fragment;
+            return source.lift(new OperatorWeakBinding<T, android.support.v4.app.Fragment>(f));
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && fragment instanceof Fragment) {
+            Fragment f = (Fragment) fragment;
+            return source.lift(new OperatorWeakBinding<T, Fragment>(f));
+        } 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/operators/OperatorObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
index 3e656ccfbb..754ebb2e4e 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
@@ -25,6 +25,7 @@
 import android.os.Looper;
 import android.util.Log;
 
+@Deprecated
 public class OperatorObserveFromAndroidComponent {
 
     public static <T> Observable<T> observeFromAndroidComponent(Observable<T> source, android.app.Fragment fragment) {
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
new file mode 100644
index 0000000000..3392cc887a
--- /dev/null
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
@@ -0,0 +1,75 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.Subscriber;
+
+import android.util.Log;
+
+import java.lang.ref.WeakReference;
+
+public final class OperatorWeakBinding<T, R> implements Observable.Operator<T, T> {
+
+    private static final String LOG_TAG = "WeakBinding";
+
+    private final WeakReference<R> boundRef;
+
+    public OperatorWeakBinding(R bound) {
+        boundRef = new WeakReference<R>(bound);
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new WeakSubscriber<T, R>(child, boundRef);
+    }
+
+    private static final class WeakSubscriber<T, R> extends Subscriber<T> {
+
+        private final WeakReference<Subscriber<? super T>> subscriberRef;
+        private final WeakReference<R> boundRef;
+
+        private WeakSubscriber(Subscriber<? super T> op, WeakReference<R> boundRef) {
+            subscriberRef = new WeakReference<Subscriber<? super T>>(op);
+            this.boundRef = boundRef;
+        }
+
+        @Override
+        public void onCompleted() {
+            Subscriber<? super T> sub = subscriberRef.get();
+            if (sub != null && boundRef.get() != null) {
+                sub.onCompleted();
+            } else {
+                handleLostBinding(sub, "onCompleted");
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            Subscriber<? super T> sub = subscriberRef.get();
+            if (sub != null && boundRef.get() != null) {
+                sub.onError(e);
+            } else {
+                handleLostBinding(sub, "onError");
+            }
+        }
+
+        @Override
+        public void onNext(T t) {
+            Subscriber<? super T> sub = subscriberRef.get();
+            if (sub != null && boundRef.get() != null) {
+                sub.onNext(t);
+            } else {
+                handleLostBinding(sub, "onNext");
+            }
+        }
+
+        private void handleLostBinding(Subscriber<? super T> sub, String context) {
+            if (sub == null) {
+                Log.d(LOG_TAG, "subscriber gone; skipping " + context);
+            } else {
+                Log.d(LOG_TAG, "bound component gone; skipping " + context);
+            }
+            unsubscribe();
+        }
+
+    }
+}

From eb92efdbcbe49bfced1509012860345ee8729488 Mon Sep 17 00:00:00 2001
From: George Campbell <gscampbell@netflix.com>
Date: Sat, 1 Mar 2014 16:11:46 -0800
Subject: [PATCH 070/422] refactor the debug hooks before they become a
 breaking change.

---
 .../java/rx/operators/DebugSubscriber.java    |  49 ++--
 .../java/rx/operators/DebugSubscription.java  |  22 +-
 .../src/main/java/rx/plugins/DebugHook.java   |  73 +++---
 .../java/rx/plugins/DebugNotification.java    | 111 +++++++--
 .../rx/plugins/DebugNotificationListener.java |  70 ++++++
 .../src/test/java/rx/debug/DebugHookTest.java | 233 +++++++++++++-----
 rxjava-core/src/main/java/rx/Observable.java  |  16 +-
 .../src/main/java/rx/functions/Actions.java   |  36 ++-
 .../src/main/java/rx/functions/Functions.java |  75 ++++++
 .../rx/operators/OnSubscribeFromIterable.java |   3 +
 .../RxJavaObservableExecutionHook.java        |  93 ++++---
 11 files changed, 557 insertions(+), 224 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.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 f75c6b5662..f8ef22e9a5 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,72 +3,63 @@
 import rx.Observable.Operator;
 import rx.Observer;
 import rx.Subscriber;
-import rx.functions.Action1;
-import rx.functions.Action2;
-import rx.functions.Func1;
 import rx.plugins.DebugNotification;
+import rx.plugins.DebugNotificationListener;
 
 public final class DebugSubscriber<T, C> extends Subscriber<T> {
-    private final Func1<T, T> onNextHook;
-    private final Func1<DebugNotification, C> start;
-    private final Action1<C> complete;
-    private final Action2<C, Throwable> error;
+    private DebugNotificationListener<C> listener;
     private final Observer<? super T> o;
     private Operator<? extends T, ?> from = null;
     private Operator<?, ? super T> to = null;
 
     public DebugSubscriber(
-            Func1<T, T> onNextHook,
-            Func1<DebugNotification, C> start,
-            Action1<C> complete,
-            Action2<C, Throwable> error,
+            DebugNotificationListener<C> listener,
             Subscriber<? super T> _o,
             Operator<? extends T, ?> _out,
             Operator<?, ? super T> _in) {
         super(_o);
-        this.start = start;
-        this.complete = complete;
-        this.error = error;
+        this.listener = listener;
         this.o = _o;
-        this.onNextHook = onNextHook;
         this.from = _out;
         this.to = _in;
-        this.add(new DebugSubscription<T, C>(this, start, complete, error));
+        this.add(new DebugSubscription<T, C>(this, listener));
     }
 
     @Override
     public void onCompleted() {
-        final DebugNotification<T, C> n = DebugNotification.createOnCompleted(o, from, to);
-        C context = start.call(n);
+        final DebugNotification<T> n = DebugNotification.createOnCompleted(o, from, to);
+        C context = listener.start(n);
         try {
             o.onCompleted();
-            complete.call(context);
+            listener.complete(context);
         } catch (Throwable e) {
-            error.call(context, e);
+            listener.error(context, e);
         }
     }
 
     @Override
     public void onError(Throwable e) {
-        final DebugNotification<T, C> n = DebugNotification.createOnError(o, from, e, to);
-        C context = start.call(n);
+        final DebugNotification<T> n = DebugNotification.createOnError(o, from, e, to);
+        C context = listener.start(n);
         try {
             o.onError(e);
-            complete.call(context);
+            listener.complete(context);
         } catch (Throwable e2) {
-            error.call(context, e2);
+            listener.error(context, e2);
         }
     }
 
     @Override
     public void onNext(T t) {
-        final DebugNotification<T, C> n = DebugNotification.createOnNext(o, from, t, to);
-        C context = start.call(n);
+        final DebugNotification<T> n = DebugNotification.createOnNext(o, from, t, to);
+        t = (T) listener.onNext(n);
+
+        C context = listener.start(n);
         try {
-            o.onNext(onNextHook.call(t));
-            complete.call(context);
+            o.onNext(t);
+            listener.complete(context);
         } catch (Throwable e) {
-            error.call(context, e);
+            listener.error(context, e);
         }
     }
 
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
index 256fd8798a..0a3ce9d5ef 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/operators/DebugSubscription.java
@@ -1,33 +1,27 @@
 package rx.operators;
 
 import rx.Subscription;
-import rx.functions.Action1;
-import rx.functions.Action2;
-import rx.functions.Func1;
 import rx.plugins.DebugNotification;
+import rx.plugins.DebugNotificationListener;
 
 final class DebugSubscription<T, C> implements Subscription {
     private final DebugSubscriber<T, C> debugObserver;
-    private final Func1<DebugNotification, C> start;
-    private final Action1<C> complete;
-    private final Action2<C, Throwable> error;
+    private DebugNotificationListener<C> listener;
 
-    DebugSubscription(DebugSubscriber<T, C> debugObserver, Func1<DebugNotification, C> start, Action1<C> complete, Action2<C, Throwable> error) {
+    DebugSubscription(DebugSubscriber<T, C> debugObserver, DebugNotificationListener<C> listener) {
         this.debugObserver = debugObserver;
-        this.start = start;
-        this.complete = complete;
-        this.error = error;
+        this.listener = listener;
     }
 
     @Override
     public void unsubscribe() {
-        final DebugNotification<T, C> n = DebugNotification.<T, C> createUnsubscribe(debugObserver.getActual(), debugObserver.getFrom(), debugObserver.getTo());
-        C context = start.call(n);
+        final DebugNotification<T> n = DebugNotification.<T> createUnsubscribe(debugObserver.getActual(), debugObserver.getFrom(), debugObserver.getTo());
+        C context = listener.start(n);
         try {
             debugObserver.unsubscribe();
-            complete.call(context);
+            listener.complete(context);
         } catch (Throwable e) {
-            error.call(context, e);
+            listener.error(context, e);
         }
     }
 
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 3e5d5eba9a..9e48267333 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
@@ -19,10 +19,7 @@
  * @author gscampbell
  */
 public class DebugHook<C> extends RxJavaObservableExecutionHook {
-    private final Func1 onNextHook;
-    private final Func1<DebugNotification, C> start;
-    private final Action1<C> complete;
-    private final Action2<C, Throwable> error;
+    private DebugNotificationListener<C> listener;
 
     /**
      * Creates a new instance of the DebugHook RxJava plug-in that can be passed into
@@ -34,11 +31,10 @@ public class DebugHook<C> extends RxJavaObservableExecutionHook {
      * @param events
      *            This action is invoked as each notification is generated
      */
-    public DebugHook(Func1 onNextDataHook, Func1<DebugNotification, C> start, Action1<C> complete, Action2<C, Throwable> error) {
-        this.complete = complete;
-        this.error = error;
-        this.onNextHook = onNextDataHook == null ? Functions.identity() : onNextDataHook;
-        this.start = (Func1<DebugNotification, C>) (start == null ? Actions.empty() : start);
+    public DebugHook(DebugNotificationListener<C> listener) {
+        if (listener == null)
+            throw new IllegalArgumentException("The debug listener must not be null");
+        this.listener = listener;
     }
 
     @Override
@@ -46,27 +42,48 @@ public <T> OnSubscribe<T> onSubscribeStart(final Observable<? extends T> observa
         return new OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> o) {
-                C context = start.call(DebugNotification.createSubscribe(o, observableInstance, f));
+                final DebugNotification<T> n = DebugNotification.createSubscribe(o, observableInstance, f);
+                o = wrapOutbound(null, o);
+
+                C context = listener.start(n);
                 try {
-                    f.call(wrapOutbound(null, o));
-                    complete.call(context);
+                    f.call(o);
+                    listener.complete(context);
                 }
                 catch(Throwable e) {
-                    error.call(context, e);
+                    listener.error(context, e);
                 }
             }
         };
     }
 
     @Override
-    public <T> Subscription onSubscribeReturn(Observable<? extends T> observableInstance, Subscription subscription) {
+    public <T> Subscription onSubscribeReturn(Subscription subscription) {
         return subscription;
     }
 
     @Override
     public <T> OnSubscribe<T> onCreate(final OnSubscribe<T> f) {
-        return new OnCreateWrapper<T>(f);
+        return new DebugOnSubscribe<T>(f);
     }
+    
+    public final class DebugOnSubscribe<T> implements OnSubscribe<T> {
+        private final OnSubscribe<T> f;
+
+        private DebugOnSubscribe(OnSubscribe<T> f) {
+            this.f = f;
+        }
+
+        @Override
+        public void call(Subscriber<? super T> o) {
+            f.call(wrapInbound(null, o));
+        }
+
+        public OnSubscribe<T> getActual() {
+            return f;
+        }
+    }
+
 
     @Override
     public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> bind) {
@@ -78,11 +95,6 @@ public Subscriber<? super T> call(final Subscriber<? super R> o) {
         };
     }
 
-    @Override
-    public <T> Subscription onAdd(Subscriber<T> subscriber, Subscription s) {
-        return s;
-    }
-
     @SuppressWarnings("unchecked")
     private <R> Subscriber<? super R> wrapOutbound(Operator<? extends R, ?> bind, Subscriber<? super R> o) {
         if (o instanceof DebugSubscriber) {
@@ -90,7 +102,7 @@ private <R> Subscriber<? super R> wrapOutbound(Operator<? extends R, ?> bind, Su
                 ((DebugSubscriber<R, C>) o).setFrom(bind);
             return o;
         }
-        return new DebugSubscriber<R, C>(onNextHook, start, complete, error, o, bind, null);
+        return new DebugSubscriber<R, C>(listener, o, bind, null);
     }
 
     @SuppressWarnings("unchecked")
@@ -100,23 +112,6 @@ private <T> Subscriber<? super T> wrapInbound(Operator<?, ? super T> bind, Subsc
                 ((DebugSubscriber<T, C>) o).setTo(bind);
             return o;
         }
-        return new DebugSubscriber<T, C>(onNextHook, start, complete, error, o, null, bind);
-    }
-
-    public final class OnCreateWrapper<T> implements OnSubscribe<T> {
-        private final OnSubscribe<T> f;
-
-        private OnCreateWrapper(OnSubscribe<T> f) {
-            this.f = f;
-        }
-
-        @Override
-        public void call(Subscriber<? super T> o) {
-            f.call(wrapInbound(null, o));
-        }
-
-        public OnSubscribe<T> getActual() {
-            return f;
-        }
+        return new DebugSubscriber<T, C>(listener, 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
index f22d4e31ef..1cc8eab752 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
@@ -7,7 +7,7 @@
 import rx.observers.SafeSubscriber;
 import rx.operators.DebugSubscriber;
 
-public class DebugNotification<T, C> {
+public class DebugNotification<T> {
     public static enum Kind {
         OnNext, OnError, OnCompleted, Subscribe, Unsubscribe
     }
@@ -21,37 +21,39 @@ public static enum Kind {
     private final T value;
     private final Observer observer;
 
-    public static <T, C> DebugNotification<T, C> createSubscribe(Observer<? super T> o, Observable<? extends T> source, OnSubscribe<T> sourceFunc) {
+    @SuppressWarnings("unchecked")
+    public static <T, C> DebugNotification<T> createSubscribe(Observer<? super T> o, Observable<? extends T> source, OnSubscribe<T> sourceFunc) {
         Operator<?, ? super T> to = null;
         Operator<? extends T, ?> from = null;
         if (o instanceof SafeSubscriber) {
-            o = ((SafeSubscriber) o).getActual();
+            o = ((SafeSubscriber<T>) o).getActual();
         }
         if (o instanceof DebugSubscriber) {
-            to = ((DebugSubscriber<T, C>) o).getTo();
-            from = ((DebugSubscriber<T, C>) o).getFrom();
-            o = ((DebugSubscriber) o).getActual();
+            final DebugSubscriber ds = (DebugSubscriber) o;
+            to = ds.getTo();
+            from = ds.getFrom();
+            o = ds.getActual();
         }
-        if (sourceFunc instanceof DebugHook.OnCreateWrapper) {
-            sourceFunc = ((DebugHook.OnCreateWrapper) sourceFunc).getActual();
+        if (sourceFunc instanceof DebugHook.DebugOnSubscribe) {
+            sourceFunc = ((DebugHook<C>.DebugOnSubscribe<T>) sourceFunc).getActual();
         }
-        return new DebugNotification<T, C>(o, from, Kind.Subscribe, null, null, to, source, sourceFunc);
+        return new DebugNotification<T>(o, from, Kind.Subscribe, null, null, to, source, sourceFunc);
     }
 
-    public static <T, C> DebugNotification<T, C> createOnNext(Observer<? super T> o, Operator<? extends T, ?> from, T t, Operator<?, ? super T> to) {
-        return new DebugNotification<T, C>(o, from, Kind.OnNext, t, null, to, null, null);
+    public static <T> DebugNotification<T> createOnNext(Observer<? super T> o, Operator<? extends T, ?> from, T t, Operator<?, ? super T> to) {
+        return new DebugNotification<T>(o, from, Kind.OnNext, t, null, to, null, null);
     }
 
-    public static <T, C> DebugNotification<T, C> createOnError(Observer<? super T> o, Operator<? extends T, ?> from, Throwable e, Operator<?, ? super T> to) {
-        return new DebugNotification<T, C>(o, from, Kind.OnError, null, e, to, null, null);
+    public static <T> DebugNotification<T> createOnError(Observer<? super T> o, Operator<? extends T, ?> from, Throwable e, Operator<?, ? super T> to) {
+        return new DebugNotification<T>(o, from, Kind.OnError, null, e, to, null, null);
     }
 
-    public static <T, C> DebugNotification<T, C> createOnCompleted(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
-        return new DebugNotification<T, C>(o, from, Kind.OnCompleted, null, null, to, null, null);
+    public static <T> DebugNotification<T> createOnCompleted(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
+        return new DebugNotification<T>(o, from, Kind.OnCompleted, null, null, to, null, null);
     }
 
-    public static <T, C> DebugNotification<T, C> createUnsubscribe(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
-        return new DebugNotification<T, C>(o, from, Kind.Unsubscribe, null, null, to, null, null);
+    public static <T> DebugNotification<T> createUnsubscribe(Observer<? super T> o, Operator<? extends T, ?> from, Operator<?, ? super T> to) {
+        return new DebugNotification<T>(o, from, Kind.Unsubscribe, null, null, to, null, null);
     }
 
     private DebugNotification(Observer o, Operator<? extends T, ?> from, Kind kind, T value, Throwable throwable, Operator<?, ? super T> to, Observable<? extends T> source, OnSubscribe<T> sourceFunc) {
@@ -88,11 +90,11 @@ public Throwable getThrowable() {
     public Kind getKind() {
         return kind;
     }
-    
+
     public Observable<? extends T> getSource() {
         return source;
     }
-    
+
     public OnSubscribe<T> getSourceFunc() {
         return sourceFunc;
     }
@@ -103,11 +105,14 @@ public OnSubscribe<T> getSourceFunc() {
      */
     public String toString() {
         final StringBuilder s = new StringBuilder("{");
-        s.append("\"observer\": \"").append(observer.getClass().getName()).append("@").append(Integer.toHexString(observer.hashCode())).append("\"");
+        s.append("\"observer\": ");
+        if (observer != null)
+            s.append("\"").append(observer.getClass().getName()).append("@").append(Integer.toHexString(observer.hashCode())).append("\"");
+        else
+            s.append("null");
         s.append(", \"type\": \"").append(kind).append("\"");
         if (kind == Kind.OnNext)
-            // not json safe
-            s.append(", \"value\": \"").append(value).append("\"");
+            s.append(", \"value\": ").append(quote(value)).append("");
         if (kind == Kind.OnError)
             s.append(", \"exception\": \"").append(throwable.getMessage().replace("\\", "\\\\").replace("\"", "\\\"")).append("\"");
         if (source != null)
@@ -121,4 +126,66 @@ public String toString() {
         s.append("}");
         return s.toString();
     }
+
+    public static String quote(Object obj) {
+        if (obj == null) {
+            return "null";
+        }
+
+        String string;
+        try {
+            string = obj.toString();
+        } catch (Throwable e) {
+            return "\"\"";
+        }
+        if (string == null || string.length() == 0) {
+            return "\"\"";
+        }
+
+        char c = 0;
+        int i;
+        int len = string.length();
+        StringBuilder sb = new StringBuilder(len + 4);
+        String t;
+
+        sb.append('"');
+        for (i = 0; i < len; i += 1) {
+            c = string.charAt(i);
+            switch (c) {
+            case '\\':
+            case '"':
+                sb.append('\\');
+                sb.append(c);
+                break;
+            case '/':
+                sb.append('\\');
+                sb.append(c);
+                break;
+            case '\b':
+                sb.append("\\b");
+                break;
+            case '\t':
+                sb.append("\\t");
+                break;
+            case '\n':
+                sb.append("\\n");
+                break;
+            case '\f':
+                sb.append("\\f");
+                break;
+            case '\r':
+                sb.append("\\r");
+                break;
+            default:
+                if (c < ' ') {
+                    t = "000" + Integer.toHexString(c);
+                    sb.append("\\u" + t.substring(t.length() - 4));
+                } else {
+                    sb.append(c);
+                }
+            }
+        }
+        sb.append('"');
+        return sb.toString();
+    }
 }
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.java
new file mode 100644
index 0000000000..f34e25159e
--- /dev/null
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.java
@@ -0,0 +1,70 @@
+package rx.plugins;
+
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Observer;
+
+/**
+ * Subclasses of this are passed into the constructor of {@link DebugHook} to receive notification
+ * about all activity in Rx.
+ * 
+ * @author gscampbell
+ * 
+ * @param <C>
+ *            Context type that is returned from start and passed to either complete or error.
+ * @see DebugHook
+ */
+@SuppressWarnings("unused")
+public abstract class DebugNotificationListener<C> {
+    /**
+     * Override this to change the default behavior of returning the encapsulated value. This will
+     * only be invoked when the {@link DebugNotification#getKind()} is
+     * {@link DebugNotification.Kind#OnNext} and the value (null or not) is just about to be sent to
+     * next {@link Observer}. This can end up being called multiple times for
+     * the same value as it passes from {@link Operator} to {@link Operator} in the
+     * {@link Observable} chain.
+     * <p>
+     * This can be used to decorate or replace the values passed into any onNext function or just
+     * perform extra logging, metrics and other such things and pass-thru the function.
+     * 
+     * @param n
+     *            {@link DebugNotification} containing the data and context about what is happening.
+     * @return
+     */
+    public <T> T onNext(DebugNotification<T> n) {
+        return n.getValue();
+    }
+
+    /**
+     * For each {@link DebugNotification.Kind} start is invoked before the actual method is invoked.
+     * <p>
+     * This can be used to perform extra logging, metrics and other such things.
+     * 
+     * @param n
+     *            {@link DebugNotification} containing the data and context about what is happening.
+     * @return
+     *         A contextual object that the listener can use in the {@link #complete(C)} or
+     *         {@link #error(C, Throwable)} after the actual operation has ended.
+     */
+    public <T> C start(DebugNotification<T> n) {
+        return null;
+    }
+
+    /**
+     * After the actual operations has completed from {@link #start(DebugNotification)} this is
+     * invoked
+     * 
+     * @param context
+     */
+    public void complete(C context) {
+    }
+
+    /**
+     * After the actual operations has thrown an exception from {@link #start(DebugNotification)}
+     * this is invoked
+     * 
+     * @param context
+     */
+    public void error(C context, Throwable e) {
+    }
+}
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 ea69258259..c3f4f2d426 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
@@ -1,27 +1,28 @@
 package rx.debug;
 
+import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.Arrays;
+import java.util.Map.Entry;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 
 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 org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
+import org.mockito.InOrder;
 
 import rx.Observable;
-import rx.Subscriber;
-import rx.functions.Action1;
-import rx.functions.Action2;
 import rx.functions.Func1;
+import rx.observers.Subscribers;
 import rx.plugins.DebugHook;
 import rx.plugins.DebugNotification;
 import rx.plugins.DebugNotification.Kind;
+import rx.plugins.DebugNotificationListener;
 import rx.plugins.PlugReset;
 import rx.plugins.RxJavaPlugins;
 
@@ -32,112 +33,212 @@ public void reset() {
         PlugReset.reset();
     }
 
+    private static class TestDebugNotificationListener extends DebugNotificationListener<Object> {
+        ConcurrentHashMap<Thread, AtomicInteger> allThreadDepths = new ConcurrentHashMap<Thread, AtomicInteger>(1);
+        ThreadLocal<AtomicInteger> currentThreadDepth = new ThreadLocal<AtomicInteger>() {
+            protected AtomicInteger initialValue() {
+                AtomicInteger depth = new AtomicInteger();
+                allThreadDepths.put(Thread.currentThread(), depth);
+                return depth;
+            };
+        };
+
+        @Override
+        public <T> T onNext(DebugNotification<T> n) {
+            if (n == null)
+                return null; // because we are verifying on a spied object.
+            System.err.println("next: " + n.getValue());
+            return super.onNext(n);
+        }
+
+        @Override
+        public <T> Object start(DebugNotification<T> n) {
+            if (n == null)
+                return null; // because we are verifying on a spied object.
+            currentThreadDepth.get().incrementAndGet();
+            Object context = new Object();
+            System.err.println("start: " + Integer.toHexString(context.hashCode()) + " " + n);
+            return context;
+        }
+
+        @Override
+        public void complete(Object context) {
+            if (context == null)
+                return; // because we are verifying on a spied object.
+            currentThreadDepth.get().decrementAndGet();
+            System.err.println("complete: " + Integer.toHexString(context.hashCode()));
+        }
+
+        @Override
+        public void error(Object context, Throwable e) {
+            if (context == null)
+                return; // because we are verifying on a spied object.
+            currentThreadDepth.get().decrementAndGet();
+            System.err.println("error: " + Integer.toHexString(context.hashCode()));
+        }
+
+        public void assertValidState() {
+            for (Entry<Thread, AtomicInteger> threadDepth : allThreadDepths.entrySet()) {
+                assertEquals(0, threadDepth.getValue().get());
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
     @Test
-    @Ignore
     public void testSimple() {
-        Func1 start = mock(Func1.class);
-        Action1 complete = mock(Action1.class);
-        Action2 error = mock(Action2.class);
-        final DebugHook hook = new DebugHook(null, start, complete, error);
+        TestDebugNotificationListener listener = new TestDebugNotificationListener();
+        listener = spy(listener);
+        final DebugHook hook = new DebugHook(listener);
         RxJavaPlugins.getInstance().registerObservableExecutionHook(hook);
-        Observable.empty().subscribe();
-        verify(start, times(1)).call(subscribe());
-        verify(start, times(1)).call(onCompleted());
 
-        verify(complete, times(2)).call(any());
+        Observable.from(1).subscribe(Subscribers.empty());
+
+        final InOrder inOrder = inOrder(listener);
+        inOrder.verify(listener).start(subscribe());
+        inOrder.verify(listener).onNext(onNext(1));
+        inOrder.verify(listener).start(onNext(1));
+        inOrder.verify(listener).complete(any());
+        inOrder.verify(listener).start(onCompleted());
+        inOrder.verify(listener, times(2)).complete(any());
+        inOrder.verifyNoMoreInteractions();
 
-        verify(error, never()).call(any(), any());
+        listener.assertValidState();
     }
 
+    @SuppressWarnings("unchecked")
     @Test
     public void testOneOp() {
-        Func1<DebugNotification<Integer, Object>, Object> start = mock(Func1.class);
-        doAnswer(new Answer() {
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                Object context = new Object();
-                System.out.println("start: " + context.hashCode() + " " + invocation.getArguments()[0]);
-                return context;
-            }
-        }).when(start).call(any(DebugNotification.class));
-        Action1<Object> complete = mock(Action1.class);
-        doAnswer(new Answer() {
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                System.out.println("complete: " + invocation.getArguments()[0].hashCode());
-                return null;
-            }
-        }).when(complete).call(any());
-        Action2<Object, Throwable> error = mock(Action2.class);
-        doAnswer(new Answer() {
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                System.out.println("error: " + invocation.getArguments()[1].hashCode());
-                return null;
-            }
-        }).when(error).call(any(), any(Throwable.class));
-        final DebugHook hook = new DebugHook(null, start, complete, error);
+        TestDebugNotificationListener listener = new TestDebugNotificationListener();
+        listener = spy(listener);
+
+        // create and register the hooks.
+        final DebugHook<Object> hook = new DebugHook<Object>(listener);
         RxJavaPlugins.getInstance().registerObservableExecutionHook(hook);
-        Observable.from(Arrays.asList(1, 3)).flatMap(new Func1<Integer, Observable<Integer>>() {
+
+        // do the operation
+        Observable
+                .from(Arrays.asList(1, 3))
+                .flatMap(new Func1<Integer, Observable<Integer>>() {
+                    @Override
+                    public Observable<Integer> call(Integer it) {
+                        return Observable.from(Arrays.asList(it * 10, (it + 1) * 10));
+                    }
+                })
+                .take(3)
+                .subscribe(Subscribers.<Integer> empty());
+
+        InOrder calls = inOrder(listener);
+
+        calls.verify(listener).start(subscribe());
+        calls.verify(listener).start(onNext(1)); // from to map
+        calls.verify(listener).start(onNext(Observable.class)); // map to merge
+        calls.verify(listener).start(subscribe()); // merge inner
+        calls.verify(listener).start(onNext(10)); // from to merge inner
+        calls.verify(listener).start(onNext(10)); // merge inner to take
+        calls.verify(listener).start(onNext(10)); // take to empty subscriber
+        calls.verify(listener, times(3)).complete(any());
+        calls.verify(listener).start(onNext(20)); // next from to merge inner
+        calls.verify(listener).start(onNext(20)); // merge inner to take
+        calls.verify(listener).start(onNext(20)); // take to output
+        calls.verify(listener, times(3)).complete(any());
+        calls.verify(listener).start(onCompleted()); // sub from completes
+        // calls.verify(listener).start(unsubscribe()); // merge's composite subscription
+        // unnecessarily calls unsubscribe during the removing the subscription from the array.
+        //
+        // i didn't include it because it could cause a test failure if the internals change.
+        calls.verify(listener, times(5)).complete(any()); // pop the call stack up to onNext(1)
+        calls.verify(listener).start(onNext(3)); // from to map
+        calls.verify(listener).start(onNext(Observable.class)); // map to merge
+        calls.verify(listener).start(subscribe());
+        calls.verify(listener).start(onNext(30)); // next from to merge inner
+        calls.verify(listener).start(onNext(30)); // merge inner to take
+        calls.verify(listener).start(onNext(30)); // take to output
+        calls.verify(listener).complete(any());
+        calls.verify(listener).start(onCompleted()); // take to output
+        calls.verify(listener).start(unsubscribe()); // take unsubscribes
+        calls.verify(listener).complete(any());
+        calls.verify(listener).start(unsubscribe()); // merge inner unsubscribes
+        calls.verify(listener).complete(any());
+        calls.verify(listener).start(unsubscribe()); // merge outer unsubscribes
+        calls.verify(listener).complete(any());
+        calls.verify(listener).start(unsubscribe()); // map unsubscribe
+        calls.verify(listener, times(7)).complete(any());
+        calls.verifyNoMoreInteractions();
+
+        listener.assertValidState();
+    }
+
+    private static <T> DebugNotification<T> onNext(final T value) {
+        return argThat(new BaseMatcher<DebugNotification<T>>() {
             @Override
-            public Observable<Integer> call(Integer it) {
-                return Observable.from(Arrays.asList(it, it + 1));
+            public boolean matches(Object item) {
+                if (item instanceof DebugNotification) {
+                    @SuppressWarnings("unchecked")
+                    DebugNotification<T> dn = (DebugNotification<T>) item;
+                    return dn.getKind() == Kind.OnNext && dn.getValue().equals(value);
+                }
+                return false;
             }
-        }).take(3).subscribe(new Subscriber<Integer>() {
+
             @Override
-            public void onCompleted() {
+            public void describeTo(Description description) {
+                description.appendText("OnNext " + value);
             }
+        });
+    }
 
+    private static <T> DebugNotification<T> onNext(final Class<T> type) {
+        return argThat(new BaseMatcher<DebugNotification<T>>() {
             @Override
-            public void onError(Throwable e) {
+            public boolean matches(Object item) {
+                if (item instanceof DebugNotification) {
+                    @SuppressWarnings("unchecked")
+                    DebugNotification<T> dn = (DebugNotification<T>) item;
+                    return dn.getKind() == Kind.OnNext && type.isAssignableFrom(dn.getValue().getClass());
+                }
+                return false;
             }
 
             @Override
-            public void onNext(Integer t) {
+            public void describeTo(Description description) {
+                description.appendText("OnNext " + type);
             }
         });
-        verify(start, atLeast(3)).call(subscribe());
-        verify(start, times(4)).call(onNext(1));
-        // one less because it originates from the inner observable sent to merge
-        verify(start, times(3)).call(onNext(2));
-        verify(start, times(4)).call(onNext(3));
-        // because the take unsubscribes
-        verify(start, never()).call(onNext(4));
-
-        verify(complete, atLeast(14)).call(any());
-
-        verify(error, never()).call(any(), any(Throwable.class));
     }
 
-    private static <T, C> DebugNotification<T, C> onNext(final T value) {
-        return argThat(new BaseMatcher<DebugNotification<T, C>>() {
+    private static <T> DebugNotification subscribe() {
+        return argThat(new BaseMatcher<DebugNotification<T>>() {
             @Override
             public boolean matches(Object item) {
                 if (item instanceof DebugNotification) {
-                    DebugNotification<T, C> dn = (DebugNotification<T, C>) item;
-                    return dn.getKind() == Kind.OnNext && dn.getValue().equals(value);
+                    DebugNotification dn = (DebugNotification) item;
+                    return dn.getKind() == DebugNotification.Kind.Subscribe;
                 }
                 return false;
             }
 
             @Override
             public void describeTo(Description description) {
-                description.appendText("OnNext " + value);
+                description.appendText("Subscribe");
             }
         });
     }
 
-    private static DebugNotification subscribe() {
-        return argThat(new BaseMatcher<DebugNotification>() {
+    private static <T> DebugNotification unsubscribe() {
+        return argThat(new BaseMatcher<DebugNotification<T>>() {
             @Override
             public boolean matches(Object item) {
                 if (item instanceof DebugNotification) {
                     DebugNotification dn = (DebugNotification) item;
-                    return dn.getKind() == DebugNotification.Kind.Subscribe;
+                    return dn.getKind() == DebugNotification.Kind.Unsubscribe;
                 }
                 return false;
             }
 
             @Override
             public void describeTo(Description description) {
-                description.appendText("Subscribe");
+                description.appendText("Unsubscribe");
             }
         });
     }
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 893ec455eb..8e29da1e8f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -25,8 +25,8 @@
 import java.util.concurrent.TimeUnit;
 
 import rx.exceptions.Exceptions;
-import rx.exceptions.OnErrorThrowable;
 import rx.exceptions.OnErrorNotImplementedException;
+import rx.exceptions.OnErrorThrowable;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Action2;
@@ -115,8 +115,8 @@
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMerge;
 import rx.operators.OperatorObserveOn;
-import rx.operators.OperatorOnErrorResumeNextViaFunction;
 import rx.operators.OperatorOnErrorFlatMap;
+import rx.operators.OperatorOnErrorResumeNextViaFunction;
 import rx.operators.OperatorParallel;
 import rx.operators.OperatorRepeat;
 import rx.operators.OperatorScan;
@@ -171,10 +171,10 @@ public class Observable<T> {
      *            {@link OnSubscribe} to be executed when {@link #subscribe(Subscriber)} is called
      */
     protected Observable(OnSubscribe<T> f) {
-        this.f = hook.onCreate(f);
+        this.f = f;
     }
 
-    private final static RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
+    private final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
 
     /**
      * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
@@ -7041,7 +7041,7 @@ public final Subscription subscribe(Subscriber<? super T> observer) {
                 observer = new SafeSubscriber<T>(observer);
                 onSubscribeFunction.call(observer);
             }
-            final Subscription returnSubscription = hook.onSubscribeReturn(this, observer);
+            final Subscription returnSubscription = hook.onSubscribeReturn(observer);
             // we return it inside a Subscription so it can't be cast back to Subscriber
             return Subscriptions.create(new Action0() {
 
@@ -7056,7 +7056,7 @@ public void call() {
             Exceptions.throwIfFatal(e);
             // if an unhandled error occurs executing the onSubscribe we will propagate it
             try {
-                observer.onError(hook.onSubscribeError(this, e));
+                observer.onError(hook.onSubscribeError(e));
             } catch (OnErrorNotImplementedException e2) {
                 // special handling when onError is not implemented ... we just rethrow
                 throw e2;
@@ -7064,7 +7064,9 @@ public void call() {
                 // 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);
+                // TODO could the hook be the cause of the error in the on error handling.
+                hook.onSubscribeError(r);
+                // TODO why aren't we throwing the hook's return value.
                 throw r;
             }
             return Subscriptions.empty();
diff --git a/rxjava-core/src/main/java/rx/functions/Actions.java b/rxjava-core/src/main/java/rx/functions/Actions.java
index 9954ce5119..0a9f79726e 100644
--- a/rxjava-core/src/main/java/rx/functions/Actions.java
+++ b/rxjava-core/src/main/java/rx/functions/Actions.java
@@ -25,51 +25,63 @@ private Actions() {
         throw new IllegalStateException("No instances!");
     }
 
-    public static final EmptyAction empty() {
-        return EMPTY_ACTION;
+    @SuppressWarnings("unchecked")
+    public static final <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> empty() {
+        return (EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>) 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 {
+    private static final class EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> implements
+            Action0,
+            Action1<T0>,
+            Action2<T0, T1>,
+            Action3<T0, T1, T2>,
+            Action4<T0, T1, T2, T3>,
+            Action5<T0, T1, T2, T3, T4>,
+            Action6<T0, T1, T2, T3, T4, T5>,
+            Action7<T0, T1, T2, T3, T4, T5, T6>,
+            Action8<T0, T1, T2, T3, T4, T5, T6, T7>,
+            Action9<T0, T1, T2, T3, T4, T5, T6, T7, T8>,
+            ActionN {
         @Override
         public void call() {
         }
 
         @Override
-        public void call(Object t1) {
+        public void call(T0 t1) {
         }
 
         @Override
-        public void call(Object t1, Object t2) {
+        public void call(T0 t1, T1 t2) {
         }
 
         @Override
-        public void call(Object t1, Object t2, Object t3) {
+        public void call(T0 t1, T1 t2, T2 t3) {
         }
 
         @Override
-        public void call(Object t1, Object t2, Object t3, Object t4) {
+        public void call(T0 t1, T1 t2, T2 t3, T3 t4) {
         }
 
         @Override
-        public void call(Object t1, Object t2, Object t3, Object t4, Object t5) {
+        public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5) {
         }
 
         @Override
-        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6) {
+        public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6) {
         }
 
         @Override
-        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7) {
+        public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7) {
         }
 
         @Override
-        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8) {
+        public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8) {
         }
 
         @Override
-        public void call(Object t1, Object t2, Object t3, Object t4, Object t5, Object t6, Object t7, Object t8, Object t9) {
+        public void call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8, T8 t9) {
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/functions/Functions.java b/rxjava-core/src/main/java/rx/functions/Functions.java
index b30ad4e4d2..becfe31c43 100644
--- a/rxjava-core/src/main/java/rx/functions/Functions.java
+++ b/rxjava-core/src/main/java/rx/functions/Functions.java
@@ -358,4 +358,79 @@ public Boolean call(Object o) {
             return false;
         }
     }
+
+    @SuppressWarnings("unchecked")
+    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> returnNull() {
+        return (NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R>) NULL_FUNCTION;
+    }
+
+    private static final NullFunction NULL_FUNCTION = new NullFunction();
+
+    private static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
+            Func0<R>,
+            Func1<T0, R>,
+            Func2<T0, T1, R>,
+            Func3<T0, T1, T2, R>,
+            Func4<T0, T1, T2, T3, R>,
+            Func5<T0, T1, T2, T3, T4, R>,
+            Func6<T0, T1, T2, T3, T4, T5, R>,
+            Func7<T0, T1, T2, T3, T4, T5, T6, R>,
+            Func8<T0, T1, T2, T3, T4, T5, T6, T7, R>,
+            Func9<T0, T1, T2, T3, T4, T5, T6, T7, T8, R>,
+            FuncN<R> {
+        @Override
+        public R call() {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8, T8 t9) {
+            return null;
+        }
+
+        @Override
+        public R call(Object... args) {
+            return null;
+        }
+    }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OnSubscribeFromIterable.java b/rxjava-core/src/main/java/rx/operators/OnSubscribeFromIterable.java
index 45dbde9004..38766395f4 100644
--- a/rxjava-core/src/main/java/rx/operators/OnSubscribeFromIterable.java
+++ b/rxjava-core/src/main/java/rx/operators/OnSubscribeFromIterable.java
@@ -42,6 +42,9 @@ public void call(Subscriber<? super T> o) {
             }
             o.onNext(i);
         }
+        if (o.isUnsubscribed()) {
+            return;
+        }
         o.onCompleted();
     }
 
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 01e6c97507..64402fe0de 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -17,85 +17,108 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 
 /**
- * Abstract ExecutionHook with invocations at different lifecycle points of {@link Observable} execution with a default no-op implementation.
+ * Abstract ExecutionHook with invocations at different lifecycle points of {@link Observable}
+ * execution with a default no-op implementation.
  * <p>
  * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins: <a
- * href="https://github.com/Netflix/RxJava/wiki/Plugins">https://github.com/Netflix/RxJava/wiki/Plugins</a>.
+ * href ="https://github.com/Netflix/RxJava/wiki/Plugins">https://github.com/Netflix/RxJava/wiki/
+ * Plugins </a>.
  * <p>
  * <b>Note on thread-safety and performance</b>
  * <p>
- * A single implementation of this class will be used globally so methods on this class will be invoked concurrently from multiple threads so all functionality must be thread-safe.
+ * A single implementation of this class will be used globally so methods on this class will be
+ * invoked concurrently from multiple threads so all functionality must be thread-safe.
  * <p>
- * Methods are also invoked synchronously and will add to execution time of the observable so all behavior should be fast. If anything time-consuming is to be done it should be spawned asynchronously
- * onto separate worker threads.
+ * Methods are also invoked synchronously and will add to execution time of the observable so all
+ * behavior should be fast. If anything time-consuming is to be done it should be spawned
+ * asynchronously onto separate worker threads.
  * 
- * */
+ */
 public abstract class RxJavaObservableExecutionHook {
+    /**
+     * Invoked during the construction by {@link Observable#create(OnSubscribe)}
+     * <p>
+     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform
+     * extra logging, metrics and other such things and pass-thru the function.
+     * 
+     * @param onSubscribe
+     *            original {@link OnSubscribe}<{@code T}> to be executed
+     * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or
+     *         just returned as a pass-thru.
+     */
+    public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
+        return f;
+    }
+
     /**
      * Invoked before {@link Observable#subscribe(rx.Subscriber)} is about to be executed.
      * <p>
-     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra logging, metrics and other such things and pass-thru the function.
+     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform
+     * extra logging, metrics and other such things and pass-thru the function.
      * 
-     * @param observableInstance
-     *            The executing {@link Observable} instance.
      * @param onSubscribe
-     *            original {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}> to be executed
-     * @return {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}> function that can be modified, decorated, replaced or just returned as a pass-thru.
+     *            original {@link OnSubscribe}<{@code T}> to be executed
+     * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or
+     *         just returned as a pass-thru.
      */
-    public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> onSubscribe) {
+    public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInsance, final OnSubscribe<T> onSubscribe) {
         // pass-thru by default
         return onSubscribe;
     }
 
     /**
-     * Invoked after successful execution of {@link Observable#subscribe(rx.Subscriber)} with returned {@link Subscription}.
+     * Invoked after successful execution of {@link Observable#subscribe(rx.Subscriber)} with
+     * returned {@link Subscription}.
      * <p>
-     * This can be used to decorate or replace the {@link Subscription} instance or just perform extra logging, metrics and other such things and pass-thru the subscription.
+     * This can be used to decorate or replace the {@link Subscription} instance or just perform
+     * extra logging, metrics and other such things and pass-thru the subscription.
      * 
-     * @param observableInstance
-     *            The executing {@link Observable} instance.
      * @param subscription
      *            original {@link Subscription}
-     * @return {@link Subscription} subscription that can be modified, decorated, replaced or just returned as a pass-thru.
+     * @return {@link Subscription} subscription that can be modified, decorated, replaced or just
+     *         returned as a pass-thru.
      */
-    public <T> Subscription onSubscribeReturn(Observable<? extends T> observableInstance, Subscription subscription) {
+    public <T> Subscription onSubscribeReturn(Subscription subscription) {
         // pass-thru by default
         return subscription;
     }
 
     /**
-     * Invoked after failed execution of {@link Observable#subscribe(Subscriber)} with thrown Throwable.
+     * Invoked after failed execution of {@link Observable#subscribe(Subscriber)} with thrown
+     * Throwable.
      * <p>
-     * This is NOT errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown when attempting
-     * to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}>.
+     * This is NOT errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown
+     * when attempting to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>},
+     * {@link Subscription}>.
      * 
-     * @param observableInstance
-     *            The executing {@link Observable} instance.
      * @param e
      *            Throwable thrown by {@link Observable#subscribe(Subscriber)}
      * @return Throwable that can be decorated, replaced or just returned as a pass-thru.
      */
-    public <T> Throwable onSubscribeError(Observable<? extends T> observableInstance, Throwable e) {
+    public <T> Throwable onSubscribeError(Throwable e) {
         // pass-thru by default
         return e;
     }
 
-    public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
-        return f;
-    }
-
-    public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> bind) {
-        return bind;
-    }
-
-    public <T> Subscription onAdd(Subscriber<T> subscriber, Subscription s) {
-        return s;
+    /**
+     * Invoked just as the operator functions is called to bind two operations together into a new
+     * {@link Observable} and the return value is used as the lifted function
+     * <p>
+     * This can be used to decorate or replace the {@link Operator} instance or just perform extra
+     * logging, metrics and other such things and pass-thru the onSubscribe.
+     * 
+     * @param lift
+     *            original {@link Operator}{@code<R, T>} ' * @return {@link Operator}{@code <R, T>}
+     *            function that can be modified, decorated, replaced or
+     *            just returned as a pass-thru.
+     */
+    public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> lift) {
+        return lift;
     }
 }

From 68d40628a78db18ecb49d880798f1a03551ccd59 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 4 Mar 2014 22:30:18 -0800
Subject: [PATCH 071/422] math-module

Moving the average/sum/min/max functionality to the MathObservable similar to StringObservable.
---
 rxjava-contrib/rxjava-math/build.gradle       |  31 ++
 .../rx/math/operators/OperationAverage.java   | 348 ++++++++++++++++
 .../rx/math/operators/OperationMinMax.java    | 147 +++++++
 .../java/rx/math/operators/OperationSum.java  |  89 +++++
 .../java/rx/observables/MathObservable.java   | 378 ++++++++++++++++++
 .../math/operators/OperationAverageTest.java  | 342 ++++++++++++++++
 .../math/operators/OperationMinMaxTest.java   | 354 ++++++++++++++++
 .../rx/math/operators/OperationSumTest.java   | 346 ++++++++++++++++
 rxjava-core/src/main/java/rx/Observable.java  |  22 +-
 settings.gradle                               |   1 +
 10 files changed, 2057 insertions(+), 1 deletion(-)
 create mode 100644 rxjava-contrib/rxjava-math/build.gradle
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
 create mode 100644 rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java
 create mode 100644 rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
 create mode 100644 rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java

diff --git a/rxjava-contrib/rxjava-math/build.gradle b/rxjava-contrib/rxjava-math/build.gradle
new file mode 100644
index 0000000000..cbc8cca804
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/build.gradle
@@ -0,0 +1,31 @@
+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 = '<h2 class="title" style="padding-top:40px">RxJava</h2>'
+}
+
+jar {
+    manifest {
+        name = 'rxjava-math'
+        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-math/src/main/java/rx/math/operators/OperationAverage.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
new file mode 100644
index 0000000000..25d6bc7376
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
@@ -0,0 +1,348 @@
+/**
+ * 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.math.operators;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observer;
+import rx.Subscription;
+import rx.functions.Func1;
+import rx.functions.Func2;
+
+/**
+ * A few operators for implementing the averaging operation.
+ * 
+ * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average%28v=vs.103%29.aspx">MSDN: Observable.Average</a>
+ */
+public final class OperationAverage {
+    private static final class Tuple2<T> {
+        private final T current;
+        private final Integer count;
+
+        private Tuple2(T v1, Integer v2) {
+            current = v1;
+            count = v2;
+        }
+    }
+
+    public static Observable<Integer> average(Observable<Integer> source) {
+        return source.reduce(new Tuple2<Integer>(0, 0), new Func2<Tuple2<Integer>, Integer, Tuple2<Integer>>() {
+            @Override
+            public Tuple2<Integer> call(Tuple2<Integer> accu, Integer next) {
+                return new Tuple2<Integer>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Integer>, Integer>() {
+            @Override
+            public Integer call(Tuple2<Integer> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    public static Observable<Long> averageLongs(Observable<Long> source) {
+        return source.reduce(new Tuple2<Long>(0L, 0), new Func2<Tuple2<Long>, Long, Tuple2<Long>>() {
+            @Override
+            public Tuple2<Long> call(Tuple2<Long> accu, Long next) {
+                return new Tuple2<Long>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Long>, Long>() {
+            @Override
+            public Long call(Tuple2<Long> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    public static Observable<Float> averageFloats(Observable<Float> source) {
+        return source.reduce(new Tuple2<Float>(0.0f, 0), new Func2<Tuple2<Float>, Float, Tuple2<Float>>() {
+            @Override
+            public Tuple2<Float> call(Tuple2<Float> accu, Float next) {
+                return new Tuple2<Float>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Float>, Float>() {
+            @Override
+            public Float call(Tuple2<Float> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    public static Observable<Double> averageDoubles(Observable<Double> source) {
+        return source.reduce(new Tuple2<Double>(0.0d, 0), new Func2<Tuple2<Double>, Double, Tuple2<Double>>() {
+            @Override
+            public Tuple2<Double> call(Tuple2<Double> accu, Double next) {
+                return new Tuple2<Double>(accu.current + next, accu.count + 1);
+            }
+        }).map(new Func1<Tuple2<Double>, Double>() {
+            @Override
+            public Double call(Tuple2<Double> result) {
+                if (result.count == 0) {
+                    throw new IllegalArgumentException("Sequence contains no elements");
+                }
+                return result.current / result.count;
+            }
+        });
+    }
+
+    /**
+     * Compute the average by extracting integer values from the source via an
+     * extractor function.
+     * 
+     * @param <T>
+     *            the source value type
+     */
+    public static final class AverageIntegerExtractor<T> implements OnSubscribeFunc<Integer> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Integer> valueExtractor;
+
+        public AverageIntegerExtractor(Observable<? extends T> source, Func1<? super T, Integer> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Integer> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Integer> observer;
+            int sum;
+            int count;
+
+            public AverageObserver(Observer<? super Integer> 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 <T>
+     *            the source value type
+     */
+    public static final class AverageLongExtractor<T> implements OnSubscribeFunc<Long> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Long> valueExtractor;
+
+        public AverageLongExtractor(Observable<? extends T> source, Func1<? super T, Long> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Long> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Long> observer;
+            long sum;
+            int count;
+
+            public AverageObserver(Observer<? super Long> 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 <T>
+     *            the source value type
+     */
+    public static final class AverageFloatExtractor<T> implements OnSubscribeFunc<Float> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Float> valueExtractor;
+
+        public AverageFloatExtractor(Observable<? extends T> source, Func1<? super T, Float> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Float> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Float> observer;
+            float sum;
+            int count;
+
+            public AverageObserver(Observer<? super Float> 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 <T>
+     *            the source value type
+     */
+    public static final class AverageDoubleExtractor<T> implements OnSubscribeFunc<Double> {
+        final Observable<? extends T> source;
+        final Func1<? super T, Double> valueExtractor;
+
+        public AverageDoubleExtractor(Observable<? extends T> source, Func1<? super T, Double> valueExtractor) {
+            this.source = source;
+            this.valueExtractor = valueExtractor;
+        }
+
+        @Override
+        public Subscription onSubscribe(Observer<? super Double> t1) {
+            return source.subscribe(new AverageObserver(t1));
+        }
+
+        /** Computes the average. */
+        private final class AverageObserver implements Observer<T> {
+            final Observer<? super Double> observer;
+            double sum;
+            int count;
+
+            public AverageObserver(Observer<? super Double> 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-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java
new file mode 100644
index 0000000000..cfa92d4fce
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java
@@ -0,0 +1,147 @@
+/**
+ * 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.math.operators;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import rx.Observable;
+import rx.functions.Func1;
+import rx.functions.Func2;
+
+/**
+ * Returns the minimum element in an observable sequence.
+ */
+public class OperationMinMax {
+
+    public static <T extends Comparable<? super T>> Observable<T> min(
+            Observable<T> source) {
+        return minMax(source, -1L);
+    }
+
+    public static <T> Observable<T> min(Observable<T> source,
+            final Comparator<? super T> comparator) {
+        return minMax(source, comparator, -1L);
+    }
+
+    public static <T, R extends Comparable<? super R>> Observable<List<T>> minBy(
+            Observable<T> source, final Func1<T, R> selector) {
+        return minMaxBy(source, selector, -1L);
+    }
+
+    public static <T, R> Observable<List<T>> minBy(Observable<T> source,
+            final Func1<T, R> selector, final Comparator<? super R> comparator) {
+        return minMaxBy(source, selector, comparator, -1L);
+    }
+
+    public static <T extends Comparable<? super T>> Observable<T> max(
+            Observable<T> source) {
+        return minMax(source, 1L);
+    }
+
+    public static <T> Observable<T> max(Observable<T> source,
+            final Comparator<? super T> comparator) {
+        return minMax(source, comparator, 1L);
+    }
+
+    public static <T, R extends Comparable<? super R>> Observable<List<T>> maxBy(
+            Observable<T> source, final Func1<T, R> selector) {
+        return minMaxBy(source, selector, 1L);
+    }
+
+    public static <T, R> Observable<List<T>> maxBy(Observable<T> source,
+            final Func1<T, R> selector, final Comparator<? super R> comparator) {
+        return minMaxBy(source, selector, comparator, 1L);
+    }
+
+    private static <T extends Comparable<? super T>> Observable<T> minMax(
+            Observable<T> source, final long flag) {
+        return source.reduce(new Func2<T, T, T>() {
+            @Override
+            public T call(T acc, T value) {
+                if (flag * acc.compareTo(value) > 0) {
+                    return acc;
+                }
+                return value;
+            }
+        });
+    }
+
+    private static <T> Observable<T> minMax(Observable<T> source,
+            final Comparator<? super T> comparator, final long flag) {
+        return source.reduce(new Func2<T, T, T>() {
+            @Override
+            public T call(T acc, T value) {
+                if (flag * comparator.compare(acc, value) > 0) {
+                    return acc;
+                }
+                return value;
+            }
+        });
+    }
+
+    private static <T, R extends Comparable<? super R>> Observable<List<T>> minMaxBy(
+            Observable<T> source, final Func1<T, R> selector, final long flag) {
+        return source.reduce(new ArrayList<T>(),
+                new Func2<List<T>, T, List<T>>() {
+
+                    @Override
+                    public List<T> call(List<T> acc, T value) {
+                        if (acc.isEmpty()) {
+                            acc.add(value);
+                        } else {
+                            int compareResult = selector.call(acc.get(0))
+                                    .compareTo(selector.call(value));
+                            if (compareResult == 0) {
+                                acc.add(value);
+                            } else if (flag * compareResult < 0) {
+                                acc.clear();
+                                acc.add(value);
+                            }
+                        }
+                        return acc;
+                    }
+                });
+    }
+
+    private static <T, R> Observable<List<T>> minMaxBy(Observable<T> source,
+            final Func1<T, R> selector, final Comparator<? super R> comparator,
+            final long flag) {
+        return source.reduce(new ArrayList<T>(),
+                new Func2<List<T>, T, List<T>>() {
+
+                    @Override
+                    public List<T> call(List<T> acc, T value) {
+                        if (acc.isEmpty()) {
+                            acc.add(value);
+                        } else {
+                            int compareResult = comparator.compare(
+                                    selector.call(acc.get(0)),
+                                    selector.call(value));
+                            if (compareResult == 0) {
+                                acc.add(value);
+                            } else if (flag * compareResult < 0) {
+                                acc.clear();
+                                acc.add(value);
+                            }
+                        }
+                        return acc;
+                    }
+                });
+    }
+
+}
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java
new file mode 100644
index 0000000000..3d519e4220
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.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.math.operators;
+
+import rx.Observable;
+import rx.functions.Func2;
+
+/**
+ * A few operators for implementing the sum operation.
+ * 
+ * @see <a
+ *      href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum%28v=vs.103%29.aspx">MSDN:
+ *      Observable.Sum</a>
+ */
+public final class OperationSum {
+
+    public static Observable<Integer> sumIntegers(Observable<Integer> source) {
+        return source.reduce(0, ACCUM_INT);
+    }
+
+    public static Observable<Long> sumLongs(Observable<Long> source) {
+        return source.reduce(0l, ACCUM_LONG);
+    }
+
+    public static Observable<Float> sumFloats(Observable<Float> source) {
+        return source.reduce(0.0f, ACCUM_FLOAT);
+    }
+
+    public static Observable<Double> sumDoubles(Observable<Double> source) {
+        return source.reduce(0.0d, ACCUM_DOUBLE);
+    }
+
+    public static Observable<Integer> sumAtLeastOneIntegers(Observable<Integer> source) {
+        return source.reduce(ACCUM_INT);
+    }
+
+    public static Observable<Long> sumAtLeastOneLongs(Observable<Long> source) {
+        return source.reduce(ACCUM_LONG);
+    }
+
+    public static Observable<Float> sumAtLeastOneFloats(Observable<Float> source) {
+        return source.reduce(ACCUM_FLOAT);
+    }
+
+    public static Observable<Double> sumAtLeastOneDoubles(Observable<Double> source) {
+        return source.reduce(ACCUM_DOUBLE);
+    }
+
+    private static final Func2<Integer, Integer, Integer> ACCUM_INT = new Func2<Integer, Integer, Integer>() {
+        @Override
+        public Integer call(Integer accu, Integer next) {
+            return accu + next;
+        }
+    };
+
+    private static final Func2<Long, Long, Long> ACCUM_LONG = new Func2<Long, Long, Long>() {
+        @Override
+        public Long call(Long accu, Long next) {
+            return accu + next;
+        }
+    };
+
+    private static final Func2<Float, Float, Float> ACCUM_FLOAT = new Func2<Float, Float, Float>() {
+        @Override
+        public Float call(Float accu, Float next) {
+            return accu + next;
+        }
+    };
+
+    private static final Func2<Double, Double, Double> ACCUM_DOUBLE = new Func2<Double, Double, Double>() {
+        @Override
+        public Double call(Double accu, Double next) {
+            return accu + next;
+        }
+    };
+}
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java b/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
new file mode 100644
index 0000000000..2614983bf8
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
@@ -0,0 +1,378 @@
+/**
+ * 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.observables;
+
+import java.util.Comparator;
+
+import rx.Observable;
+import rx.functions.Func1;
+import rx.math.operators.OperationAverage;
+import rx.math.operators.OperationMinMax;
+import rx.math.operators.OperationSum;
+
+public class MathObservable<T> {
+
+    private final Observable<T> o;
+
+    private MathObservable(Observable<T> o) {
+        this.o = o;
+    }
+
+    public static <T> MathObservable<T> from(Observable<T> o) {
+        return new MathObservable<T>(o);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Doubles emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Double> averageDouble(Observable<Double> source) {
+        return OperationAverage.averageDoubles(source);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Floats emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Float> averageFloat(Observable<Float> source) {
+        return OperationAverage.averageFloats(source);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Integers emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @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
+     * @throws IllegalArgumentException
+     *             if the source Observable emits no items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Integer> averageInteger(Observable<Integer> source) {
+        return OperationAverage.average(source);
+    }
+
+    /**
+     * Returns an Observable that emits the average of the Longs emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final static Observable<Long> averageLong(Observable<Long> source) {
+        return OperationAverage.averageLongs(source);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/max.png">
+     * 
+     * @param source
+     *            an Observable to scan for the maximum emitted item
+     * @return an Observable that emits this maximum item
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211837.aspx">MSDN: Observable.Max</a>
+     */
+    public final static <T extends Comparable<? super T>> Observable<T> max(Observable<T> source) {
+        return OperationMinMax.max(source);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/min.png">
+     * 
+     * @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 <a href="http://msdn.microsoft.com/en-us/library/hh229715.aspx">MSDN: Observable.Min</a>
+     */
+    public final static <T extends Comparable<? super T>> Observable<T> min(Observable<T> source) {
+        return OperationMinMax.min(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Doubles emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @param source
+     *            the source Observable to compute the sum of
+     * @return an Observable that emits a single item: the sum of all the Doubles emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Double> sumDouble(Observable<Double> source) {
+        return OperationSum.sumDoubles(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Floats emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Float> sumFloat(Observable<Float> source) {
+        return OperationSum.sumFloats(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Integers emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Integer> sumInteger(Observable<Integer> source) {
+        return OperationSum.sumIntegers(source);
+    }
+
+    /**
+     * Returns an Observable that emits the sum of all the Longs emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
+     * 
+     * @param source
+     *            source Observable to compute the sum of
+     * @return an Observable that emits a single item: the sum of all the Longs emitted by the
+     *         source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final static Observable<Long> sumLong(Observable<Long> source) {
+        return OperationSum.sumLongs(source);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageDoubleExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageFloatExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageIntegerExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     */
+    public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor) {
+        return Observable.create(new OperationAverage.AverageLongExtractor<T>(o, valueExtractor));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/max.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211635.aspx">MSDN: Observable.Max</a>
+     */
+    public final Observable<T> max(Comparator<? super T> comparator) {
+        return OperationMinMax.max(o, comparator);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/min.png">
+     * 
+     * @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
+     * @throws IllegalArgumentException
+     *             if the source is empty
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-min">RxJava Wiki: min()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229095.aspx">MSDN: Observable.Min</a>
+     */
+    public final Observable<T> min(Comparator<? super T> comparator) {
+        return OperationMinMax.min(o, comparator);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtractor) {
+        return OperationSum.sumAtLeastOneDoubles(o.map(valueExtractor));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor) {
+        return OperationSum.sumAtLeastOneFloats(o.map(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtractor) {
+        return OperationSum.sumAtLeastOneIntegers(o.map(valueExtractor));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     */
+    public final Observable<Long> sumLong(Func1<? super T, Long> valueExtractor) {
+        return OperationSum.sumAtLeastOneLongs(o.map(valueExtractor));
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java
new file mode 100644
index 0000000000..a77868dc7a
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java
@@ -0,0 +1,342 @@
+/**
+ * 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.math.operators;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.math.operators.OperationAverage.*;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observer;
+import rx.functions.Func1;
+import rx.observables.MathObservable;
+
+public class OperationAverageTest {
+
+    @SuppressWarnings("unchecked")
+    Observer<Integer> w = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Long> wl = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Float> wf = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Double> wd = mock(Observer.class);
+
+    @Test
+    public void testAverageOfAFewInts() throws Throwable {
+        Observable<Integer> src = Observable.from(1, 2, 3, 4, 6);
+        average(src).subscribe(w);
+
+        verify(w, times(1)).onNext(anyInt());
+        verify(w).onNext(3);
+        verify(w, never()).onError(any(Throwable.class));
+        verify(w, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverage() throws Throwable {
+        Observable<Integer> src = Observable.empty();
+        average(src).subscribe(w);
+
+        verify(w, never()).onNext(anyInt());
+        verify(w, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(w, never()).onCompleted();
+    }
+
+    @Test
+    public void testAverageOfAFewLongs() throws Throwable {
+        Observable<Long> src = Observable.from(1L, 2L, 3L, 4L, 6L);
+        averageLongs(src).subscribe(wl);
+
+        verify(wl, times(1)).onNext(anyLong());
+        verify(wl).onNext(3L);
+        verify(wl, never()).onError(any(Throwable.class));
+        verify(wl, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverageLongs() throws Throwable {
+        Observable<Long> src = Observable.empty();
+        averageLongs(src).subscribe(wl);
+
+        verify(wl, never()).onNext(anyLong());
+        verify(wl, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(wl, never()).onCompleted();
+    }
+
+    @Test
+    public void testAverageOfAFewFloats() throws Throwable {
+        Observable<Float> src = Observable.from(1.0f, 2.0f);
+        averageFloats(src).subscribe(wf);
+
+        verify(wf, times(1)).onNext(anyFloat());
+        verify(wf).onNext(1.5f);
+        verify(wf, never()).onError(any(Throwable.class));
+        verify(wf, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverageFloats() throws Throwable {
+        Observable<Float> src = Observable.empty();
+        averageFloats(src).subscribe(wf);
+
+        verify(wf, never()).onNext(anyFloat());
+        verify(wf, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(wf, never()).onCompleted();
+    }
+
+    @Test
+    public void testAverageOfAFewDoubles() throws Throwable {
+        Observable<Double> src = Observable.from(1.0d, 2.0d);
+        averageDoubles(src).subscribe(wd);
+
+        verify(wd, times(1)).onNext(anyDouble());
+        verify(wd).onNext(1.5d);
+        verify(wd, never()).onError(any(Throwable.class));
+        verify(wd, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptyAverageDoubles() throws Throwable {
+        Observable<Double> src = Observable.empty();
+        averageDoubles(src).subscribe(wd);
+
+        verify(wd, never()).onNext(anyDouble());
+        verify(wd, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(wd, never()).onCompleted();
+    }
+
+    void testThrows(Observer<Object> o, Class<? extends Throwable> errorClass) {
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o, times(1)).onError(any(errorClass));
+    }
+
+    <N extends Number> void testValue(Observer<Object> 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<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2);
+    }
+
+    @Test
+    public void testLongAverageSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).averageLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2L);
+    }
+
+    @Test
+    public void testFloatAverageSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2.5f);
+    }
+
+    @Test
+    public void testDoubleAverageSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 2.5d);
+    }
+
+    @Test
+    public void testIntegerAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testLongAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).averageLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testFloatAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testDoubleAverageSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testIntegerAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testLongAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).averageLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testFloatAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testDoubleAverageSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+    
+    static class CustomException extends RuntimeException {
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
new file mode 100644
index 0000000000..63eee7b28f
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
@@ -0,0 +1,354 @@
+/**
+ * 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.math.operators;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.math.operators.OperationMinMax.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import rx.Observable;
+import rx.Observer;
+import rx.functions.Func1;
+
+public class OperationMinMaxTest {
+    @Test
+    public void testMin() {
+        Observable<Integer> observable = min(Observable.from(2, 3, 1, 4));
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) 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 testMinWithEmpty() {
+        Observable<Integer> observable = min(Observable.<Integer> empty());
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinWithComparator() {
+        Observable<Integer> observable = min(Observable.from(2, 3, 1, 4),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(4);
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinWithComparatorAndEmpty() {
+        Observable<Integer> observable = min(Observable.<Integer> empty(),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinBy() {
+        Observable<List<String>> observable = minBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinByWithEmpty() {
+        Observable<List<String>> observable = minBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinByWithComparator() {
+        Observable<List<String>> observable = minBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMinByWithComparatorAndEmpty() {
+        Observable<List<String>> observable = minBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMax() {
+        Observable<Integer> observable = max(Observable.from(2, 3, 1, 4));
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(4);
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxWithEmpty() {
+        Observable<Integer> observable = max(Observable.<Integer> empty());
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxWithComparator() {
+        Observable<Integer> observable = max(Observable.from(2, 3, 1, 4),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) 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 testMaxWithComparatorAndEmpty() {
+        Observable<Integer> observable = max(Observable.<Integer> empty(),
+                new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onError(
+                isA(IllegalArgumentException.class));
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxBy() {
+        Observable<List<String>> observable = maxBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxByWithEmpty() {
+        Observable<List<String>> observable = maxBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxByWithComparator() {
+        Observable<List<String>> observable = maxBy(
+                Observable.from("1", "2", "3", "4", "5", "6"),
+                new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6"));
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+
+    @Test
+    public void testMaxByWithComparatorAndEmpty() {
+        Observable<List<String>> observable = maxBy(
+                Observable.<String> empty(), new Func1<String, Integer>() {
+                    @Override
+                    public Integer call(String t1) {
+                        return Integer.parseInt(t1) % 2;
+                    }
+                }, new Comparator<Integer>() {
+                    @Override
+                    public int compare(Integer o1, Integer o2) {
+                        return o2 - o1;
+                    }
+                });
+
+        @SuppressWarnings("unchecked")
+        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
+
+        observable.subscribe(observer);
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
+        inOrder.verify(observer, times(1)).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+}
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java
new file mode 100644
index 0000000000..43e2805d43
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java
@@ -0,0 +1,346 @@
+/**
+ * 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.math.operators;
+
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+import static rx.math.operators.OperationSum.*;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observer;
+import rx.functions.Func1;
+import rx.observables.MathObservable;
+
+public class OperationSumTest {
+
+    @SuppressWarnings("unchecked")
+    Observer<Integer> w = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Long> wl = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Float> wf = mock(Observer.class);
+    @SuppressWarnings("unchecked")
+    Observer<Double> wd = mock(Observer.class);
+
+    @Test
+    public void testSumOfAFewInts() throws Throwable {
+        Observable<Integer> src = Observable.from(1, 2, 3, 4, 5);
+        sumIntegers(src).subscribe(w);
+
+        verify(w, times(1)).onNext(anyInt());
+        verify(w).onNext(15);
+        verify(w, never()).onError(any(Throwable.class));
+        verify(w, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySum() throws Throwable {
+        Observable<Integer> src = Observable.empty();
+        sumIntegers(src).subscribe(w);
+
+        verify(w, times(1)).onNext(anyInt());
+        verify(w).onNext(0);
+        verify(w, never()).onError(any(Throwable.class));
+        verify(w, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSumOfAFewLongs() throws Throwable {
+        Observable<Long> src = Observable.from(1L, 2L, 3L, 4L, 5L);
+        sumLongs(src).subscribe(wl);
+
+        verify(wl, times(1)).onNext(anyLong());
+        verify(wl).onNext(15L);
+        verify(wl, never()).onError(any(Throwable.class));
+        verify(wl, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySumLongs() throws Throwable {
+        Observable<Long> src = Observable.empty();
+        sumLongs(src).subscribe(wl);
+
+        verify(wl, times(1)).onNext(anyLong());
+        verify(wl).onNext(0L);
+        verify(wl, never()).onError(any(Throwable.class));
+        verify(wl, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSumOfAFewFloats() throws Throwable {
+        Observable<Float> src = Observable.from(1.0f);
+        sumFloats(src).subscribe(wf);
+
+        verify(wf, times(1)).onNext(anyFloat());
+        verify(wf).onNext(1.0f);
+        verify(wf, never()).onError(any(Throwable.class));
+        verify(wf, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySumFloats() throws Throwable {
+        Observable<Float> src = Observable.empty();
+        sumFloats(src).subscribe(wf);
+
+        verify(wf, times(1)).onNext(anyFloat());
+        verify(wf).onNext(0.0f);
+        verify(wf, never()).onError(any(Throwable.class));
+        verify(wf, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testSumOfAFewDoubles() throws Throwable {
+        Observable<Double> src = Observable.from(0.0d, 1.0d, 0.5d);
+        sumDoubles(src).subscribe(wd);
+
+        verify(wd, times(1)).onNext(anyDouble());
+        verify(wd).onNext(1.5d);
+        verify(wd, never()).onError(any(Throwable.class));
+        verify(wd, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testEmptySumDoubles() throws Throwable {
+        Observable<Double> src = Observable.empty();
+        sumDoubles(src).subscribe(wd);
+
+        verify(wd, times(1)).onNext(anyDouble());
+        verify(wd).onNext(0.0d);
+        verify(wd, never()).onError(any(Throwable.class));
+        verify(wd, times(1)).onCompleted();
+    }
+
+    void testThrows(Observer<Object> o, Class<? extends Throwable> errorClass) {
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o, times(1)).onError(any(errorClass));
+    }
+
+    <N extends Number> void testValue(Observer<Object> 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<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10);
+    }
+
+    @Test
+    public void testLongSumSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).sumLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10L);
+    }
+
+    @Test
+    public void testFloatSumSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10f);
+    }
+
+    @Test
+    public void testDoubleSumSelector() {
+        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testValue(o, 10d);
+    }
+
+    @Test
+    public void testIntegerSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                return t1.length();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testLongSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                return (long) t1.length();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).sumLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testFloatSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                return (float) t1.length();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testDoubleSumSelectorEmpty() {
+        Observable<String> source = Observable.empty();
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                return (double) t1.length();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, IllegalArgumentException.class);
+    }
+
+    @Test
+    public void testIntegerSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Integer> length = new Func1<String, Integer>() {
+            @Override
+            public Integer call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testLongSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Long> length = new Func1<String, Long>() {
+            @Override
+            public Long call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Long> result = MathObservable.from(source).sumLong(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testFloatSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Float> length = new Func1<String, Float>() {
+            @Override
+            public Float call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    @Test
+    public void testDoubleSumSelectorThrows() {
+        Observable<String> source = Observable.from("a");
+        Func1<String, Double> length = new Func1<String, Double>() {
+            @Override
+            public Double call(String t1) {
+                throw new CustomException();
+            }
+        };
+
+        Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        Observer<Object> o = mock(Observer.class);
+        result.subscribe(o);
+
+        testThrows(o, CustomException.class);
+    }
+
+    static class CustomException extends RuntimeException {
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c244fb5001..92ae1c7c40 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -441,6 +441,7 @@ public final static Observable<Integer> average(Observable<Integer> source) {
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Double> averageDouble(Observable<Double> source) {
         return OperationAverage.averageDoubles(source);
@@ -457,6 +458,7 @@ public final static Observable<Double> averageDouble(Observable<Double> source)
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Float> averageFloat(Observable<Float> source) {
         return OperationAverage.averageFloats(source);
@@ -475,6 +477,7 @@ public final static Observable<Float> averageFloat(Observable<Float> source) {
      *             if the source Observable emits no items
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Integer> averageInteger(Observable<Integer> source) {
         return OperationAverage.average(source);
@@ -491,6 +494,7 @@ public final static Observable<Integer> averageInteger(Observable<Integer> sourc
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Long> averageLong(Observable<Long> source) {
         return OperationAverage.averageLongs(source);
@@ -1595,6 +1599,7 @@ public final static <T> Observable<T> just(T value, Scheduler scheduler) {
      *             if the source is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211837.aspx">MSDN: Observable.Max</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static <T extends Comparable<? super T>> Observable<T> max(Observable<T> source) {
         return OperationMinMax.max(source);
@@ -2309,6 +2314,7 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @throws IllegalArgumentException
      *             if the source is empty
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229715.aspx">MSDN: Observable.Min</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static <T extends Comparable<? super T>> Observable<T> min(Observable<T> source) {
         return OperationMinMax.min(source);
@@ -2485,7 +2491,7 @@ public final Boolean call(T first, T second) {
     public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
         return OperationSequenceEqual.sequenceEqual(first, second, equality);
     }
-
+    
     /**
      * Returns an Observable that emits the sum of all the Doubles emitted by the source Observable.
      * <p>
@@ -2497,6 +2503,7 @@ public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Double> sumDouble(Observable<Double> source) {
         return OperationSum.sumDoubles(source);
@@ -2513,6 +2520,7 @@ public final static Observable<Double> sumDouble(Observable<Double> source) {
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Float> sumFloat(Observable<Float> source) {
         return OperationSum.sumFloats(source);
@@ -2529,6 +2537,7 @@ public final static Observable<Float> sumFloat(Observable<Float> source) {
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Integer> sumInteger(Observable<Integer> source) {
         return OperationSum.sumIntegers(source);
@@ -2545,6 +2554,7 @@ public final static Observable<Integer> sumInteger(Observable<Integer> source) {
      *         source Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final static Observable<Long> sumLong(Observable<Long> source) {
         return OperationSum.sumLongs(source);
@@ -3413,6 +3423,7 @@ public final Observable<T> asObservable() {
      *         emitted by the source Observable when transformed into Doubles by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtractor) {
         return create(new OperationAverage.AverageDoubleExtractor<T>(this, valueExtractor));
@@ -3430,6 +3441,7 @@ public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtr
      *         emitted by the source Observable when transformed into Floats by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtractor) {
         return create(new OperationAverage.AverageFloatExtractor<T>(this, valueExtractor));
@@ -3447,6 +3459,7 @@ public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtract
      *         emitted by the source Observable when transformed into Integers by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueExtractor) {
         return create(new OperationAverage.AverageIntegerExtractor<T>(this, valueExtractor));
@@ -3464,6 +3477,7 @@ public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueE
      *         emitted by the source Observable when transformed into Longs by the specified function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor) {
         return create(new OperationAverage.AverageLongExtractor<T>(this, valueExtractor));
@@ -4843,6 +4857,7 @@ public final Observable<Notification<T>> materialize() {
      *             if the source is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211635.aspx">MSDN: Observable.Max</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<T> max(Comparator<? super T> comparator) {
         return OperationMinMax.max(this, comparator);
@@ -5011,6 +5026,7 @@ public final <U, R> Observable<R> mergeMapIterable(Func1<? super T, ? extends It
      *             if the source is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-min">RxJava Wiki: min()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229095.aspx">MSDN: Observable.Min</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<T> min(Comparator<? super T> comparator) {
         return OperationMinMax.min(this, comparator);
@@ -7053,6 +7069,7 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
      *         by the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtractor) {
         return OperationSum.sumAtLeastOneDoubles(map(valueExtractor));
@@ -7070,6 +7087,7 @@ public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtracto
      *         the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor) {
         return OperationSum.sumAtLeastOneFloats(map(valueExtractor));
@@ -7087,6 +7105,7 @@ public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor)
      *         by the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtractor) {
         return OperationSum.sumAtLeastOneIntegers(map(valueExtractor));
@@ -7104,6 +7123,7 @@ public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtra
      *         the source Observable as transformed by the provided function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
+     * @deprecated Use rxjava-math module instead
      */
     public final Observable<Long> sumLong(Func1<? super T, Long> valueExtractor) {
         return OperationSum.sumAtLeastOneLongs(map(valueExtractor));
diff --git a/settings.gradle b/settings.gradle
index 5be4134cef..5a9e3e8cb0 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -9,6 +9,7 @@ include 'rxjava-core', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-apache-http', \
 'rxjava-contrib:rxjava-string', \
+'rxjava-contrib:rxjava-math', \
 'rxjava-contrib:rxjava-debug', \
 'rxjava-contrib:rxjava-async-util', \
 'rxjava-contrib:rxjava-computation-expressions'

From d08df0bfd1983c56eac0f90593de92e890c452a3 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 5 Mar 2014 21:53:31 -0800
Subject: [PATCH 072/422] OperationRetry -> OperatorRetry

Updated to use "lift" and Subscriber.
Fixes https://github.com/Netflix/RxJava/issues/943 Observable.retry() does not unsubscribe from source
---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../java/rx/operators/OperationRetry.java     | 104 -----------------
 .../main/java/rx/operators/OperatorRetry.java | 110 ++++++++++++++++++
 ...nRetryTest.java => OperatorRetryTest.java} |  28 ++++-
 4 files changed, 135 insertions(+), 111 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationRetry.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorRetry.java
 rename rxjava-core/src/test/java/rx/operators/{OperationRetryTest.java => OperatorRetryTest.java} (83%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 92ae1c7c40..0db0910764 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5985,7 +5985,7 @@ public final ConnectableObservable<T> replay(Scheduler scheduler) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-retry">RxJava Wiki: retry()</a>
      */
     public final Observable<T> retry() {
-        return create(OperationRetry.retry(this));
+        return nest().lift(new OperatorRetry<T>());
     }
 
     /**
@@ -6009,7 +6009,7 @@ public final Observable<T> retry() {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-retry">RxJava Wiki: retry()</a>
      */
     public final Observable<T> retry(int retryCount) {
-        return create(OperationRetry.retry(this, retryCount));
+        return nest().lift(new OperatorRetry<T>(retryCount));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRetry.java b/rxjava-core/src/main/java/rx/operators/OperationRetry.java
deleted file mode 100644
index ece2358a6c..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationRetry.java
+++ /dev/null
@@ -1,104 +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;
-
-/**
- * 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.
- */
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler.Inner;
-import rx.Subscription;
-import rx.functions.Action1;
-import rx.schedulers.Schedulers;
-
-public class OperationRetry {
-
-    private static final int INFINITE_RETRY = -1;
-
-    public static <T> OnSubscribeFunc<T> retry(final Observable<T> observable, final int retryCount) {
-        return new Retry<T>(observable, retryCount);
-    }
-
-    public static <T> OnSubscribeFunc<T> retry(final Observable<T> observable) {
-        return new Retry<T>(observable, INFINITE_RETRY);
-    }
-
-    private static class Retry<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<T> source;
-        private final int retryCount;
-        private final AtomicInteger attempts = new AtomicInteger(0);
-
-        public Retry(Observable<T> source, int retryCount) {
-            this.source = source;
-            this.retryCount = retryCount;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            return Schedulers.trampoline().schedule(new Action1<Inner>() {
-
-                @Override
-                public void call(final Inner inner) {
-                    final Action1<Inner> _self = this;
-                    attempts.incrementAndGet();
-                    source.subscribe(new Observer<T>() {
-
-                        @Override
-                        public void onCompleted() {
-                            observer.onCompleted();
-                        }
-
-                        @Override
-                        public void onError(Throwable e) {
-                            if ((retryCount == INFINITE_RETRY || attempts.get() <= retryCount) && !inner.isUnsubscribed()) {
-                                // retry again
-                                inner.schedule(_self);
-                            } else {
-                                // give up and pass the failure
-                                observer.onError(e);
-                            }
-                        }
-
-                        @Override
-                        public void onNext(T v) {
-                            observer.onNext(v);
-                        }
-
-                    });
-                }
-            });
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
new file mode 100644
index 0000000000..9f3ea2f5cc
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -0,0 +1,110 @@
+/**
+ * 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 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.
+ */
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.functions.Action1;
+import rx.schedulers.Schedulers;
+
+public class OperatorRetry<T> implements Operator<T, Observable<T>> {
+
+    private static final int INFINITE_RETRY = -1;
+
+    private final int retryCount;
+    private final AtomicInteger attempts = new AtomicInteger(0);
+
+    public OperatorRetry(int retryCount) {
+        this.retryCount = retryCount;
+    }
+
+    public OperatorRetry() {
+        this(INFINITE_RETRY);
+    }
+
+    @Override
+    public Subscriber<? super Observable<T>> call(final Subscriber<? super T> s) {
+        return new Subscriber<Observable<T>>(s) {
+
+            @Override
+            public void onCompleted() {
+                // ignore as we expect a single nested Observable<T>
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+            }
+
+            @Override
+            public void onNext(final Observable<T> o) {
+                Schedulers.trampoline().schedule(new Action1<Inner>() {
+
+                    @Override
+                    public void call(final Inner inner) {
+                        final Action1<Inner> _self = this;
+                        attempts.incrementAndGet();
+                        o.subscribe(new Subscriber<T>(s) {
+
+                            @Override
+                            public void onCompleted() {
+                                s.onCompleted();
+                            }
+
+                            @Override
+                            public void onError(Throwable e) {
+                                if ((retryCount == INFINITE_RETRY || attempts.get() <= retryCount) && !inner.isUnsubscribed()) {
+                                    // retry again
+                                    inner.schedule(_self);
+                                } else {
+                                    // give up and pass the failure
+                                    s.onError(e);
+                                }
+                            }
+
+                            @Override
+                            public void onNext(T v) {
+                                s.onNext(v);
+                            }
+
+                        });
+                    }
+                });
+            }
+
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationRetryTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
similarity index 83%
rename from rxjava-core/src/test/java/rx/operators/OperationRetryTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
index f49c2ac572..6fbcf19678 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationRetryTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
@@ -15,9 +15,10 @@
  */
 package rx.operators;
 
+import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationRetry.*;
+import static rx.operators.OperatorRetry.*;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -27,9 +28,11 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.functions.Action1;
+import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 
-public class OperationRetryTest {
+public class OperatorRetryTest {
 
     @Test
     public void testOriginFails() {
@@ -52,7 +55,7 @@ public void testRetryFail() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         Observable<String> origin = Observable.create(new FuncWithErrors(NUM_FAILURES));
-        Observable.create(retry(origin, NUM_RETRIES)).subscribe(observer);
+        origin.nest().lift(new OperatorRetry<String>(NUM_RETRIES)).subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
         // should show 2 attempts (first time fail, second time (1st retry) fail)
@@ -72,7 +75,7 @@ public void testRetrySuccess() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         Observable<String> origin = Observable.create(new FuncWithErrors(NUM_FAILURES));
-        Observable.create(retry(origin, NUM_RETRIES)).subscribe(observer);
+        origin.nest().lift(new OperatorRetry<String>(NUM_RETRIES)).subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
         // should show 3 attempts
@@ -92,7 +95,7 @@ public void testInfiniteRetry() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         Observable<String> origin = Observable.create(new FuncWithErrors(NUM_FAILURES));
-        Observable.create(retry(origin)).subscribe(observer);
+        origin.nest().lift(new OperatorRetry<String>()).subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
         // should show 3 attempts
@@ -127,4 +130,19 @@ public Subscription onSubscribe(Observer<? super String> o) {
             return Subscriptions.empty();
         }
     }
+    
+    @Test
+    public void testUnsubscribeFromRetry() {
+        PublishSubject<Integer> subject = PublishSubject.create();
+        final AtomicInteger count = new AtomicInteger(0);
+        Subscription sub = subject.retry().subscribe(new Action1<Integer>() {
+            @Override
+            public void call(Integer n) {
+                count.incrementAndGet();
+            }});
+        subject.onNext(1);
+        sub.unsubscribe();
+        subject.onNext(2);
+        assertEquals(1,count.get());
+    }
 }

From c54b3220701735d3db7fb2f42559117413678c88 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Wed, 5 Mar 2014 22:08:45 -0800
Subject: [PATCH 073/422] Move state inside Subscriber

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

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index 9f3ea2f5cc..1ee809aa47 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -45,7 +45,6 @@ public class OperatorRetry<T> implements Operator<T, Observable<T>> {
     private static final int INFINITE_RETRY = -1;
 
     private final int retryCount;
-    private final AtomicInteger attempts = new AtomicInteger(0);
 
     public OperatorRetry(int retryCount) {
         this.retryCount = retryCount;
@@ -58,7 +57,8 @@ public OperatorRetry() {
     @Override
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> s) {
         return new Subscriber<Observable<T>>(s) {
-
+            final AtomicInteger attempts = new AtomicInteger(0);
+            
             @Override
             public void onCompleted() {
                 // ignore as we expect a single nested Observable<T>

From d3cb033ba02b524863cc44956e5ce8b88cc7cb17 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Wed, 5 Mar 2014 22:21:19 -0800
Subject: [PATCH 074/422] Ignoring broken unit tests until fixed

/cc @abersnaze
---
 .../rxjava-debug/src/test/java/rx/debug/DebugHookTest.java     | 3 +++
 1 file changed, 3 insertions(+)

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 c3f4f2d426..5fdba559a6 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
@@ -13,6 +13,7 @@
 import org.hamcrest.Description;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.InOrder;
 
@@ -85,6 +86,7 @@ public void assertValidState() {
     }
 
     @SuppressWarnings("unchecked")
+    @Ignore
     @Test
     public void testSimple() {
         TestDebugNotificationListener listener = new TestDebugNotificationListener();
@@ -107,6 +109,7 @@ public void testSimple() {
     }
 
     @SuppressWarnings("unchecked")
+    @Ignore
     @Test
     public void testOneOp() {
         TestDebugNotificationListener listener = new TestDebugNotificationListener();

From bb73bbc7440ae09ef0974560185dc0258f74360f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Wed, 5 Mar 2014 22:45:27 -0800
Subject: [PATCH 075/422] Changing line 38 to try and fix build

Odd Jenkins build failures even though command-line build works fine:

```
:rxjava:rxjava-contrib:rxjava-debug:compileJava/mnt/builds/slave/workspace/OSS-RxJava-release/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java:38: ')' expected
            sourceFunc = ((DebugHook<C>.DebugOnSubscribe<T>) sourceFunc).getActual();
                                       ^
/mnt/builds/slave/workspace/OSS-RxJava-release/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java:38: ')' expected
            sourceFunc = ((DebugHook<C>.DebugOnSubscribe<T>) sourceFunc).getActual();
                                        ^
/mnt/builds/slave/workspace/OSS-RxJava-release/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java:38: illegal start of expression
            sourceFunc = ((DebugHook<C>.DebugOnSubscribe<T>) sourceFunc).getActual();
                                                           ^
/mnt/builds/slave/workspace/OSS-RxJava-release/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java:38: not a statement
            sourceFunc = ((DebugHook<C>.DebugOnSubscribe<T>) sourceFunc).getActual();
                                                             ^
/mnt/builds/slave/workspace/OSS-RxJava-release/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotification.java:38: ';' expected
            sourceFunc = ((DebugHook<C>.DebugOnSubscribe<T>) sourceFunc).getActual();
                                                                       ^
5 errors
 FAILED
```
---
 .../src/main/java/rx/plugins/DebugNotification.java             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 1cc8eab752..f7e065b50c 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
@@ -35,7 +35,7 @@ public static <T, C> DebugNotification<T> createSubscribe(Observer<? super T> o,
             o = ds.getActual();
         }
         if (sourceFunc instanceof DebugHook.DebugOnSubscribe) {
-            sourceFunc = ((DebugHook<C>.DebugOnSubscribe<T>) sourceFunc).getActual();
+            sourceFunc = (OnSubscribe<T>) ((SafeSubscriber) sourceFunc).getActual();
         }
         return new DebugNotification<T>(o, from, Kind.Subscribe, null, null, to, source, sourceFunc);
     }

From 509357b01009735aaaccda7fe29d08d3a21d4ff0 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Thu, 6 Mar 2014 06:55:07 +0000
Subject: [PATCH 076/422] [Gradle Release Plugin] - pre tag commit: 
 '0.17.0-RC7'.

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

diff --git a/gradle.properties b/gradle.properties
index f84383b779..75dc0f4000 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC7-SNAPSHOT
+version=0.17.0-RC7

From 18916d14c32d6db33be372259aba5c3e799696d5 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Thu, 6 Mar 2014 06:55:11 +0000
Subject: [PATCH 077/422] [Gradle Release Plugin] - new version commit: 
 '0.17.0-RC8-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index 75dc0f4000..2e8a8bdd53 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC7
+version=0.17.0-RC8-SNAPSHOT

From 1f47d1180fcda01ecbcc53084d523658c5651793 Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Thu, 6 Mar 2014 09:59:40 -0800
Subject: [PATCH 078/422] startWith(observable) marble diagram

---
 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 ed0f8c1bb7..33d64089fa 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6449,10 +6449,10 @@ public final Observable<T> skipWhileWithIndex(Func2<? super T, Integer, Boolean>
     }
 
     /**
-     * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit items
-     * emitted by the source Observable. 
+     * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit
+     * items emitted by the source Observable. 
      * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.o.png">
      * 
      * @param values
      *            an Observable that contains the items you want the modified Observable to emit first

From 940c26eb63d76f9cbedaaf89cd951b0a4d29347e Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Fri, 7 Mar 2014 18:46:17 -0800
Subject: [PATCH 079/422] correcting markup error in javadoc comments

---
 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 33d64089fa..42da02f62b 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4101,7 +4101,7 @@ public final <U, V> Observable<T> delay(
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.o.png">
      * <p>
-     * <em>Note:</code> the resulting Observable will immediately propagate any {@code onError} notification
+     * <em>Note:</em> the resulting Observable will immediately propagate any {@code onError} notification
      * from the source Observable.
      * 
      * @param <U>

From 0f19eb2225e9bb26abde3fb6d2378b69bb3e792c Mon Sep 17 00:00:00 2001
From: MarkVanDerVoort <mark.van.der.voort@gmail.com>
Date: Sat, 8 Mar 2014 22:17:59 +0100
Subject: [PATCH 080/422] OperationAll to OperatorAll

---
 rxjava-core/src/main/java/rx/Observable.java  | 85 +----------------
 .../main/java/rx/operators/OperationAll.java  | 91 -------------------
 .../main/java/rx/operators/OperatorAll.java   | 58 ++++++++++++
 ...ationAllTest.java => OperatorAllTest.java} | 50 ++++------
 4 files changed, 79 insertions(+), 205 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationAll.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorAll.java
 rename rxjava-core/src/test/java/rx/operators/{OperationAllTest.java => OperatorAllTest.java} (60%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 42da02f62b..06cf28cc9b 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -49,88 +49,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;
-import rx.operators.OperationAny;
-import rx.operators.OperationAsObservable;
-import rx.operators.OperationAverage;
-import rx.operators.OperationBuffer;
-import rx.operators.OperationCache;
-import rx.operators.OperationCombineLatest;
-import rx.operators.OperationConcat;
-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;
-import rx.operators.OperationElementAt;
-import rx.operators.OperationFinally;
-import rx.operators.OperationFlatMap;
-import rx.operators.OperationGroupByUntil;
-import rx.operators.OperationGroupJoin;
-import rx.operators.OperationInterval;
-import rx.operators.OperationJoin;
-import rx.operators.OperationJoinPatterns;
-import rx.operators.OperationMaterialize;
-import rx.operators.OperationMergeDelayError;
-import rx.operators.OperationMergeMaxConcurrent;
-import rx.operators.OperationMinMax;
-import rx.operators.OperationMulticast;
-import rx.operators.OperationOnErrorResumeNextViaObservable;
-import rx.operators.OperationOnErrorReturn;
-import rx.operators.OperationOnExceptionResumeNextViaObservable;
-import rx.operators.OperationParallelMerge;
-import rx.operators.OperationReplay;
-import rx.operators.OperationSample;
-import rx.operators.OperationSequenceEqual;
-import rx.operators.OperationSingle;
-import rx.operators.OperationSkip;
-import rx.operators.OperationSkipLast;
-import rx.operators.OperationSkipUntil;
-import rx.operators.OperationSkipWhile;
-import rx.operators.OperationSum;
-import rx.operators.OperationSwitch;
-import rx.operators.OperationSynchronize;
-import rx.operators.OperationTakeLast;
-import rx.operators.OperationTakeTimed;
-import rx.operators.OperationTakeUntil;
-import rx.operators.OperationTakeWhile;
-import rx.operators.OperationThrottleFirst;
-import rx.operators.OperationTimeInterval;
-import rx.operators.OperationTimer;
-import rx.operators.OperationToMap;
-import rx.operators.OperationToMultimap;
-import rx.operators.OperationToObservableFuture;
-import rx.operators.OperationUsing;
-import rx.operators.OperationWindow;
-import rx.operators.OperatorCast;
-import rx.operators.OperatorDoOnEach;
-import rx.operators.OperatorFilter;
-import rx.operators.OperatorGroupBy;
-import rx.operators.OperatorMap;
-import rx.operators.OperatorMerge;
-import rx.operators.OperatorObserveOn;
-import rx.operators.OperatorOnErrorFlatMap;
-import rx.operators.OperatorOnErrorResumeNextViaFunction;
-import rx.operators.OperatorParallel;
-import rx.operators.OperatorRepeat;
-import rx.operators.OperatorRetry;
-import rx.operators.OperatorScan;
-import rx.operators.OperatorSkip;
-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;
-import rx.operators.OperatorUnsubscribeOn;
-import rx.operators.OperatorZip;
-import rx.operators.OperatorZipIterable;
+import rx.operators.*;
 import rx.plugins.RxJavaObservableExecutionHook;
 import rx.plugins.RxJavaPlugins;
 import rx.schedulers.Schedulers;
@@ -3461,7 +3380,7 @@ public final <R> Observable<R> aggregate(R initialValue, Func2<R, ? super T, R>
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-all">RxJava Wiki: all()</a>
      */
     public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
-        return create(OperationAll.all(this, predicate));
+        return lift(new OperatorAll<T>(predicate));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAll.java b/rxjava-core/src/main/java/rx/operators/OperationAll.java
deleted file mode 100644
index 681486f13c..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationAll.java
+++ /dev/null
@@ -1,91 +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.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-import rx.functions.Func1;
-
-/**
- * Returns an Observable that emits a Boolean that indicates whether all items emitted by an
- * Observable satisfy a condition.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/all.png">
- */
-public class OperationAll {
-
-    public static <T> OnSubscribeFunc<Boolean> all(Observable<? extends T> sequence, Func1<? super T, Boolean> predicate) {
-        return new AllObservable<T>(sequence, predicate);
-    }
-
-    private static class AllObservable<T> implements OnSubscribeFunc<Boolean> {
-        private final Observable<? extends T> sequence;
-        private final Func1<? super T, Boolean> predicate;
-
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-        private AllObservable(Observable<? extends T> sequence, Func1<? super T, Boolean> predicate) {
-            this.sequence = sequence;
-            this.predicate = predicate;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super Boolean> observer) {
-            return subscription.wrap(sequence.subscribe(new AllObserver(observer)));
-
-        }
-
-        private class AllObserver implements Observer<T> {
-            private final Observer<? super Boolean> underlying;
-
-            private final AtomicBoolean status = new AtomicBoolean(true);
-
-            public AllObserver(Observer<? super Boolean> underlying) {
-                this.underlying = underlying;
-            }
-
-            @Override
-            public void onCompleted() {
-                if (status.get()) {
-                    underlying.onNext(true);
-                    underlying.onCompleted();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                underlying.onError(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                boolean result = predicate.call(args);
-                boolean changed = status.compareAndSet(true, result);
-
-                if (changed && !result) {
-                    underlying.onNext(false);
-                    underlying.onCompleted();
-                    subscription.unsubscribe();
-                }
-            }
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAll.java b/rxjava-core/src/main/java/rx/operators/OperatorAll.java
new file mode 100644
index 0000000000..b1b0535127
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAll.java
@@ -0,0 +1,58 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.Subscriber;
+import rx.exceptions.OnErrorThrowable;
+import rx.functions.Func1;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static rx.Observable.Operator;
+
+/**
+ * Returns an Observable that emits a Boolean that indicates whether all items emitted by an
+ * Observable satisfy a condition.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/all.png">
+ */
+public class OperatorAll<T> implements Operator<Boolean,T>{
+
+    private final Func1<? super T, Boolean> predicate;
+
+    public OperatorAll(Func1<? super T, Boolean> predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super Boolean> child) {
+        return new Subscriber<T>() {
+            private AtomicBoolean status = new AtomicBoolean(true);
+
+            @Override
+            public void onCompleted() {
+                child.onNext(status.get());
+                child.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onNext(T t) {
+                try {
+                    final Boolean result = predicate.call(t);
+                    boolean changed = status.compareAndSet(true, result);
+
+                    if (changed && !result) {
+                        child.onNext(false);
+                        child.onCompleted();
+                    }
+                } catch (Throwable e) {
+                    child.onError(OnErrorThrowable.addValueAsLastCause(e,t));
+                }
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAllTest.java
similarity index 60%
rename from rxjava-core/src/test/java/rx/operators/OperationAllTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorAllTest.java
index e7940a0583..f97504f884 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAllTest.java
@@ -16,28 +16,31 @@
 package rx.operators;
 
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationAll.*;
-
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
 import rx.functions.Func1;
+import rx.observers.TestSubscriber;
+
+import java.util.Arrays;
+
+public class OperatorAllTest {
 
-public class OperationAllTest {
+    final Func1<String, Boolean> hasLength3 = new Func1<String, Boolean>() {
+        @Override
+        public Boolean call(String s) {
+            return s.length() == 3;
+        }
+    };
 
     @Test
     @SuppressWarnings("unchecked")
     public void testAll() {
-        Observable<String> obs = Observable.from("one", "two", "six");
+        Observable<Boolean> obs = Observable.from(Arrays.asList("one", "two", "six")).all(hasLength3);
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
-            @Override
-            public Boolean call(String s) {
-                return s.length() == 3;
-            }
-        })).subscribe(observer);
+        obs.subscribe(new TestSubscriber<Boolean>(observer));
 
         verify(observer).onNext(true);
         verify(observer).onCompleted();
@@ -47,15 +50,10 @@ public Boolean call(String s) {
     @Test
     @SuppressWarnings("unchecked")
     public void testNotAll() {
-        Observable<String> obs = Observable.from("one", "two", "three", "six");
+        Observable<Boolean> obs = Observable.from(Arrays.asList("one", "two", "three", "six")).all(hasLength3);
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
-            @Override
-            public Boolean call(String s) {
-                return s.length() == 3;
-            }
-        })).subscribe(observer);
+        obs.subscribe(new TestSubscriber<Boolean>(observer));
 
         verify(observer).onNext(false);
         verify(observer).onCompleted();
@@ -65,15 +63,10 @@ public Boolean call(String s) {
     @Test
     @SuppressWarnings("unchecked")
     public void testEmpty() {
-        Observable<String> obs = Observable.empty();
+        Observable<Boolean> obs = Observable.<String>empty().all(hasLength3);
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
-            @Override
-            public Boolean call(String s) {
-                return s.length() == 3;
-            }
-        })).subscribe(observer);
+        obs.subscribe(new TestSubscriber<Boolean>(observer));
 
         verify(observer).onNext(true);
         verify(observer).onCompleted();
@@ -84,15 +77,10 @@ public Boolean call(String s) {
     @SuppressWarnings("unchecked")
     public void testError() {
         Throwable error = new Throwable();
-        Observable<String> obs = Observable.error(error);
+        Observable<Boolean> obs = Observable.<String>error(error).all(hasLength3);
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
-            @Override
-            public Boolean call(String s) {
-                return s.length() == 3;
-            }
-        })).subscribe(observer);
+        obs.subscribe(new TestSubscriber<Boolean>(observer));
 
         verify(observer).onError(error);
         verifyNoMoreInteractions(observer);

From a455b693ab2a34f9d74558582d02d78e582998a0 Mon Sep 17 00:00:00 2001
From: Acardiac <a028575@hotmail.com>
Date: Sun, 9 Mar 2014 11:00:46 +0100
Subject: [PATCH 081/422] add support for eclipse pde

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

diff --git a/rxjava-core/build.gradle b/rxjava-core/build.gradle
index 8cd94496a6..00420d0f74 100644
--- a/rxjava-core/build.gradle
+++ b/rxjava-core/build.gradle
@@ -29,6 +29,7 @@ jar {
         instruction 'Bundle-Vendor', 'Netflix'
         instruction 'Bundle-DocURL', 'https://github.com/Netflix/RxJava'
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
+        instruction 'Eclipse-ExtensibleAPI', 'true'
     }
 }
 

From a0ebbc77c22db31e7bada84dd6983be8ab3697ea Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Sun, 9 Mar 2014 13:48:55 -0700
Subject: [PATCH 082/422] fixing a variety of errors in javadoc generation
 (syntax errors, misnamed params, etc.)

---
 rxjava-core/src/main/java/rx/Observable.java  |  52 ++-
 rxjava-core/src/main/java/rx/Observer.java    |  18 +-
 rxjava-core/src/main/java/rx/Scheduler.java   |  53 +--
 .../rx/observers/SynchronizedSubscriber.java  |   2 +-
 .../java/rx/operators/OperationBuffer.java    | 250 +++++++-------
 .../java/rx/operators/OperationWindow.java    | 315 ++++++++++--------
 .../main/java/rx/operators/OperatorScan.java  |  40 +--
 .../main/java/rx/operators/SafeObserver.java  |   9 +-
 .../rx/plugins/RxJavaDefaultSchedulers.java   |  13 +-
 .../RxJavaObservableExecutionHook.java        |  67 ++--
 .../java/rx/schedulers/ExecutorScheduler.java |   8 +-
 .../main/java/rx/schedulers/Schedulers.java   |  17 +-
 .../java/rx/subjects/BehaviorSubject.java     |  20 +-
 13 files changed, 453 insertions(+), 411 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 42da02f62b..5bfb5ad278 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -259,7 +259,7 @@ public static interface OnSubscribeFunc<T> extends Function {
      * observable.map(...).filter(...).take(5).lift(new ObserverA()).lift(new ObserverB(...)).subscribe()
      * }
      * 
-     * @param bind
+     * @param lift
      * @return an Observable that emits values that are the result of applying the bind function to the values
      *         of the current Observable
      */
@@ -1552,7 +1552,7 @@ public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6, T
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
      * 
-     * @param items
+     * @param t1
      *            the source Array
      * @param <T>
      *            the type of items in the Array and the type of items to be emitted by the resulting Observable
@@ -1680,7 +1680,7 @@ public final static <T> Observable<T> just(T value, Scheduler scheduler) {
      *             if the source is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211837.aspx">MSDN: Observable.Max</a>
-     * @deprecated Use rxjava-math module instead
+     * @deprecated use rxjava-math module instead
      */
     public final static <T extends Comparable<? super T>> Observable<T> max(Observable<T> source) {
         return OperationMinMax.max(source);
@@ -2680,7 +2680,7 @@ public final static <T> Observable<T> switchDo(Observable<? extends Observable<?
      * @return an Observable that emits the items emitted by the Observable most recently emitted by the source
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-switchonnext">RxJava Wiki: switchOnNext()</a>
-     * @see {@link #switchOnNext(Observable)}
+     * @see #switchOnNext(Observable)
      */
     public final static <T> Observable<T> switchLatest(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
         return create(OperationSwitch.switchDo(sequenceOfSequences));
@@ -4308,7 +4308,7 @@ public final void onNext(T args) {
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnEach.png">
      * 
-     * @param observer
+     * @param onNotification
      *            the action to invoke for each item emitted by the source Observable
      * @return the source Observable with the side-effecting behavior applied
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooneach">RxJava Wiki: doOnEach()</a>
@@ -4503,7 +4503,7 @@ public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
      * @return an Observable that emits a Boolean that indicates whether any item emitted by the source
      *         Observable satisfies the {@code predicate}
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-exists-and-isempty">RxJava Wiki: exists()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211993.aspx">MSDN: Observable.Any</a> Note: the description in this page was wrong at the time of this writing.
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211993.aspx">MSDN: Observable.Any (Note: the description in this page was wrong at the time of this writing)</a>
      */
     public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
         return create(OperationAny.exists(this, predicate));
@@ -4551,7 +4551,7 @@ public final Observable<T> finallyDo(Action0 action) {
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see MSDN: {@code Observable.firstAsync()}
+     * @see "MSDN: Observable.firstAsync()"
      */
     public final Observable<T> first() {
         return take(1).single();
@@ -4568,7 +4568,7 @@ public final Observable<T> first() {
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see MSDN: {@code Observable.firstAsync()}
+     * @see "MSDN: Observable.firstAsync()"
      */
     public final Observable<T> first(Func1<? super T, Boolean> predicate) {
         return takeFirst(predicate).single();
@@ -4585,7 +4585,7 @@ public final Observable<T> first(Func1<? super T, Boolean> predicate) {
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-firstordefault">RxJava Wiki: firstOrDefault()</a>
-     * @see MSDN: {@code Observable.firstOrDefaultAsync()}
+     * @see "MSDN: Observable.firstOrDefaultAsync()"
      */
     public final Observable<T> firstOrDefault(T defaultValue) {
         return take(1).singleOrDefault(defaultValue);
@@ -4605,7 +4605,7 @@ public final Observable<T> firstOrDefault(T defaultValue) {
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-firstordefault">RxJava Wiki: firstOrDefault()</a>
-     * @see MSDN: {@code Observable.firstOrDefaultAsync()}
+     * @see "MSDN: Observable.firstOrDefaultAsync()"
      */
     public final Observable<T> firstOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
         return takeFirst(predicate).singleOrDefault(defaultValue);
@@ -4784,7 +4784,7 @@ public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> join(Obser
      * @return an Observable that emits the last item from the source Observable or notifies observers of an
      *         error
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
-     * @see MSDN: {@code Observable.lastAsync()}
+     * @see "MSDN: Observable.lastAsync()"
      */
     public final Observable<T> last() {
         return takeLast(1).single();
@@ -4803,7 +4803,7 @@ public final Observable<T> last() {
      * @throws IllegalArgumentException
      *             if no items that match the predicate are emitted by the source Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
-     * @see MSDN: {@code Observable.lastAsync()}
+     * @see "MSDN: Observable.lastAsync()"
      */
     public final Observable<T> last(Func1<? super T, Boolean> predicate) {
         return filter(predicate).takeLast(1).single();
@@ -4820,7 +4820,7 @@ public final Observable<T> last(Func1<? super T, Boolean> predicate) {
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-lastOrDefault">RxJava Wiki: lastOrDefault()</a>
-     * @see MSDN: {@code Observable.lastOrDefaultAsync()}
+     * @see "MSDN: Observable.lastOrDefaultAsync()"
      */
     public final Observable<T> lastOrDefault(T defaultValue) {
         return takeLast(1).singleOrDefault(defaultValue);
@@ -4840,7 +4840,7 @@ public final Observable<T> lastOrDefault(T defaultValue) {
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-lastOrDefault">RxJava Wiki: lastOrDefault()</a>
-     * @see MSDN: {@code Observable.lastOrDefaultAsync()}
+     * @see "MSDN: Observable.lastOrDefaultAsync()"
      */
     public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
         return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
@@ -5355,7 +5355,7 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
      * @param f
      *            a {@link Func1} that applies Observable Observers to {@code Observable<T>} in parallel and
      *            returns an {@code Observable<R>}
-     * @return an Observable that emits the results of applying {@link f} to the items emitted by the source
+     * @return an Observable that emits the results of applying {@code f} to the items emitted by the source
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-parallel">RxJava Wiki: parallel()</a>
      */
@@ -5376,7 +5376,7 @@ public final <R> Observable<R> parallel(Func1<Observable<T>, Observable<R>> f) {
      *            returns an {@code Observable<R>}
      * @param s
      *            a {@link Scheduler} to perform the work on
-     * @return an Observable that emits the results of applying {@link f} to the items emitted by the source
+     * @return an Observable that emits the results of applying {@code f} to the items emitted by the source
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-parallel">RxJava Wiki: parallel()</a>
      */
@@ -5450,7 +5450,7 @@ public final Subject<T, T> call() {
      * @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 Observable
+     *         on a {@link ConnectableObservable} that shares a single subscription to the underlying Observable
      */
     public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Observable<R>> selector, final T initialValue) {
         return multicast(new Func0<Subject<T, T>>() {
@@ -6208,7 +6208,7 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
      * @throws IllegalArgumentException
      *             if the source emits more than one item or no items
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see MSDN: {@code Observable.singleAsync()}
+     * @see "MSDN: Observable.singleAsync()"
      */
     public final Observable<T> single() {
         return create(OperationSingle.<T> single(this));
@@ -6229,7 +6229,7 @@ public final Observable<T> single() {
      *             if the source Observable emits either more than one item that matches the predicate or no
      *             items that match the predicate
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see MSDN: {@code Observable.singleAsync()}
+     * @see "MSDN: Observable.singleAsync()"
      */
     public final Observable<T> single(Func1<? super T, Boolean> predicate) {
         return filter(predicate).single();
@@ -6249,7 +6249,7 @@ public final Observable<T> single(Func1<? super T, Boolean> predicate) {
      * @throws IllegalArgumentException
      *             if the source Observable emits more than one item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see MSDN: {@code Observable.singleOrDefaultAsync()}
+     * @see "MSDN: Observable.singleOrDefaultAsync()"
      */
     public final Observable<T> singleOrDefault(T defaultValue) {
         return create(OperationSingle.<T> singleOrDefault(this, defaultValue));
@@ -6272,7 +6272,7 @@ public final Observable<T> singleOrDefault(T defaultValue) {
      * @throws IllegalArgumentException
      *             if the source Observable emits more than one item that matches the predicate
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see MSDN: {@code Observable.singleOrDefaultAsync()}
+     * @see "MSDN: Observable.singleOrDefaultAsync()"
      */
     public final Observable<T> singleOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
         return filter(predicate).singleOrDefault(defaultValue);
@@ -7140,8 +7140,7 @@ public final Subscription subscribe(Subscriber<? super T> observer, Scheduler sc
     }
 
     /**
-     * Asynchronously subscribes Observers to this Observable on the specified
-     * {@link Scheduler}.
+     * Asynchronously subscribes Observers to this Observable on the specified {@link Scheduler}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/subscribeOn.png">
      * 
@@ -7150,7 +7149,6 @@ public final Subscription subscribe(Subscriber<? super T> observer, Scheduler sc
      * @return the source Observable modified so that its subscriptions happen on the
      *         specified {@link Scheduler}
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-subscribeon">RxJava Wiki: subscribeOn()</a>
-     * @see #subscribeOn(rx.Scheduler, int) 
      */
     public final Observable<T> subscribeOn(Scheduler scheduler) {
         return nest().lift(new OperatorSubscribeOn<T>(scheduler));
@@ -7354,7 +7352,7 @@ public final Observable<T> 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
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see MSDN: {@code Observable.firstAsync()}
+     * @see "MSDN: Observable.firstAsync()"
      * @deprecated use {@code take(1)} directly
      */
     @Deprecated
@@ -7374,7 +7372,7 @@ public final Observable<T> takeFirst() {
      *         the given condition, or that completes without emitting anything if the source Observable
      *         completes without emitting a single condition-satisfying item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see MSDN: {@code Observable.firstAsync()}
+     * @see "MSDN: Observable.firstAsync()"
      */
     public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
         return filter(predicate).take(1);
@@ -7638,7 +7636,7 @@ public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Int
      * 
      * @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
+     * @return a {@link Plan0} that produces the projected results, to be fed (with other Plans) to the
      *         {@link #when} Observer
      * @throws NullPointerException
      *             if {@code selector} is null
diff --git a/rxjava-core/src/main/java/rx/Observer.java b/rxjava-core/src/main/java/rx/Observer.java
index a2de94be24..a0d7a815e2 100644
--- a/rxjava-core/src/main/java/rx/Observer.java
+++ b/rxjava-core/src/main/java/rx/Observer.java
@@ -18,9 +18,10 @@
 /**
  * Provides a mechanism for receiving push-based notifications.
  * <p>
- * After an Observer calls an {@link Observable}'s <code>Observable.subscribe</code> method, the {@link Observable} calls the
- * Observer's <code>onNext</code> method to provide notifications. A well-behaved {@link Observable} will call an Observer's
- * <code>onCompleted</code> closure exactly once or the Observer's <code>onError</code> closure exactly once.
+ * After an Observer calls an {@link Observable}'s <code>Observable.subscribe</code> method, the
+ * {@link Observable} calls the Observer's <code>onNext</code> method to provide notifications. A well-behaved
+ * {@link Observable} will call an Observer's <code>onCompleted</code> closure exactly once or the Observer's
+ * <code>onError</code> closure exactly once.
  * <p>
  * For more information see the <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
  * 
@@ -38,7 +39,8 @@ public interface Observer<T> {
     /**
      * Notifies the Observer that the {@link Observable} has experienced an error condition.
      * <p>
-     * If the {@link Observable} calls this closure, it will not thereafter call <code>onNext</code> or <code>onCompleted</code>.
+     * If the {@link Observable} calls this closure, it will not thereafter call <code>onNext</code> or
+     * <code>onCompleted</code>.
      * 
      * @param e
      */
@@ -47,11 +49,13 @@ public interface Observer<T> {
     /**
      * Provides the Observer with new data.
      * <p>
-     * The {@link Observable} calls this closure 1 or more times, unless it calls <code>onError</code> in which case this closure may never be called.
+     * The {@link Observable} calls this closure 1 or more times, unless it calls <code>onError</code> in which
+     * case this closure may never be called.
      * <p>
-     * The {@link Observable} will not call this closure again after it calls either <code>onCompleted</code> or <code>onError</code>.
+     * The {@link Observable} will not call this closure again after it calls either <code>onCompleted</code> or
+     * <code>onError</code>.
      * 
-     * @param args
+     * @param t
      */
     public abstract void onNext(T t);
 
diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 21d4791f44..8203ec567b 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -31,11 +31,15 @@
  * Why is this an abstract class instead of an interface?
  * <p>
  * <ol>
- * <li>Java doesn't support extension methods and there are many overload methods needing default implementations.</li>
- * <li>Virtual extension methods aren't available until Java8 which RxJava will not set as a minimum target for a long time.</li>
- * <li>If only an interface were used Scheduler implementations would then need to extend from an AbstractScheduler pair that gives all of the functionality unless they intend on copy/pasting the
- * functionality.</li>
- * <li>Without virtual extension methods even additive changes are breaking and thus severely impede library maintenance.</li>
+ * <li>Java doesn't support extension methods and there are many overload methods needing default
+ *     implementations.</li>
+ * <li>Virtual extension methods aren't available until Java8 which RxJava will not set as a minimum target for
+ *     a long time.</li>
+ * <li>If only an interface were used Scheduler implementations would then need to extend from an
+ *     AbstractScheduler pair that gives all of the functionality unless they intend on copy/pasting the
+ *     functionality.</li>
+ * <li>Without virtual extension methods even additive changes are breaking and thus severely impede library
+ *     maintenance.</li>
  * </ol>
  */
 public abstract class Scheduler {
@@ -44,38 +48,40 @@ public abstract class Scheduler {
      * Schedules an Action on a new Scheduler instance (typically another thread) for execution.
      * 
      * @param action
-     *            Action to schedule.
-     * @return a subscription to be able to unsubscribe from action.
+     *            Action to schedule
+     * @return a subscription to be able to unsubscribe from action
      */
 
     public abstract Subscription schedule(Action1<Scheduler.Inner> action);
 
     /**
-     * Schedules an Action on a new Scheduler instance (typically another thread) for execution at some point in the future.
+     * Schedules an Action on a new Scheduler instance (typically another thread) for execution at some point
+     * in the future.
      * 
      * @param action
+     *            the Action to schedule
      * @param delayTime
+     *            time to wait before executing the action
      * @param unit
-     * @return
+     *            the time unit the delay time is given in
+     * @return a subscription to be able to unsubscribe from action
      */
     public abstract Subscription schedule(final Action1<Scheduler.Inner> action, final long delayTime, final TimeUnit 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.
+     * 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
      * @param unit
-     *            The time unit the interval above is given in.
-     * @return A subscription to be able to unsubscribe from action.
+     *            the time unit the interval above is given in
+     * @return a subscription to be able to unsubscribe from action
      */
     public Subscription schedulePeriodically(final Action1<Scheduler.Inner> action, long initialDelay, long period, TimeUnit unit) {
         final long periodInNanos = unit.toNanos(period);
@@ -151,9 +157,9 @@ public abstract static class Inner implements Subscription {
          * Schedules an action to be executed in delayTime.
          * 
          * @param delayTime
-         *            Time the action is to be delayed before executing.
+         *            time the action is to be delayed before executing
          * @param unit
-         *            Time unit of the delay time.
+         *            time unit of the delay time
          */
         public abstract void schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit);
 
@@ -174,9 +180,10 @@ public long now() {
     /**
      * Parallelism available to a Scheduler.
      * <p>
-     * This defaults to {@code Runtime.getRuntime().availableProcessors()} but can be overridden for use cases such as scheduling work on a computer cluster.
+     * 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 available degree of parallelism
      */
     public int degreeOfParallelism() {
         return Runtime.getRuntime().availableProcessors();
diff --git a/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
index 8c01f506e1..8dbf1b20f5 100644
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
@@ -42,7 +42,7 @@ public SynchronizedSubscriber(Subscriber<? super T> subscriber, Object lock) {
     /**
      * Used when synchronizing an Subscriber without access to the subscription.
      * 
-     * @param Observer
+     * @param subscriber
      */
     public SynchronizedSubscriber(Subscriber<? super T> subscriber) {
         this(subscriber, new Object());
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index b3dd33400b..d4181504ba 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -42,24 +42,25 @@ public Buffer<T> call() {
     }
 
     /**
-     * <p>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
-     * 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
-     * event is propagated
-     * to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.</p>
+     * 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 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 event is
+     * propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
+     * exactly one buffer actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param bufferClosingSelector
-     *            A {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine when a buffer is emitted and replaced by simply
-     *            producing an object.
+     *            a {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine
+     *            when a buffer is emitted and replaced by simply producing an object.
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T, TClosing> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Func0<? extends Observable<? extends TClosing>> bufferClosingSelector) {
         return new OnSubscribeFunc<List<T>>() {
@@ -76,29 +77,31 @@ public Subscription onSubscribe(Observer<? super List<T>> observer) {
     }
 
     /**
-     * <p>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
-     * there are no chunks active.</p>
-     * 
-     * <p>Chunks can be created by pushing a {@link rx.util.Opening} value to the "bufferOpenings" {@link Observable}.
-     * This creates a new buffer which will then start recording values which are produced by the "source" {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an
-     * {@link Observable} which can produce values. When it does so it will close this (and only this) newly created
-     * buffer. When the source {@link Observable} completes or produces an error, all chunks are emitted, and the
-     * event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that when using this operation <strong>multiple overlapping chunks</strong>
-     * could be active at any one point.</p>
+     * 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 there are no chunks active.
+     * <p>
+     * Chunks can be created by pushing a {@link rx.util.TOpening} value to the "bufferOpenings"
+     * {@link Observable}. This creates a new buffer which will then start recording values which are produced
+     * by the "source" {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an
+     * {@link Observable} which can produce values. When it does so it will close this (and only this) newly
+     * created buffer. When the source {@link Observable} completes or produces an error, all chunks are
+     * emitted, and the event is propagated to all subscribed {@link Observer}s.
+     * </p><p>
+     * Note that when using this operation <strong>multiple overlapping chunks</strong> could be active at any
+     * one point.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param bufferOpenings
-     *            An {@link Observable} which when it produces a {@link rx.util.Opening} value will
-     *            create a new buffer which instantly starts recording the "source" {@link Observable}.
+     *            an {@link Observable} which when it produces a {@link rx.util.TOpening} value will create a
+     *            new buffer which instantly starts recording the "source" {@link Observable}
      * @param bufferClosingSelector
-     *            A {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine when a buffer is emitted and replaced by simply
-     *            producing an object.
+     *            a {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine
+     *            when a buffer is emitted and replaced by simply producing an object.
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T, TOpening, TClosing> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Observable<? extends TOpening> bufferOpenings, final Func1<? super TOpening, ? extends Observable<? extends TClosing>> bufferClosingSelector) {
         return new OnSubscribeFunc<List<T>>() {
@@ -114,48 +117,50 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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 buffer contains
      * a specified number of elements. The buffer is then emitted, and a new buffer is created to replace it.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.</p>
+     * the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
+     * exactly one buffer actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param count
-     *            The number of elements a buffer should have before being emitted and replaced.
+     *            the number of elements a buffer should have before being emitted and replaced
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, int count) {
         return buffer(source, count, count);
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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 all active chunks until the buffer
      * contains a specified number of elements. The buffer is then emitted. Chunks are created after a certain
-     * amount of values have been received. When the source {@link Observable} completes or produces an error, the
-     * currently active chunks are emitted, and the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
-     * chunks</strong> depending on the input parameters.</p>
+     * amount of values have been received. When the source {@link Observable} completes or produces an error,
+     * the currently active chunks are emitted, and the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
+     * chunks</strong> depending on the input parameters.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param count
-     *            The number of elements a buffer should have before being emitted.
+     *            the number of elements a buffer should have before being emitted
      * @param skip
-     *            The interval with which chunks have to be created. Note that when "skip" == "count"
-     *            that this is the same as calling {@link OperationBuffer#buffer(Observable, int)}.
-     *            If "skip" < "count", this buffer operation will produce overlapping chunks and if "skip"
-     *            > "count" non-overlapping chunks will be created and some values will not be pushed
+     *            the interval with which chunks have to be created. Note that when {@code skip == count} that
+     *            this is the same as calling {@link OperationBuffer#buffer(Observable, int)}. If
+     *            {@code skip < count}, this buffer operation will produce overlapping chunks and if
+     *            {@code skip > count} non-overlapping chunks will be created and some values will not be pushed
      *            into a buffer at all!
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final int count, final int skip) {
         return new OnSubscribeFunc<List<T>>() {
@@ -171,48 +176,50 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.</p>
+     * the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
+     * exactly one buffer actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param timespan
-     *            The amount of time all chunks must be actively collect values before being emitted.
+     *            the amount of time all chunks must be actively collect values before being emitted
      * @param unit
-     *            The {@link TimeUnit} defining the unit of time for the timespan.
+     *            the {@link TimeUnit} defining the unit of time for the timespan
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit) {
         return buffer(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.</p>
+     * the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
+     * exactly one buffer actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param timespan
-     *            The amount of time all chunks must be actively collect values before being emitted.
+     *            the amount of time all chunks must be actively collect values before being emitted
      * @param unit
-     *            The {@link TimeUnit} defining the unit of time for the timespan.
+     *            the {@link TimeUnit} defining the unit of time for the timespan
      * @param scheduler
-     *            The {@link Scheduler} to use for timing chunks.
+     *            the {@link Scheduler} to use for timing chunks
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc<List<T>>() {
@@ -228,54 +235,56 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * Additionally the buffer is automatically emitted once it reaches a specified number of elements.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.</p>
+     * the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
+     * exactly one buffer actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param timespan
-     *            The amount of time all chunks must be actively collect values before being emitted.
+     *            the amount of time all chunks must be actively collect values before being emitted
      * @param unit
-     *            The {@link TimeUnit} defining the unit of time for the timespan.
+     *            the {@link TimeUnit} defining the unit of time for the timespan
      * @param count
-     *            The maximum size of the buffer. Once a buffer reaches this size, it is emitted.
+     *            the maximum size of the buffer. Once a buffer reaches this size, it is emitted
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit, int count) {
         return buffer(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * Additionally the buffer is automatically emitted once it reaches a specified number of elements.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.</p>
+     * the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
+     * exactly one buffer actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param timespan
-     *            The amount of time all chunks must be actively collect values before being emitted.
+     *            the amount of time all chunks must be actively collect values before being emitted
      * @param unit
-     *            The {@link TimeUnit} defining the unit of time for the timespan.
+     *            the {@link TimeUnit} defining the unit of time for the timespan
      * @param count
-     *            The maximum size of the buffer. Once a buffer reaches this size, it is emitted.
+     *            the maximum size of the buffer. Once a buffer reaches this size, it is emitted
      * @param scheduler
-     *            The {@link Scheduler} to use for timing chunks.
+     *            the {@link Scheduler} to use for timing chunks
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
         return new OnSubscribeFunc<List<T>>() {
@@ -292,54 +301,56 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
-     * on the input parameters.</p>
+     * the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
+     * on the input parameters.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param timespan
-     *            The amount of time all chunks must be actively collect values before being emitted.
+     *            the amount of time all chunks must be actively collect values before being emitted
      * @param timeshift
-     *            The amount of time between creating chunks.
+     *            the amount of time between creating chunks
      * @param unit
-     *            The {@link TimeUnit} defining the unit of time for the timespan.
+     *            the {@link TimeUnit} defining the unit of time for the timespan
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
         return buffer(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * <p>This method creates a {@link Func1} object which represents the buffer operation. This operation takes
+     * 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. Periodically the buffer
      * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
      * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
      * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.</p>
-     * 
-     * <p>Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
-     * on the input parameters.</p>
+     * the event is propagated to all subscribed {@link Observer}s.
+     * <p>
+     * Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
+     * on the input parameters.
+     * </p>
      * 
      * @param source
-     *            The {@link Observable} which produces values.
+     *            the {@link Observable} which produces values
      * @param timespan
-     *            The amount of time all chunks must be actively collect values before being emitted.
+     *            the amount of time all chunks must be actively collect values before being emitted
      * @param timeshift
-     *            The amount of time between creating chunks.
+     *            the amount of time between creating chunks
      * @param unit
-     *            The {@link TimeUnit} defining the unit of time for the timespan.
+     *            the {@link TimeUnit} defining the unit of time for the timespan
      * @param scheduler
-     *            The {@link Scheduler} to use for timing chunks.
+     *            the {@link Scheduler} to use for timing chunks
      * @return
-     *         the {@link Func1} object representing the specified buffer operation.
+     *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc<List<T>>() {
@@ -359,7 +370,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      * This class represents a single buffer: A sequence of recorded values.
      * 
      * @param <T>
-     *            The type of objects which this {@link Buffer} can hold.
+     *            the type of objects which this {@link Buffer} can hold
      */
     protected static class Buffer<T> extends Chunk<T, List<T>> {
         /**
@@ -402,6 +413,10 @@ public boolean isUnsubscribed() {
 
     /**
      * Create a buffer operator with the given observable sequence as the buffer boundary.
+     *
+     * @param source
+     * @param boundary
+     * @return
      */
     public static <T, B> OnSubscribeFunc<List<T>> bufferWithBoundaryObservable(Observable<? extends T> source, Observable<B> boundary) {
         return new BufferWithObservableBoundary<T, B>(source, boundary, 16);
@@ -410,6 +425,11 @@ public static <T, B> OnSubscribeFunc<List<T>> bufferWithBoundaryObservable(Obser
     /**
      * Create a buffer operator with the given observable sequence as the buffer boundary and
      * with the given initial capacity for buffers.
+     *
+     * @param source
+     * @param boundary
+     * @param initialCapacity
+     * @return
      */
     public static <T, B> OnSubscribeFunc<List<T>> bufferWithBoundaryObservable(Observable<? extends T> source, Observable<B> boundary, int initialCapacity) {
         if (initialCapacity <= 0) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index c0d96f3a79..5b170c56a0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -42,24 +42,26 @@ public Window<T> call() {
     }
 
     /**
-     * <p>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.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.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.</p>
+     * 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.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.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param windowClosingSelector
-     *            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
+     *            a {@link rx.functions.Func0} object that 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.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T, TClosing> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final Func0<? extends Observable<? extends TClosing>> windowClosingSelector) {
         return new OnSubscribeFunc<Observable<T>>() {
@@ -74,29 +76,33 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
     }
 
     /**
-     * <p>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.</p>
-     * 
-     * <p>Windows can be created by pushing a {@link rx.util.Opening} value to the "windowOpenings" {@link rx.Observable}.
-     * This creates a new window which will then start recording values which are produced by the "source" {@link rx.Observable}. Additionally the "windowClosingSelector" will be used to construct an
-     * {@link rx.Observable} which can produce values. When it does so it will close this (and only this) newly created
-     * window. When the source {@link rx.Observable} completes or produces an error, all windows are emitted, and the
-     * event is propagated to all subscribed {@link rx.Observer}s.</p>
-     * 
-     * <p>Note that when using this operation <strong>multiple overlapping windows</strong>
-     * could be active at any one point.</p>
+     * 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.
+     * <p>
+     * Windows can be created by pushing a {@link rx.util.TOpening} value to the {@code windowOpenings}
+     * {@link rx.Observable}. This creates a new window which will then start recording values which are
+     * produced by the {@code source} {@link rx.Observable}. Additionally the {@code windowClosingSelector}
+     * will be used to construct an {@link rx.Observable} which can produce values. When it does so it will
+     * close this (and only this) newly created window. When the source {@link rx.Observable} completes or
+     * produces an error, all windows are emitted, and the event is propagated to all subscribed
+     * {@link rx.Observer}s.
+     * </p><p>
+     * Note that when using this operation <strong>multiple overlapping windows</strong> could be active at any
+     * one point.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param windowOpenings
-     *            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}.
+     *            an {@link rx.Observable} which when it produces a {@link rx.util.TOpening} value will create a
+     *            new window which instantly starts recording the {@code source} {@link rx.Observable}
      * @param windowClosingSelector
-     *            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.
+     *            a {@link rx.functions.Func0} object that 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.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T, TOpening, TClosing> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final Observable<? extends TOpening> windowOpenings, final Func1<? super TOpening, ? extends Observable<? extends TClosing>> windowClosingSelector) {
         return new OnSubscribeFunc<Observable<T>>() {
@@ -110,48 +116,51 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
     }
 
     /**
-     * <p>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
-     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.</p>
+     * 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 the event is propagated to all subscribed {@link rx.Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param count
-     *            The number of elements a window should have before being emitted and replaced.
+     *            the number of elements a window should have before being emitted and replaced
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, int count) {
         return window(source, count, count);
     }
 
     /**
-     * <p>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
-     * currently active windows are emitted, and the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     * 
-     * <p>Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
-     * windows</strong> depending on the input parameters.</p>
+     * 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 currently active windows are emitted, and the event is propagated to
+     * all subscribed {@link rx.Observer}s.
+     * <p>
+     * Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
+     * windows</strong> depending on the input parameters.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param count
-     *            The number of elements a window should have before being emitted.
+     *            the number of elements a window should have before being emitted
      * @param skip
-     *            The interval with which windows have to be created. Note that when "skip" == "count"
-     *            that this is the same as calling {@link rx.operators.OperationWindow#window(rx.Observable, int)}.
-     *            If "skip" < "count", this window operation will produce overlapping windows and if "skip"
-     *            > "count" non-overlapping windows will be created and some values will not be pushed
-     *            into a window at all!
+     *            the interval with which windows have to be created. Note that when {@code skip == count} that
+     *            this is the same as calling {@link rx.operators.OperationWindow#window(rx.Observable, int)}.
+     *            If {@code skip < count}, this window operation will produce overlapping windows and if
+     *            {@code skip > count} non-overlapping windows will be created and some values will not be
+     *            pushed into a window at all!
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final int count, final int skip) {
         return new OnSubscribeFunc<Observable<T>>() {
@@ -165,48 +174,50 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
     }
 
     /**
-     * <p>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
-     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.</p>
+     * 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 the event is propagated to all subscribed {@link rx.Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param timespan
-     *            The amount of time all windows must be actively collect values before being emitted.
+     *            the amount of time all windows must be actively collect values before being emitted
      * @param unit
-     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit) {
         return window(source, timespan, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * <p>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
-     * the event is propagated to all subscribed {@link rx.Observer}s.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.</p>
+     * 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 the event is propagated to all subscribed {@link rx.Observer}s.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param timespan
-     *            The amount of time all windows must be actively collect values before being emitted.
+     *            the amount of time all windows must be actively collect values before being emitted
      * @param unit
-     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
      * @param scheduler
-     *            The {@link rx.Scheduler} to use for timing windows.
+     *            the {@link rx.Scheduler} to use for timing windows
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc<Observable<T>>() {
@@ -220,54 +231,56 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
     }
 
     /**
-     * <p>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.
-     * 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.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.</p>
+     * 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. 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.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param timespan
-     *            The amount of time all windows must be actively collect values before being emitted.
+     *            the amount of time all windows must be actively collect values before being emitted
      * @param unit
-     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
      * @param count
-     *            The maximum size of the window. Once a window reaches this size, it is emitted.
+     *            the maximum size of the window. Once a window reaches this size, it is emitted
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit, int count) {
         return window(source, timespan, unit, count, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * <p>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.
-     * 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.</p>
-     * 
-     * <p>Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.</p>
+     * 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. 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.
+     * <p>
+     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
+     * exactly one window actively storing values.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param timespan
-     *            The amount of time all windows must be actively collect values before being emitted.
+     *            the amount of time all windows must be actively collect values before being emitted
      * @param unit
-     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
      * @param count
-     *            The maximum size of the window. Once a window reaches this size, it is emitted.
+     *            the maximum size of the window. Once a window reaches this size, it is emitted
      * @param scheduler
-     *            The {@link rx.Scheduler} to use for timing windows.
+     *            the {@link rx.Scheduler} to use for timing windows
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
         return new OnSubscribeFunc<Observable<T>>() {
@@ -281,54 +294,56 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
     }
 
     /**
-     * <p>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.
-     * 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.</p>
-     * 
-     * <p>Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending
-     * on the input parameters.</p>
+     * 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. 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.
+     * <p>
+     * Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending on
+     * the input parameters.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param timespan
-     *            The amount of time all windows must be actively collect values before being emitted.
+     *            the amount of time all windows must be actively collect values before being emitted
      * @param timeshift
-     *            The amount of time between creating windows.
+     *            the amount of time between creating windows
      * @param unit
-     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit) {
         return window(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
     }
 
     /**
-     * <p>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.
-     * 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.</p>
-     * 
-     * <p>Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending
-     * on the input parameters.</p>
+     * 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. 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.
+     * <p>
+     * Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending on
+     * the input parameters.
+     * </p>
      * 
      * @param source
-     *            The {@link rx.Observable} which produces values.
+     *            the {@link rx.Observable} which produces values
      * @param timespan
-     *            The amount of time all windows must be actively collect values before being emitted.
+     *            the amount of time all windows must be actively collect values before being emitted
      * @param timeshift
-     *            The amount of time between creating windows.
+     *            the amount of time between creating windows
      * @param unit
-     *            The {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan.
+     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
      * @param scheduler
-     *            The {@link rx.Scheduler} to use for timing windows.
+     *            the {@link rx.Scheduler} to use for timing windows
      * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation.
+     *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
         return new OnSubscribeFunc<Observable<T>>() {
@@ -345,13 +360,13 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      * This class represents a single window: A sequence of recorded values.
      * 
      * @param <T>
-     *            The type of objects which this {@link Window} can hold.
+     *            the type of objects which this {@link Window} can hold
      */
     protected static class Window<T> extends Chunk<T, Observable<T>> {
         /**
          * @return
-         *         The mutable underlying {@link Observable} which contains all the
-         *         recorded values in this {@link Window} object.
+         *         the mutable underlying {@link Observable} which contains all the recorded values in this
+         *         {@link Window} object
          */
         @Override
         public Observable<T> getContents() {
@@ -360,16 +375,20 @@ public Observable<T> getContents() {
     }
 
     /**
-     * Emits windows of values of the source Observable where the window boundary is
-     * determined by the items of the boundary Observable.
+     * Emits windows of values of the source Observable where the window boundary is determined by the items of
+     * the boundary Observable.
+     *
+     * @param source
+     * @param boundary
+     * @return
      */
     public static <T, U> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, Observable<U> boundary) {
         return new WindowViaObservable<T, U>(source, boundary);
     }
 
     /**
-     * Create non-overlapping windows from the source values by using another observable's
-     * values as to when to replace a window.
+     * 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<T, U> implements OnSubscribeFunc<Observable<T>> {
         final Observable<? extends T> source;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorScan.java b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
index 2cd8de2626..d1e9b769a9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorScan.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorScan.java
@@ -21,17 +21,17 @@
 import rx.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.
+ * 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.
  * <p>
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/scan.png">
  * <p>
  * This sort of function is sometimes called an accumulator.
  * <p>
- * Note that when you pass a seed to <code>scan()</code> the resulting Observable will emit that
- * seed as its first emitted item.
+ * Note that when you pass a seed to <code>scan()</code> the resulting Observable will emit that seed as its
+ * first emitted item.
  */
 public final class OperatorScan<R, T> implements Operator<R, T> {
 
@@ -41,19 +41,14 @@ public final class OperatorScan<R, T> implements Operator<R, T> {
     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.
+     * 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.
+     *            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 <a href="http://msdn.microsoft.com/en-us/library/hh212007%28v=vs.103%29.aspx">Observable.Scan(TSource, TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource,
+     *            an accumulator function to be invoked on each element from the sequence
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212007.aspx">Observable.Scan(TSource, TAccumulate) Method (IObservable(TSource), TAccumulate, Func(TAccumulate, TSource,
      *      TAccumulate))</a>
      */
     public OperatorScan(R initialValue, Func2<R, ? super T, R> accumulator) {
@@ -62,17 +57,12 @@ public OperatorScan(R initialValue, Func2<R, ? super T, R> accumulator) {
     }
 
     /**
-     * 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 <a href="http://msdn.microsoft.com/en-us/library/hh211665(v=vs.103).aspx">Observable.Scan(TSource) Method (IObservable(TSource), Func(TSource, TSource, TSource))</a>
+     *            an accumulator function to be invoked on each element from the sequence
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665.aspx">Observable.Scan(TSource) Method (IObservable(TSource), Func(TSource, TSource, TSource))</a>
      */
     @SuppressWarnings("unchecked")
     public OperatorScan(final Func2<R, ? super T, R> accumulator) {
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index f776619905..cf632b4dc5 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -29,7 +29,8 @@
 /**
  * Wrapper around Observer to ensure compliance with Rx contract.
  * <p>
- * The following is taken from the Rx Design Guidelines document: http://go.microsoft.com/fwlink/?LinkID=205219
+ * The following is taken from <a href="http://go.microsoft.com/fwlink/?LinkID=205219">the Rx Design Guidelines
+ * document</a>:
  * <pre>
  * Messages sent to instances of the IObserver interface follow the following grammar:
  * 
@@ -38,8 +39,8 @@
  * This grammar allows observable sequences to send any amount (0 or more) of OnNext messages to the subscribed
  * observer instance, optionally followed by a single success (OnCompleted) or failure (OnError) message.
  * 
- * The single message indicating that an observable sequence has finished ensures that consumers of the observable
- * sequence can deterministically establish that it is safe to perform cleanup operations.
+ * The single message indicating that an observable sequence has finished ensures that consumers of the
+ * observable sequence can deterministically establish that it is safe to perform cleanup operations.
  * 
  * A single failure further ensures that abort semantics can be maintained for operators that work on
  * multiple observable sequences (see paragraph 6.6).
@@ -57,7 +58,7 @@
  * It will not synchronize onNext execution. Use the {@link SynchronizedObserver} to do that.
  * 
  * @param <T>
- * @Deprecated Replaced by SafeSubscriber
+ * @deprecated replaced by SafeSubscriber
  */
 @Deprecated
 public class SafeObserver<T> implements Observer<T> {
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
index 5adc50e0d1..f3e7708669 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaDefaultSchedulers.java
@@ -18,29 +18,30 @@
 import rx.Scheduler;
 
 /**
- * Define alternate Scheduler implementations to be returned by the `Schedulers` factory methods.
+ * Define alternate Scheduler implementations to be returned by the {@code Schedulers} factory methods.
  * <p>
- * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins: <a
- * href="https://github.com/Netflix/RxJava/wiki/Plugins">https://github.com/Netflix/RxJava/wiki/Plugins</a>.
+ * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins:
+ * <a href="https://github.com/Netflix/RxJava/wiki/Plugins">https://github.com/Netflix/RxJava/wiki/Plugins</a>.
  */
 public abstract class RxJavaDefaultSchedulers {
 
     /**
-     * Scheduler to return from {@link Schedulers.computation()} or null if default should be used.
+     * Scheduler to return from {@link rx.schedulers.Schedulers#computation()} or null if default should be
+     * used.
      * 
      * This instance should be or behave like a stateless singleton;
      */
     public abstract Scheduler getComputationScheduler();
 
     /**
-     * Scheduler to return from {@link Schedulers.io()} or null if default should be used.
+     * Scheduler to return from {@link rx.schedulers.Schedulers#io()} or null if default should be used.
      * 
      * This instance should be or behave like a stateless singleton;
      */
     public abstract Scheduler getIOScheduler();
 
     /**
-     * Scheduler to return from {@link Schedulers.newThread()} or null if default should be used.
+     * Scheduler to return from {@link rx.schedulers.Schedulers#newThread()} or null if default should be used.
      * 
      * This instance should be or behave like a stateless singleton;
      */
diff --git a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
index 64402fe0de..0b21d20ffe 100644
--- a/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
+++ b/rxjava-core/src/main/java/rx/plugins/RxJavaObservableExecutionHook.java
@@ -23,34 +23,33 @@
 import rx.functions.Func1;
 
 /**
- * Abstract ExecutionHook with invocations at different lifecycle points of {@link Observable}
- * execution with a default no-op implementation.
+ * Abstract ExecutionHook with invocations at different lifecycle points of {@link Observable} execution with a
+ * default no-op implementation.
  * <p>
- * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins: <a
- * href ="https://github.com/Netflix/RxJava/wiki/Plugins">https://github.com/Netflix/RxJava/wiki/
- * Plugins </a>.
+ * See {@link RxJavaPlugins} or the RxJava GitHub Wiki for information on configuring plugins:
+ * <a href="https://github.com/Netflix/RxJava/wiki/Plugins">https://github.com/Netflix/RxJava/wiki/Plugins</a>.
  * <p>
- * <b>Note on thread-safety and performance</b>
+ * <b>Note on thread-safety and performance:</b>
  * <p>
- * A single implementation of this class will be used globally so methods on this class will be
- * invoked concurrently from multiple threads so all functionality must be thread-safe.
+ * A single implementation of this class will be used globally so methods on this class will be invoked
+ * concurrently from multiple threads so all functionality must be thread-safe.
  * <p>
- * Methods are also invoked synchronously and will add to execution time of the observable so all
- * behavior should be fast. If anything time-consuming is to be done it should be spawned
- * asynchronously onto separate worker threads.
+ * Methods are also invoked synchronously and will add to execution time of the observable so all behavior
+ * should be fast. If anything time-consuming is to be done it should be spawned asynchronously onto separate
+ * worker threads.
  * 
  */
 public abstract class RxJavaObservableExecutionHook {
     /**
      * Invoked during the construction by {@link Observable#create(OnSubscribe)}
      * <p>
-     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform
-     * extra logging, metrics and other such things and pass-thru the function.
+     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
+     * logging, metrics and other such things and pass-thru the function.
      * 
-     * @param onSubscribe
+     * @param f
      *            original {@link OnSubscribe}<{@code T}> to be executed
-     * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or
-     *         just returned as a pass-thru.
+     * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
+     *         returned as a pass-thru
      */
     public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
         return f;
@@ -59,13 +58,13 @@ public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
     /**
      * Invoked before {@link Observable#subscribe(rx.Subscriber)} is about to be executed.
      * <p>
-     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform
-     * extra logging, metrics and other such things and pass-thru the function.
+     * This can be used to decorate or replace the <code>onSubscribe</code> function or just perform extra
+     * logging, metrics and other such things and pass-thru the function.
      * 
      * @param onSubscribe
      *            original {@link OnSubscribe}<{@code T}> to be executed
-     * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or
-     *         just returned as a pass-thru.
+     * @return {@link OnSubscribe}<{@code T}> function that can be modified, decorated, replaced or just
+     *         returned as a pass-thru
      */
     public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInsance, final OnSubscribe<T> onSubscribe) {
         // pass-thru by default
@@ -73,16 +72,16 @@ public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableIns
     }
 
     /**
-     * Invoked after successful execution of {@link Observable#subscribe(rx.Subscriber)} with
-     * returned {@link Subscription}.
+     * Invoked after successful execution of {@link Observable#subscribe(rx.Subscriber)} with returned
+     * {@link Subscription}.
      * <p>
-     * This can be used to decorate or replace the {@link Subscription} instance or just perform
-     * extra logging, metrics and other such things and pass-thru the subscription.
+     * This can be used to decorate or replace the {@link Subscription} instance or just perform extra logging,
+     * metrics and other such things and pass-thru the subscription.
      * 
      * @param subscription
      *            original {@link Subscription}
-     * @return {@link Subscription} subscription that can be modified, decorated, replaced or just
-     *         returned as a pass-thru.
+     * @return {@link Subscription} subscription that can be modified, decorated, replaced or just returned as a
+     *         pass-thru
      */
     public <T> Subscription onSubscribeReturn(Subscription subscription) {
         // pass-thru by default
@@ -90,16 +89,14 @@ public <T> Subscription onSubscribeReturn(Subscription subscription) {
     }
 
     /**
-     * Invoked after failed execution of {@link Observable#subscribe(Subscriber)} with thrown
-     * Throwable.
+     * Invoked after failed execution of {@link Observable#subscribe(Subscriber)} with thrown Throwable.
      * <p>
-     * This is NOT errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown
-     * when attempting to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>},
-     * {@link Subscription}>.
+     * This is <em>not</em> errors emitted via {@link Subscriber#onError(Throwable)} but exceptions thrown when
+     * attempting to subscribe to a {@link Func1}<{@link Subscriber}{@code <T>}, {@link Subscription}>.
      * 
      * @param e
      *            Throwable thrown by {@link Observable#subscribe(Subscriber)}
-     * @return Throwable that can be decorated, replaced or just returned as a pass-thru.
+     * @return Throwable that can be decorated, replaced or just returned as a pass-thru
      */
     public <T> Throwable onSubscribeError(Throwable e) {
         // pass-thru by default
@@ -114,9 +111,9 @@ public <T> Throwable onSubscribeError(Throwable e) {
      * logging, metrics and other such things and pass-thru the onSubscribe.
      * 
      * @param lift
-     *            original {@link Operator}{@code<R, T>} ' * @return {@link Operator}{@code <R, T>}
-     *            function that can be modified, decorated, replaced or
-     *            just returned as a pass-thru.
+     *            original {@link Operator}{@code <R, T>}
+     * @return {@link Operator}{@code <R, T>} function that can be modified, decorated, replaced or just
+     *         returned as a pass-thru
      */
     public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> lift) {
         return lift;
diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
index c6f1344320..ff994f0759 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
@@ -29,16 +29,17 @@
 import rx.subscriptions.Subscriptions;
 
 /**
- * A {@link Scheduler} implementation that uses an {@link Executor} or {@link ScheduledExecutorService} implementation.
+ * A {@link Scheduler} implementation that uses an {@link Executor} or {@link ScheduledExecutorService}
+ * implementation.
  * <p>
- * Note that if an {@link Executor} implementation is used instead of {@link ScheduledExecutorService} then a system-wide Timer will be used to handle delayed events.
+ * Note that if an {@link Executor} implementation is used instead of {@link ScheduledExecutorService} then a
+ * system-wide Timer will be used to handle delayed events.
  */
 public class ExecutorScheduler extends Scheduler {
     private final Executor executor;
 
     /**
      * @deprecated Use Schedulers.executor();
-     * @return
      */
     @Deprecated
     public ExecutorScheduler(Executor executor) {
@@ -47,7 +48,6 @@ public ExecutorScheduler(Executor executor) {
 
     /**
      * @deprecated Use Schedulers.executor();
-     * @return
      */
     @Deprecated
     public ExecutorScheduler(ScheduledExecutorService executor) {
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 7bbfe61eaa..7aa8cc0e55 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -73,7 +73,7 @@ public static Scheduler immediate() {
      * {@link Scheduler} that queues work on the current thread to be executed after the current work completes.
      * 
      * @return {@link TrampolineScheduler} instance
-     * @deprecated Use trampoline() instead
+     * @deprecated use {@link #trampoline()} instead
      */
     @Deprecated
     public static Scheduler currentThread() {
@@ -121,14 +121,15 @@ public static Scheduler executor(ScheduledExecutorService executor) {
     /**
      * {@link Scheduler} intended for computational work.
      * <p>
-     * The implementation is backed by a {@link ScheduledExecutorService} thread-pool sized to the number of CPU cores.
+     * The implementation is backed by a {@link ScheduledExecutorService} thread-pool sized to the number of CPU
+     * cores.
      * <p>
      * This can be used for event-loops, processing callbacks and other computational work.
      * <p>
      * Do not perform IO-bound work on this scheduler. Use {@link #io()} instead.
      * 
-     * @return {@link ExecutorScheduler} for computation-bound work.
-     * @Deprecated Use {@link #computation()}
+     * @return {@link ExecutorScheduler} for computation-bound work
+     * @deprecated use {@link #computation()}
      */
     @Deprecated
     public static Scheduler threadPoolForComputation() {
@@ -142,7 +143,7 @@ public static Scheduler threadPoolForComputation() {
      * <p>
      * Do not perform IO-bound work on this scheduler. Use {@link #io()} instead.
      * 
-     * @return {@link Scheduler} for computation-bound work.
+     * @return {@link Scheduler} for computation-bound work
      */
     public static Scheduler computation() {
         return INSTANCE.computationScheduler;
@@ -157,8 +158,8 @@ public static Scheduler computation() {
      * <p>
      * Do not perform computational work on this scheduler. Use {@link #computation()} instead.
      * 
-     * @return {@link ExecutorScheduler} for IO-bound work.
-     * @deprecated Use {@link #io()} instead.
+     * @return {@link ExecutorScheduler} for IO-bound work
+     * @deprecated use {@link #io()} instead
      */
     @Deprecated
     public static Scheduler threadPoolForIO() {
@@ -174,7 +175,7 @@ public static Scheduler threadPoolForIO() {
      * <p>
      * Do not perform computational work on this scheduler. Use {@link #computation()} instead.
      * 
-     * @return {@link ExecutorScheduler} for IO-bound work.
+     * @return {@link ExecutorScheduler} for IO-bound work
      */
     public static Scheduler io() {
         return INSTANCE.ioScheduler;
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 5e33a85637..036da20a48 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -67,23 +67,27 @@
 public final class BehaviorSubject<T> extends Subject<T, T> {
 
     /**
-     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
+     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each
+     * {@link Observer} that subscribes to it.
      * 
      * @param defaultValue
-     *            The value which will be published to any {@link Observer} as long as the {@link BehaviorSubject} has not yet received any events.
-     * @return the constructed {@link BehaviorSubject}.
-     * @deprecated Use {@link create()} instead.
+     *            the value which will be published to any {@link Observer} as long as the
+     *            {@link BehaviorSubject} has not yet received any events
+     * @return the constructed {@link BehaviorSubject}
+     * @deprecated use {@link #create(T)} instead
      */
     public static <T> BehaviorSubject<T> createWithDefaultValue(T defaultValue) {
         return create(defaultValue);
     }
 
     /**
-     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
+     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each
+     * {@link Observer} that subscribes to it.
      * 
      * @param defaultValue
-     *            The value which will be published to any {@link Observer} as long as the {@link BehaviorSubject} has not yet received any events.
-     * @return the constructed {@link BehaviorSubject}.
+     *            the value which will be published to any {@link Observer} as long as the
+     *            {@link BehaviorSubject} has not yet received any events
+     * @return the constructed {@link BehaviorSubject}
      */
     public static <T> BehaviorSubject<T> create(T defaultValue) {
         final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
@@ -179,4 +183,4 @@ public void onNext(T v) {
         }
     }
 
-}
\ No newline at end of file
+}

From d46af6391fe41c05250c1f8b956c940c310db135 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 10 Mar 2014 14:41:59 +0800
Subject: [PATCH 083/422] Add amb, delay and delaySubscription in rxjava-scala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 31 ++++++++
 .../main/scala/rx/lang/scala/Observable.scala | 72 +++++++++++++++++++
 2 files changed, 103 insertions(+)

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 e7c09e769c..e09e6a7ec9 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
@@ -533,4 +533,35 @@ class RxScalaDemo extends JUnitSuite {
     println(result)
   }
 
+  @Test def ambExample(): Unit = {
+    val o1 = List(100L, 200L, 300L).toObservable.delay(4 seconds)
+    val o2 = List(1000L, 2000L, 3000L).toObservable.delay(2 seconds)
+    val result = o1.amb(o2).toBlockingObservable.toList
+    println(result)
+  }
+
+  @Test def delayExample(): Unit = {
+    val o = List(100L, 200L, 300L).toObservable.delay(2 seconds)
+    val result = o.toBlockingObservable.toList
+    println(result)
+  }
+
+  @Test def delayExample2(): Unit = {
+    val o = List(100L, 200L, 300L).toObservable.delay(2 seconds, IOScheduler())
+    val result = o.toBlockingObservable.toList
+    println(result)
+  }
+
+  @Test def delaySubscriptionExample(): Unit = {
+    val o = List(100L, 200L, 300L).toObservable.delaySubscription(2 seconds)
+    val result = o.toBlockingObservable.toList
+    println(result)
+  }
+
+  @Test def delaySubscriptionExample2(): Unit = {
+    val o = List(100L, 200L, 300L).toObservable.delaySubscription(2 seconds, IOScheduler())
+    val result = o.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 6794770232..75abe048a7 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
@@ -2236,6 +2236,78 @@ trait Observable[+T]
   def doOnEach(onNext: T => Unit, onError: Throwable => Unit, onCompleted: () => Unit): Observable[T] = {
     toScalaObservable[T](asJavaObservable.doOnEach(Observer(onNext, onError,onCompleted)))
   }
+
+  /**
+   * Given two Observables, mirror the one that first emits an item.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+   *
+   * You can combine items emitted by two Observables so that they act like a single
+   * Observable by using the `merge` method.
+   *
+   * @param that
+   *            an Observable competing to react first
+   * @return an Observable that emits the same sequence of items as whichever of `this` or `that` first emitted an item.
+   */
+  def amb[U >: T](that: Observable[U]): Observable[U] = {
+    val thisJava: rx.Observable[_ <: U] = this.asJavaObservable
+    val thatJava: rx.Observable[_ <: U] = that.asJavaObservable
+    toScalaObservable[U](rx.Observable.amb(thisJava, thatJava))
+  }
+
+  /**
+   * 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.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.png">
+   * 
+   * @param delay the delay to shift the source by
+   * @return the source Observable shifted in time by the specified delay
+   */
+  def delay(delay: Duration): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.delay(delay.length, delay.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.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.s.png">
+   * 
+   * @param delay the delay to shift the source by
+   * @param scheduler the Scheduler to use for delaying
+   * @return the source Observable shifted in time by the specified delay
+   */
+  def delay(delay: Duration, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.delay(delay.length, delay.unit, scheduler))
+  }
+
+  /**
+   * Return an Observable that delays the subscription to the source Observable by a given amount of time.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delaySubscription.png">
+   * 
+   * @param delay the time to delay the subscription
+   * @return an Observable that delays the subscription to the source Observable by the given amount
+   */
+  def delaySubscription(delay: Duration): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.delaySubscription(delay.length, delay.unit))
+  }
+
+  /**
+   * 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.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delaySubscription.s.png">
+   * 
+   * @param delay the time to delay the subscription
+   * @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
+   */
+  def delaySubscription(delay: Duration, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.delaySubscription(delay.length, delay.unit, scheduler))
+  }
 }
 
 /**

From b8a3cad8b684177be06e65a0bad7850d8e7e9382 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 10 Mar 2014 14:50:44 +0800
Subject: [PATCH 084/422]   Reimplement the amb operator

---
 .../main/java/rx/operators/OperationAmb.java  | 79 +++++++++----------
 .../java/rx/operators/OperationAmbTest.java   | 28 ++++---
 2 files changed, 54 insertions(+), 53 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationAmb.java b/rxjava-core/src/main/java/rx/operators/OperationAmb.java
index 16a6c307dd..7f723825d9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAmb.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAmb.java
@@ -20,24 +20,23 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Subscription;
-import rx.subscriptions.CompositeSubscription;
+import rx.Subscriber;
 
 /**
  * Propagates the observable sequence that reacts first.
  */
-public class OperationAmb {
+public final class OperationAmb<T> implements OnSubscribe<T>{
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
@@ -45,7 +44,7 @@ public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
@@ -54,7 +53,7 @@ public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
@@ -64,7 +63,7 @@ public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
@@ -75,7 +74,7 @@ public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
@@ -87,7 +86,7 @@ public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
@@ -100,7 +99,7 @@ public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> o9) {
+    public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> o9) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
         sources.add(o1);
         sources.add(o2);
@@ -114,40 +113,19 @@ public static <T> OnSubscribeFunc<T> amb(Observable<? extends T> o1, Observable<
         return amb(sources);
     }
 
-    public static <T> OnSubscribeFunc<T> amb(
-            final Iterable<? extends Observable<? extends T>> sources) {
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(final Observer<? super T> observer) {
-                AtomicInteger choice = new AtomicInteger(AmbObserver.NONE);
-                int index = 0;
-                CompositeSubscription parentSubscription = new CompositeSubscription();
-                for (Observable<? extends T> source : sources) {
-                    SafeObservableSubscription subscription = new SafeObservableSubscription();
-                    AmbObserver<T> ambObserver = new AmbObserver<T>(
-                            subscription, observer, index, choice);
-                    parentSubscription.add(subscription.wrap(source
-                            .subscribe(ambObserver)));
-                    index++;
-                }
-                return parentSubscription;
-            }
-        };
+    public static <T> OnSubscribe<T> amb(final Iterable<? extends Observable<? extends T>> sources) {
+        return new OperationAmb<T>(sources);
     }
 
-    private static class AmbObserver<T> implements Observer<T> {
+    private static final class AmbSubscriber<T> extends Subscriber<T> {
 
         private static final int NONE = -1;
 
-        private Subscription subscription;
         private Observer<? super T> observer;
         private int index;
         private AtomicInteger choice;
 
-        private AmbObserver(Subscription subscription,
-                Observer<? super T> observer, int index, AtomicInteger choice) {
-            this.subscription = subscription;
+        private AmbSubscriber(Subscriber<? super T> observer, int index, AtomicInteger choice) {
             this.observer = observer;
             this.choice = choice;
             this.index = index;
@@ -156,7 +134,7 @@ private AmbObserver(Subscription subscription,
         @Override
         public void onNext(T args) {
             if (!isSelected()) {
-                subscription.unsubscribe();
+                unsubscribe();
                 return;
             }
             observer.onNext(args);
@@ -165,7 +143,7 @@ public void onNext(T args) {
         @Override
         public void onCompleted() {
             if (!isSelected()) {
-                subscription.unsubscribe();
+                unsubscribe();
                 return;
             }
             observer.onCompleted();
@@ -174,7 +152,7 @@ public void onCompleted() {
         @Override
         public void onError(Throwable e) {
             if (!isSelected()) {
-                subscription.unsubscribe();
+                unsubscribe();
                 return;
             }
             observer.onError(e);
@@ -188,4 +166,25 @@ private boolean isSelected() {
         }
     }
 
+    private final Iterable<? extends Observable<? extends T>> sources;
+
+    private OperationAmb(Iterable<? extends Observable<? extends T>> sources) {
+        this.sources = sources;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> subscriber) {
+        AtomicInteger choice = new AtomicInteger(AmbSubscriber.NONE);
+        int index = 0;
+        for (Observable<? extends T> source : sources) {
+            if (subscriber.isUnsubscribed()) {
+                break;
+            }
+            AmbSubscriber<T> ambSubscriber = new AmbSubscriber<T>(subscriber, index, choice);
+            subscriber.add(ambSubscriber);
+            source.subscribe(ambSubscriber);
+            index++;
+        }
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java b/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
index 42d48f30df..07010830ec 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationAmb.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static rx.operators.OperationAmb.amb;
 
 import java.io.IOException;
 import java.util.concurrent.TimeUnit;
@@ -26,10 +28,10 @@
 import org.mockito.InOrder;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Scheduler.Inner;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.CompositeSubscription;
@@ -45,17 +47,18 @@ public void setUp() {
 
     private Observable<String> createObservable(final String[] values,
             final long interval, final Throwable e) {
-        return Observable.create(new OnSubscribeFunc<String>() {
+        return Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
+            public void call(final Subscriber<? super String> subscriber) {
                 CompositeSubscription parentSubscription = new CompositeSubscription();
+                subscriber.add(parentSubscription);
                 long delay = interval;
                 for (final String value : values) {
                     parentSubscription.add(scheduler.schedule(new Action1<Inner>() {
                         @Override
                         public void call(Inner inner) {
-                            observer.onNext(value);
+                            subscriber.onNext(value);
                         }
                     }, delay, TimeUnit.MILLISECONDS));
                     delay += interval;
@@ -64,13 +67,12 @@ public void call(Inner inner) {
                     @Override
                     public void call(Inner inner) {
                         if (e == null) {
-                            observer.onCompleted();
+                            subscriber.onCompleted();
                         } else {
-                            observer.onError(e);
+                            subscriber.onError(e);
                         }
                     }
                 }, delay, TimeUnit.MILLISECONDS));
-                return parentSubscription;
             }
         });
     }
@@ -104,12 +106,12 @@ public void testAmb() {
 
     @Test
     public void testAmb2() {
-        IOException needHappenedException = new IOException(
+        IOException expectedException = new IOException(
                 "fake exception");
         Observable<String> observable1 = createObservable(new String[] {},
                 2000, new IOException("fake exception"));
         Observable<String> observable2 = createObservable(new String[] {
-                "2", "22", "222", "2222" }, 1000, needHappenedException);
+                "2", "22", "222", "2222" }, 1000, expectedException);
         Observable<String> observable3 = createObservable(new String[] {},
                 3000, new IOException("fake exception"));
 
@@ -127,7 +129,7 @@ public void testAmb2() {
         inOrder.verify(observer, times(1)).onNext("22");
         inOrder.verify(observer, times(1)).onNext("222");
         inOrder.verify(observer, times(1)).onNext("2222");
-        inOrder.verify(observer, times(1)).onError(needHappenedException);
+        inOrder.verify(observer, times(1)).onError(expectedException);
         inOrder.verifyNoMoreInteractions();
     }
 

From cd84189b1c762f5a2861c1653808624e06f3a3da Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 10 Mar 2014 15:13:25 +0800
Subject: [PATCH 085/422] Rename OperationAmb to OperatorAmb

---
 rxjava-core/src/main/java/rx/Observable.java  | 20 +++++++++----------
 .../{OperationAmb.java => OperatorAmb.java}   |  6 +++---
 ...ationAmbTest.java => OperatorAmbTest.java} |  4 ++--
 3 files changed, 15 insertions(+), 15 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationAmb.java => OperatorAmb.java} (97%)
 rename rxjava-core/src/test/java/rx/operators/{OperationAmbTest.java => OperatorAmbTest.java} (98%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 5bfb5ad278..ab5405f916 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -52,7 +52,7 @@
 import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationAll;
-import rx.operators.OperationAmb;
+import rx.operators.OperatorAmb;
 import rx.operators.OperationAny;
 import rx.operators.OperationAsObservable;
 import rx.operators.OperationAverage;
@@ -300,7 +300,7 @@ public void call(Subscriber<? super R> o) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229115.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>> sources) {
-        return create(OperationAmb.amb(sources));
+        return create(OperatorAmb.amb(sources));
     }
 
     /**
@@ -318,7 +318,7 @@ public final static <T> Observable<T> amb(Iterable<? extends Observable<? extend
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {
-        return create(OperationAmb.amb(o1, o2));
+        return create(OperatorAmb.amb(o1, o2));
     }
 
     /**
@@ -338,7 +338,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) {
-        return create(OperationAmb.amb(o1, o2, o3));
+        return create(OperatorAmb.amb(o1, o2, o3));
     }
 
     /**
@@ -360,7 +360,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) {
-        return create(OperationAmb.amb(o1, o2, o3, o4));
+        return create(OperatorAmb.amb(o1, o2, o3, o4));
     }
 
     /**
@@ -384,7 +384,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5));
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5));
     }
 
     /**
@@ -410,7 +410,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6));
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6));
     }
 
     /**
@@ -438,7 +438,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7));
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7));
     }
 
     /**
@@ -468,7 +468,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
     }
 
     /**
@@ -500,7 +500,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
      */
     public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> o9) {
-        return create(OperationAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAmb.java b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
similarity index 97%
rename from rxjava-core/src/main/java/rx/operators/OperationAmb.java
rename to rxjava-core/src/main/java/rx/operators/OperatorAmb.java
index 7f723825d9..9ca467fea9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAmb.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
@@ -27,7 +27,7 @@
 /**
  * Propagates the observable sequence that reacts first.
  */
-public final class OperationAmb<T> implements OnSubscribe<T>{
+public final class OperatorAmb<T> implements OnSubscribe<T>{
 
     public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {
         List<Observable<? extends T>> sources = new ArrayList<Observable<? extends T>>();
@@ -114,7 +114,7 @@ public static <T> OnSubscribe<T> amb(Observable<? extends T> o1, Observable<? ex
     }
 
     public static <T> OnSubscribe<T> amb(final Iterable<? extends Observable<? extends T>> sources) {
-        return new OperationAmb<T>(sources);
+        return new OperatorAmb<T>(sources);
     }
 
     private static final class AmbSubscriber<T> extends Subscriber<T> {
@@ -168,7 +168,7 @@ private boolean isSelected() {
 
     private final Iterable<? extends Observable<? extends T>> sources;
 
-    private OperationAmb(Iterable<? extends Observable<? extends T>> sources) {
+    private OperatorAmb(Iterable<? extends Observable<? extends T>> sources) {
         this.sources = sources;
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
index 07010830ec..323eda3ca5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAmbTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
@@ -18,7 +18,7 @@
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
-import static rx.operators.OperationAmb.amb;
+import static rx.operators.OperatorAmb.amb;
 
 import java.io.IOException;
 import java.util.concurrent.TimeUnit;
@@ -36,7 +36,7 @@
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.CompositeSubscription;
 
-public class OperationAmbTest {
+public class OperatorAmbTest {
 
     private TestScheduler scheduler;
 

From a3f7a8359ff3df56047357cb1058bfa22f5c5aa7 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 10 Mar 2014 22:27:39 +0800
Subject: [PATCH 086/422] Rename observer to subscriber and add a special logic
 to exit the loop

---
 .../main/java/rx/operators/OperatorAmb.java   | 21 +++++++++++--------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAmb.java b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
index 9ca467fea9..c9b408546b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
@@ -21,7 +21,6 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Observer;
 import rx.Subscriber;
 
 /**
@@ -121,12 +120,12 @@ private static final class AmbSubscriber<T> extends Subscriber<T> {
 
         private static final int NONE = -1;
 
-        private Observer<? super T> observer;
-        private int index;
-        private AtomicInteger choice;
+        private final Subscriber<? super T> subscriber;
+        private final int index;
+        private final AtomicInteger choice;
 
-        private AmbSubscriber(Subscriber<? super T> observer, int index, AtomicInteger choice) {
-            this.observer = observer;
+        private AmbSubscriber(Subscriber<? super T> subscriber, int index, AtomicInteger choice) {
+            this.subscriber = subscriber;
             this.choice = choice;
             this.index = index;
         }
@@ -137,7 +136,7 @@ public void onNext(T args) {
                 unsubscribe();
                 return;
             }
-            observer.onNext(args);
+            subscriber.onNext(args);
         }
 
         @Override
@@ -146,7 +145,7 @@ public void onCompleted() {
                 unsubscribe();
                 return;
             }
-            observer.onCompleted();
+            subscriber.onCompleted();
         }
 
         @Override
@@ -155,7 +154,7 @@ public void onError(Throwable e) {
                 unsubscribe();
                 return;
             }
-            observer.onError(e);
+            subscriber.onError(e);
         }
 
         private boolean isSelected() {
@@ -180,6 +179,10 @@ public void call(Subscriber<? super T> subscriber) {
             if (subscriber.isUnsubscribed()) {
                 break;
             }
+            if (choice.get() != AmbSubscriber.NONE) {
+                // Already choose someone, the rest Observables can be skipped.
+                break;
+            }
             AmbSubscriber<T> ambSubscriber = new AmbSubscriber<T>(subscriber, index, choice);
             subscriber.add(ambSubscriber);
             source.subscribe(ambSubscriber);

From 0979f84a1663f5a7b9ead5629022bb5d78defcd1 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 10 Mar 2014 22:38:29 +0800
Subject: [PATCH 087/422] Fix docs

---
 .../rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala | 3 ---
 1 file changed, 3 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 75abe048a7..8dafa30e2b 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
@@ -2242,9 +2242,6 @@ trait Observable[+T]
    *
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
    *
-   * You can combine items emitted by two Observables so that they act like a single
-   * Observable by using the `merge` method.
-   *
    * @param that
    *            an Observable competing to react first
    * @return an Observable that emits the same sequence of items as whichever of `this` or `that` first emitted an item.

From 29b5150d06593f266fb18e1aa5aea0bfd1c390f4 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 10 Mar 2014 23:15:54 +0800
Subject: [PATCH 088/422] Change to a single 'get' call

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

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAmb.java b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
index c9b408546b..a2bb92ebaf 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
@@ -158,10 +158,11 @@ public void onError(Throwable e) {
         }
 
         private boolean isSelected() {
-            if (choice.get() == NONE) {
+            int ch = choice.get();
+            if (ch == NONE) {
                 return choice.compareAndSet(NONE, index);
             }
-            return choice.get() == index;
+            return ch == index;
         }
     }
 

From 29fde71d5a5bb95d6c589253db9a45d2ee80e7ce Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 10 Mar 2014 10:28:16 -0700
Subject: [PATCH 089/422] Version 0.17.0

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

diff --git a/CHANGES.md b/CHANGES.md
index 527d52ba3c..d89b86558f 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,100 @@
 # RxJava Releases #
 
+### Version 0.17.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.0%22)) ###
+
+* [Pull 767](https://github.com/Netflix/RxJava/pull/767) Zip fix for multiple onCompleted and moved unsubscribe outside the lock.
+* [Pull 770](https://github.com/Netflix/RxJava/pull/770) Bind Operator
+* [Pull 778](https://github.com/Netflix/RxJava/pull/778) Fix zip race condition 
+* [Pull 784](https://github.com/Netflix/RxJava/pull/784) Lift and Observer+Subscription
+* [Pull 793](https://github.com/Netflix/RxJava/pull/793) Observer + Subscriber
+* [Pull 796](https://github.com/Netflix/RxJava/pull/796) Add Subscription.isUnsubscribed()
+* [Pull 797](https://github.com/Netflix/RxJava/pull/797) Scheduler Outer/Inner [Preview]
+* [Pull 805](https://github.com/Netflix/RxJava/pull/805) Fix CompositeException
+* [Pull 785](https://github.com/Netflix/RxJava/pull/785) Reimplement Zip Operator Using Lift [Preview]
+* [Pull 814](https://github.com/Netflix/RxJava/pull/814) RunAsync method for outputting multiple values
+* [Pull 812](https://github.com/Netflix/RxJava/pull/812) Fixed OperationSubscribeOn so OperationConditionalsTest works again.
+* [Pull 816](https://github.com/Netflix/RxJava/pull/816) One global onCompleted object
+* [Pull 818](https://github.com/Netflix/RxJava/pull/818) CompositeSubscription memory reduction
+* [Pull 817](https://github.com/Netflix/RxJava/pull/817) Scala Scheduler Bindings Fix
+* [Pull 819](https://github.com/Netflix/RxJava/pull/819) CompositeSubscription performance increase
+* [Pull 781](https://github.com/Netflix/RxJava/pull/781) Fixed buglet in join binding, simplified types
+* [Pull 783](https://github.com/Netflix/RxJava/pull/783) Implement some Android UI related operators
+* [Pull 821](https://github.com/Netflix/RxJava/pull/821) Update to use Subscriber/Subscriptions.create
+* [Pull 826](https://github.com/Netflix/RxJava/pull/826) Return wrapped Subscription
+* [Pull 824](https://github.com/Netflix/RxJava/pull/824) Set setDaemon on NewThreadScheduler
+* [Pull 828](https://github.com/Netflix/RxJava/pull/828) Repeat Operator
+* [Pull 827](https://github.com/Netflix/RxJava/pull/827) Fixed cut & paster error in io scheduler
+* [Pull 833](https://github.com/Netflix/RxJava/pull/833) Take operator was breaking the unsubscribe chain
+* [Pull 822](https://github.com/Netflix/RxJava/pull/822) Reimplement 'subscribeOn' using 'lift'
+* [Pull 832](https://github.com/Netflix/RxJava/pull/832) Issue #831 Fix for OperationJoin race condition
+* [Pull 834](https://github.com/Netflix/RxJava/pull/834) Update clojure for 0.17
+* [Pull 839](https://github.com/Netflix/RxJava/pull/839) Error Handling: OnErrorNotImplemented and java.lang.Error
+* [Pull 838](https://github.com/Netflix/RxJava/pull/838) Make Scala OnCompleted Notification an object
+* [Pull 837](https://github.com/Netflix/RxJava/pull/837) Perf with JMH
+* [Pull 841](https://github.com/Netflix/RxJava/pull/841) Range OnSubscribe
+* [Pull 842](https://github.com/Netflix/RxJava/pull/842) Test Unsubscribe
+* [Pull 845](https://github.com/Netflix/RxJava/pull/845) Fix problem with Subscription 
+* [Pull 847](https://github.com/Netflix/RxJava/pull/847) Various Changes While Fixing GroupBy
+* [Pull 849](https://github.com/Netflix/RxJava/pull/849) Add 'Fragment-Host' to rxjava-contrib modules for OSGi
+* [Pull 851](https://github.com/Netflix/RxJava/pull/851) Reimplement the timeout operator and fix timeout bugs
+* [Pull 846](https://github.com/Netflix/RxJava/pull/846) Added overloaded createRequest method that takes an HttpContext instance
+* [Pull 777](https://github.com/Netflix/RxJava/pull/777) Fixed testSingleSourceManyIterators
+* [Pull 852](https://github.com/Netflix/RxJava/pull/852) rxjava-debug
+* [Pull 853](https://github.com/Netflix/RxJava/pull/853) StringObservable Update
+* [Pull 763](https://github.com/Netflix/RxJava/pull/763) Added support for custom functions in combineLatest.
+* [Pull 854](https://github.com/Netflix/RxJava/pull/854) The onCreate hook disappeared
+* [Pull 857](https://github.com/Netflix/RxJava/pull/857) Change Lift to use rx.Observable.Operator 
+* [Pull 859](https://github.com/Netflix/RxJava/pull/859) Add 'Fragment-Host' to rxjava-contrib/debug module for OSGi
+* [Pull 860](https://github.com/Netflix/RxJava/pull/860) Fixing the generics for merge and lift
+* [Pull 863](https://github.com/Netflix/RxJava/pull/863) Optimize SwingMouseEventSource.fromRelativeMouseMotion
+* [Pull 862](https://github.com/Netflix/RxJava/pull/862) Update the timeout docs
+* [Pull 790](https://github.com/Netflix/RxJava/pull/790) Convert to scan to use lift
+* [Pull 866](https://github.com/Netflix/RxJava/pull/866) Update OperationScan to OperatorScan
+* [Pull 870](https://github.com/Netflix/RxJava/pull/870) Add the selector variants of timeout in RxScala
+* [Pull 874](https://github.com/Netflix/RxJava/pull/874) Update CompositeSubscriptionTest.java
+* [Pull 869](https://github.com/Netflix/RxJava/pull/869) subscribeOn + groupBy
+* [Pull 751](https://github.com/Netflix/RxJava/pull/751) Provide Observable.timestamp(Scheduler) to be used in the tests. 
+* [Pull 878](https://github.com/Netflix/RxJava/pull/878) Scheduler.scheduleRecursive
+* [Pull 877](https://github.com/Netflix/RxJava/pull/877) Correct synchronization guard in groupByUntil
+* [Pull 880](https://github.com/Netflix/RxJava/pull/880) Force ViewObservable be subscribed and unsubscribed in the UI thread
+* [Pull 887](https://github.com/Netflix/RxJava/pull/887) Remove Bad Filter Logic 
+* [Pull 890](https://github.com/Netflix/RxJava/pull/890) Split SubscribeOn into SubscribeOn/UnsubscribeOn
+* [Pull 891](https://github.com/Netflix/RxJava/pull/891) Eliminate rx.util.* dumping grounds
+* [Pull 881](https://github.com/Netflix/RxJava/pull/881) Lift Performance
+* [Pull 893](https://github.com/Netflix/RxJava/pull/893) Change Parallel to use Long instead of Int
+* [Pull 894](https://github.com/Netflix/RxJava/pull/894) Synchronized Operator Check for isTerminated
+* [Pull 885](https://github.com/Netflix/RxJava/pull/885) Fixed an issue with the from(Reader) added a bunch of unit tests.
+* [Pull 896](https://github.com/Netflix/RxJava/pull/896) removing java 7 dep
+* [Pull 883](https://github.com/Netflix/RxJava/pull/883) Make Subscriptions of SwingObservable thread-safe
+* [Pull 895](https://github.com/Netflix/RxJava/pull/895) Rewrite OperationObserveFromAndroidComponent to OperatorObserveFromAndroid
+* [Pull 892](https://github.com/Netflix/RxJava/pull/892) onErrorFlatMap + OnErrorThrowable
+* [Pull 898](https://github.com/Netflix/RxJava/pull/898) Handle illegal errors thrown from plugin
+* [Pull 901](https://github.com/Netflix/RxJava/pull/901) GroupBy Unit Test from #900
+* [Pull 902](https://github.com/Netflix/RxJava/pull/902) Fixed NullPointerException that may happen on timeout
+* [Pull 903](https://github.com/Netflix/RxJava/pull/903) Scheduler.Recurse fields should be private
+* [Pull 904](https://github.com/Netflix/RxJava/pull/904) Merge: Unsubscribe Completed Inner Observables
+* [Pull 905](https://github.com/Netflix/RxJava/pull/905) RxJavaSchedulers Plugin
+* [Pull 909](https://github.com/Netflix/RxJava/pull/909) Scheduler Plugin Refactor 
+* [Pull 910](https://github.com/Netflix/RxJava/pull/910) Remove groupBy with selector
+* [Pull 918](https://github.com/Netflix/RxJava/pull/918) Operator: doOnTerminate
+* [Pull 919](https://github.com/Netflix/RxJava/pull/919) BugFix: Zip Never Completes When Zero Observables
+* [Pull 920](https://github.com/Netflix/RxJava/pull/920) Delete Deprecated onSubscribeStart That Doesn't Work
+* [Pull 922](https://github.com/Netflix/RxJava/pull/922) Changes made while integrating it with our internal system
+* [Pull 924](https://github.com/Netflix/RxJava/pull/924) Localized Operator Error Handling
+* [Pull 925](https://github.com/Netflix/RxJava/pull/925) Rxjava clojure bindings final 
+* [Pull 926](https://github.com/Netflix/RxJava/pull/926) TestSubscriber: Default onError and Terminal Latch Behavior
+* [Pull 927](https://github.com/Netflix/RxJava/pull/927) TestSubscriber lastSeenThread 
+* [Pull 936](https://github.com/Netflix/RxJava/pull/936) Skip fixed
+* [Pull 942](https://github.com/Netflix/RxJava/pull/942) MathObservable
+* [Pull 944](https://github.com/Netflix/RxJava/pull/944) OperationRetry -> OperatorRetry
+* [Pull 945](https://github.com/Netflix/RxJava/pull/945) refactor the debug hooks before they become a breaking change.
+* [Pull 934](https://github.com/Netflix/RxJava/pull/934) add Observable.startWith(Observable) method and unit test
+* [Pull 929](https://github.com/Netflix/RxJava/pull/929) correct link to maven search
+* [Pull 923](https://github.com/Netflix/RxJava/pull/923) Observable creation from Subscriber[T]=>Unit for Scala
+* [Pull 931](https://github.com/Netflix/RxJava/pull/931) A number of improvements to OperatorObserveFromAndroidComponent 
+* [Pull 950](https://github.com/Netflix/RxJava/pull/950) Add support for Eclipse PDE
+
+
 ### 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

From 7983e575d72ca854ae392152139afff13f265e36 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 10 Mar 2014 10:44:23 -0700
Subject: [PATCH 090/422] 0.17.0 Release Notes

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

diff --git a/CHANGES.md b/CHANGES.md
index d89b86558f..9fd9365484 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -2,6 +2,647 @@
 
 ### Version 0.17.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.0%22)) ###
 
+
+# 0.17.0 Release Notes
+
+
+Version 0.17.0 contains some significant signature changes that allow us to significantly improve handling of synchronous Observables and simplify Schedulers. Many of the changes have backwards compatible deprecated methods to ease the migration while some are breaking. 
+
+The new signatures related to `Observable` in this release are:
+
+```java
+// A new create method takes `OnSubscribe` instead of `OnSubscribeFunc`
+public final static <T> Observable<T> create(OnSubscribe<T> f)
+
+// The new OnSubscribe type accepts a Subscriber instead of Observer and does not return a Subscription
+public static interface OnSubscribe<T> extends Action1<Subscriber<? super T>>
+
+// Subscriber is an Observer + Subscription
+public abstract class Subscriber<T> implements Observer<T>, Subscription
+
+// The main `subscribe` behavior receives a Subscriber instead of Observer
+public final Subscription subscribe(Subscriber<? super T> subscriber)
+
+// Subscribing with an Observer however is still appropriate
+// and the Observer is automatically converted into a Subscriber
+public final Subscription subscribe(Observer<? super T> observer)
+
+// A new 'lift' function allows composing Operator implementations together
+public <R> Observable<R> lift(final Operator<? extends R, ? super T> lift)
+	
+// The `Operator` used with `lift`
+public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>>
+
+```
+
+Also changed is the `Scheduler` interface which is much simpler:
+
+```java
+public abstract class Scheduler {
+	public Subscription schedule(Action1<Scheduler.Inner> action);
+    public Subscription schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit);
+	public Subscription schedulePeriodically(Action1<Scheduler.Inner> action, long initialDelay, long period, TimeUnit unit);
+	public final Subscription scheduleRecursive(final Action1<Recurse> action)
+	public long now();
+	public int degreeOfParallelism();
+	
+	public static class Inner implements Subscription {
+		public abstract void schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit);
+		public abstract void schedule(Action1<Scheduler.Inner> action);
+		public long now();
+	}
+	
+	public static final class Recurse {
+		public final void schedule();
+		public final void schedule(long delay, TimeUnit unit);
+	}
+}
+```
+
+
+This release applies many lessons learned over the past year and seeks to streamline the API before we hit 1.0.
+
+As shown in the code above the changes fall into 2 major sections:
+
+#### 1) Lift/Operator/OnSubscribe/Subscriber
+
+Changes that allow unsubscribing from synchronous Observables without needing to add concurrency.
+
+#### 2) Schedulers
+
+Simplification of the `Scheduler` interface and make clearer the concept of "outer" and "inner" Schedulers for recursion.
+
+
+## Lift/Operator/OnSubscribe/Subscriber
+
+New types `Subscriber` and `OnSubscribe` along with the new `lift` function have been added. The reasons and benefits are as follows:
+
+### 1) Synchronous Unsubscribe
+
+RxJava versions up until 0.16.x are unable to unsubscribe from a synchronous Observable such as this:
+
+```java
+Observable<Integer> oi = Observable.create(new OnSubscribe<Integer>() {
+
+    @Override
+    public void call(Observer<? super Integer> Observer) {
+        for (int i = 1; i < 1000000; i++) {
+            subscriber.onNext(i);
+        }
+        subscriber.onCompleted();
+    }
+});
+```
+
+Subscribing to this `Observable` will always emit all 1,000,000 values even if unsubscribed such as via `oi.take(10)`.
+
+Version 0.17.0 fixes this issue by injecting the `Subscription` into the `OnSubscribe` function to allow code like this:
+
+```java
+Observable<Integer> oi = Observable.create(new OnSubscribe<Integer>() {
+
+    @Override
+    public void call(Subscriber<? super Integer> subscriber) {
+        // we now receive a Subscriber instead of Observer
+        for (int i = 1; i < 1000000; i++) {
+            // the OnSubscribe can now check for isUnsubscribed
+            if (subscriber.isUnsubscribed()) {
+                return;
+            }
+            subscriber.onNext(i);
+        }
+        subscriber.onCompleted();
+    }
+
+});
+```
+
+Subscribing to this will now correctly only emit 10 `onNext` and unsubscribe:
+
+```java
+// subscribe with an Observer
+oi.take(10).subscribe(new Observer<Integer>() {
+
+    @Override
+    public void onCompleted() {
+
+    }
+
+    @Override
+    public void onError(Throwable e) {
+
+    }
+
+    @Override
+    public void onNext(Integer t) {
+        println("Received: " + t);
+    }
+
+})
+```
+
+Or the new `Subscriber` type can be used and the `Subscriber` itself can `unsubscribe`:
+
+```java
+// or subscribe with a Subscriber which supports unsubscribe
+oi.subscribe(new Subscriber<Integer>() {
+
+    @Override
+    public void onCompleted() {
+
+    }
+
+    @Override
+    public void onError(Throwable e) {
+
+    }
+
+    @Override
+    public void onNext(Integer t) {
+        println("Received: " + t);
+        if(t >= 10) {
+            // a Subscriber can unsubscribe
+            this.unsubscribe();
+        }
+    }
+
+})
+```
+
+
+### 2) Custom Operator Chaining
+
+Because Java doesn't support extension methods, the only approach to applying custom operators without getting them added to `rx.Observable` is using static methods. This has meant code like this:
+
+```java
+MyCustomerOperators.operate(observable.map(...).filter(...).take(5)).map(...).subscribe()
+```
+
+In reality we want:
+
+```java
+observable.map(...).filter(...).take(5).myCustomOperator().map(...).subscribe()
+```
+
+Using the newly added `lift` we can get quite close to this:
+
+
+```java
+observable.map(...).filter(...).take(5).lift(MyCustomOperator.operate()).map(...).subscribe()
+```
+
+Here is how the proposed `lift` method looks if all operators were applied with it:
+
+```java
+Observable<String> os = OBSERVABLE_OF_INTEGERS.lift(TAKE_5).lift(MAP_INTEGER_TO_STRING);
+```
+
+Along with the `lift` function comes a new `Operator` signature:
+
+```java
+public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>>
+```
+
+All operator implementations in the `rx.operators` package will over time be migrated to this new signature. 
+
+NOTE: Operators that have not yet been migrated do not work with synchronous unsubscribe. 
+
+
+### 3) Simpler Operator Implementations
+
+The `lift` operator injects the necessary `Observer` and `Subscription` instances (via the new `Subscriber` type) and eliminates (for most use cases) the need for manual subscription management. Because the `Subscription` is available in-scope there are no awkward coding patterns needed for creating a `Subscription`, closing over it and returning and taking into account synchronous vs asynchronous.
+
+For example, the body of `fromIterable` is simply:
+
+```java
+public void call(Subscriber<? super T> o) {
+    for (T i : is) {
+        if (o.isUnsubscribed()) {
+            return;
+        }
+        o.onNext(i);
+    }
+    o.onCompleted();
+}
+```
+
+The `take` operator is:
+
+```java
+public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        final CompositeSubscription parent = new CompositeSubscription();
+        if (limit == 0) {
+            child.onCompleted();
+            parent.unsubscribe();
+        }
+
+        child.add(parent);
+        return new Subscriber<T>(parent) {
+
+            int count = 0;
+            boolean completed = false;
+
+            @Override
+            public void onCompleted() {
+                if (!completed) {
+                    child.onCompleted();
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                if (!completed) {
+                    child.onError(e);
+                }
+            }
+
+            @Override
+            public void onNext(T i) {
+                if (!isUnsubscribed()) {
+                    child.onNext(i);
+                    if (++count >= limit) {
+                        completed = true;
+                        child.onCompleted();
+                        unsubscribe();
+                    }
+                }
+            }
+
+        };
+    }
+```
+
+
+### 4) Recursion/Loop Performance with Unsubscribe
+
+The `fromIterable` use case is 20x faster when implemented as a loop instead of recursive scheduler (see https://github.com/Netflix/RxJava/commit/a18b8c1a572b7b9509b7a7fe1a5075ce93657771).
+
+Several places we can remove recursive scheduling used originally for unsubscribe support and use a loop instead.
+
+
+
+
+
+## Schedulers
+
+
+Schedulers were greatly simplified to a design based around `Action1<Inner>`. 
+
+```java
+public abstract class Scheduler {
+	public Subscription schedule(Action1<Scheduler.Inner> action);
+    public Subscription schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit);
+	public Subscription schedulePeriodically(Action1<Scheduler.Inner> action, long initialDelay, long period, TimeUnit unit);
+	public final Subscription scheduleRecursive(final Action1<Recurse> action)
+	public long now();
+	public int degreeOfParallelism();
+	
+	public static class Inner implements Subscription {
+		public abstract void schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit);
+		public abstract void schedule(Action1<Scheduler.Inner> action);
+		public long now();
+	}
+	
+	public static final class Recurse {
+		public final void schedule();
+		public final void schedule(long delay, TimeUnit unit);
+	}
+}
+```
+
+This design change originated from three findings:
+
+1) It was very easy to cause memory leaks or inadvertent parallel execution since the distinction between outer and inner scheduling was not obvious.
+
+To solve this the new design explicitly has the outer `Scheduler` and then `Scheduler.Inner` for recursion.
+
+2) The passing of state is not useful since scheduling over network boundaries with this model does not work.
+
+In this new design all state passing signatures have been removed. This was determined while implementing a `RemoteScheduler` that attempted to use `observeOn` to transition execution from one machine to another. This does not work because of the requirement for serializing/deserializing the state of the entire execution stack. Migration of work over the network has been bound to be better suited to explicit boundaries established by Subjects. Thus, the complications within the Schedulers are unnecessary.
+
+3) The number of overloads with different ways of doing the same things were confusing.
+
+This new design removes all but the essential and simplest methods.
+
+4) A scheduled task could not do work in a loop and easily be unsubscribed which generally meant less efficient recursive scheduling. 
+
+This new design applies similar principles as done with `lift`/`create`/`OnSubscribe`/`Subscriber` and injects the `Subscription` via the `Inner` interface so a running task can check `isUnsubscribed()`.
+
+
+
+WIth this new design, the simplest execution of a single task is:
+
+```java
+Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        doWork();
+    }
+
+});
+```
+
+Recursion is easily invoked like this:
+
+```java
+Schedulers.newThread().scheduleRecursive(new Action1<Recurse>() {
+
+    @Override
+    public void call(Recurse recurse) {
+        doWork();
+        // recurse until unsubscribed (the schedule will do nothing if unsubscribed)
+        recurse.schedule();
+    }
+
+
+});
+```
+
+or like this if the outer and inner actions need different behavior:
+
+```java
+Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        doWork();
+        // recurse until unsubscribed (the schedule will do nothing if unsubscribed)
+        inner.schedule(this);
+    }
+
+});
+
+
+The use of `Action1<Inner>` on both the outer and inner levels makes it so recursion that refer to `this` and it works easily. 
+
+
+Similar to the new `lift`/`create` pattern with `Subscriber` the `Inner` is also a `Subscription` so it allows efficient loops with `unsubscribe` support:
+
+```java
+Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        while(!inner.isUnsubscribed()) {
+            doWork();
+        }
+    }
+
+});
+```
+
+An action can now `unsubscribe`	the `Scheduler.Inner`:
+
+```java
+Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        while(!inner.isUnsubscribed()) {
+            int i = doOtherWork();
+            if(i > 100) {
+                // an Action can cause the Scheduler to unsubscribe and stop
+                inner.unsubscribe();
+            }
+        }
+    }
+
+});
+```
+
+Typically just stopping is sufficient:
+
+```java
+Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        int i = doOtherWork();
+        if (i < 10) {
+            // recurse until done 10
+            inner.schedule(this);
+        }
+    }
+
+});
+```
+
+but if other work in other tasks is being done and you want to unsubscribe conditionally you could:
+
+```java
+Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        int i = doOtherWork();
+        if (i < 10) {
+            // recurse until done 10
+            inner.schedule(this);
+        } else {
+            inner.unsubscribe();
+        }
+    }
+
+});
+```
+
+and the recursion can be delayed:
+
+```java
+Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        doWork();
+        // recurse until unsubscribed ... but delay the recursion
+        inner.schedule(this, 500, TimeUnit.MILLISECONDS);
+    }
+
+});
+```
+
+The same pattern works with the `Recurse` signature:
+
+```java
+Schedulers.newThread().scheduleRecursive(new Action1<Recurse>() {
+
+    @Override
+    public void call(Recurse recurse) {
+        doWork();
+        // recurse until unsubscribed (the schedule will do nothing if unsubscribed)
+        recurse.schedule(500, TimeUnit.MILLISECONDS);
+    }
+
+
+});
+``
+
+The methods on the `Inner` never return a `Subscription` because they are always a single thread/event-loop/actor/etc and controlled by the `Subscription` returned by the initial `Scheduler.schedule` method. This is part of clarifying the contract.
+
+Thus an `unsubscribe` controlled from the outside would be done like this:
+
+```java
+Subscription s = Schedulers.newThread().schedule(new Action1<Inner>() {
+
+    @Override
+    public void call(Inner inner) {
+        while(!inner.isUnsubscribed()) {
+            doWork();
+        }
+    }
+
+});
+
+// unsubscribe from outside
+s.unsubscribe();
+```
+
+
+
+## Migration Path
+
+#### 1) Lift/OnSubscribe/Subscriber
+
+The `lift` function will not be used by most and is additive so will not affect backwards compatibility. The `Subscriber` type is also additive and for most use cases does not need to be used directly, the `Observer` interface can continue being used.
+
+The previous `create(OnSubscribeFunc f)` signature has been deprecated so code will work but now have warnings. Please begin migrating code as this will be deleted prior to the 1.0 release.
+
+Code such as this:
+
+```java
+Observable.create(new OnSubscribeFunc<Integer>() {
+
+    @Override
+    public Subscription onSubscribe(Observer<? super Integer> o) {
+        o.onNext(1);
+        o.onCompleted();
+        return Subscriptions.empty();
+    }
+});
+```
+
+should change to this:
+
+```java
+Observable.create(new OnSubscribe<Integer>() {
+
+    @Override
+    public void call(Subscriber<? super Integer> subscriber) {
+        subscriber.onNext(1);
+        subscriber.onCompleted();
+    }
+});
+```
+
+If concurrency was being injected to allow unsubscribe support:
+
+```java
+Observable.create(new OnSubscribeFunc<Integer>() {
+
+    @Override
+    public Subscription onSubscribe(final Observer<? super Integer> o) {
+        final BooleanSubscription s = new BooleanSubscription();
+        Thread t = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                int i = 0;
+                while (s.isUnsubscribed()) {
+                    o.onNext(i++);
+                }
+            }
+
+        });
+        t.start();
+        return s;
+    }
+});
+```
+
+you may no longer need it and can implement like this instead:
+
+```java
+Observable.create(new OnSubscribe<Integer>() {
+
+    @Override
+    public void call(Subscriber<? super Integer> subscriber) {
+        int i = 0;
+        while (subscriber.isUnsubscribed()) {
+            subscriber.onNext(i++);
+        }
+    }
+});
+```
+
+or if the concurreny is still desired you can simplify the `Subscription` management:
+
+```java
+Observable.create(new OnSubscribe<Integer>() {
+
+    @Override
+    public void call(final Subscriber<? super Integer> subscriber) {
+        Thread t = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                int i = 0;
+                while (subscriber.isUnsubscribed()) {
+                    subscriber.onNext(i++);
+                }
+            }
+
+        });
+        t.start();
+    }
+});
+```
+
+or use `subscribeOn` which now works to make synchronous `Observables` async while supporting `unsubscribe` (this didn't work before):
+
+```java
+Observable.create(new OnSubscribe<Integer>() {
+
+    @Override
+    public void call(Subscriber<? super Integer> subscriber) {
+        int i = 0;
+        while (subscriber.isUnsubscribed()) {
+            subscriber.onNext(i++);
+        }
+    }
+}).subscribeOn(Schedulers.newThread());
+```
+
+
+
+#### 2) Schedulers
+
+Custom `Scheduler` implementations will need to be re-implemented and any direct use of the `Scheduler` interface will also need to be updated.
+
+
+##### 3) Subscription
+
+If you have custom `Subscription` implementations you will see they now need an `isUnsubscribed()` method.
+
+You can either add this method, or wrap your function using `Subscriptions.create` and it will handle the `isUnsubscribed` behavior and execute your function when `unsubscribe()` is called.
+
+It is recommended to use `Subscriptions.create` for most `Subscription` usage.
+
+
+
+# The Future...
+
+We have most if not all operators from Rx.Net that we want or intend to port. We think we have got the `create`/`subscribe` signatures as we want and the `Subscription` and `Scheduler` interfaces are now clean. There is at least one more major topic related to back pressure that may result in signature change in a future release. Beyond that no further major signature changing work is expected prior to 1.0.
+
+We still need to improve on some of the `Subject` implementations still, particularly `ReplaySubject`. We are beginning to focus after this release on cleaning up all of the operator implementations, stabilizing, fixing bugs and performance tuning.
+
+As we get closer to 1.0 there will be a release that focused on deleting all deprecated methods so it is suggested to start migrating off of them.
+
+We appreciate your usage, feedback and contributions and hope the library is creating value for you!
+
+
+
+
 * [Pull 767](https://github.com/Netflix/RxJava/pull/767) Zip fix for multiple onCompleted and moved unsubscribe outside the lock.
 * [Pull 770](https://github.com/Netflix/RxJava/pull/770) Bind Operator
 * [Pull 778](https://github.com/Netflix/RxJava/pull/778) Fix zip race condition 

From 8166d5da219bdd7529ad749e266dfab1c0c8b227 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 10 Mar 2014 10:48:12 -0700
Subject: [PATCH 091/422] Version 0.17.0 Release Notes

---
 CHANGES.md | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 9fd9365484..9451d876a4 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -3,9 +3,6 @@
 ### Version 0.17.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.0%22)) ###
 
 
-# 0.17.0 Release Notes
-
-
 Version 0.17.0 contains some significant signature changes that allow us to significantly improve handling of synchronous Observables and simplify Schedulers. Many of the changes have backwards compatible deprecated methods to ease the migration while some are breaking. 
 
 The new signatures related to `Observable` in this release are:
@@ -64,20 +61,20 @@ This release applies many lessons learned over the past year and seeks to stream
 
 As shown in the code above the changes fall into 2 major sections:
 
-#### 1) Lift/Operator/OnSubscribe/Subscriber
+##### 1) Lift/Operator/OnSubscribe/Subscriber
 
 Changes that allow unsubscribing from synchronous Observables without needing to add concurrency.
 
-#### 2) Schedulers
+##### 2) Schedulers
 
 Simplification of the `Scheduler` interface and make clearer the concept of "outer" and "inner" Schedulers for recursion.
 
 
-## Lift/Operator/OnSubscribe/Subscriber
+#### Lift/Operator/OnSubscribe/Subscriber
 
 New types `Subscriber` and `OnSubscribe` along with the new `lift` function have been added. The reasons and benefits are as follows:
 
-### 1) Synchronous Unsubscribe
+##### 1) Synchronous Unsubscribe
 
 RxJava versions up until 0.16.x are unable to unsubscribe from a synchronous Observable such as this:
 
@@ -170,7 +167,7 @@ oi.subscribe(new Subscriber<Integer>() {
 ```
 
 
-### 2) Custom Operator Chaining
+##### 2) Custom Operator Chaining
 
 Because Java doesn't support extension methods, the only approach to applying custom operators without getting them added to `rx.Observable` is using static methods. This has meant code like this:
 
@@ -208,7 +205,7 @@ All operator implementations in the `rx.operators` package will over time be mig
 NOTE: Operators that have not yet been migrated do not work with synchronous unsubscribe. 
 
 
-### 3) Simpler Operator Implementations
+##### 3) Simpler Operator Implementations
 
 The `lift` operator injects the necessary `Observer` and `Subscription` instances (via the new `Subscriber` type) and eliminates (for most use cases) the need for manual subscription management. Because the `Subscription` is available in-scope there are no awkward coding patterns needed for creating a `Subscription`, closing over it and returning and taking into account synchronous vs asynchronous.
 
@@ -273,7 +270,7 @@ public Subscriber<? super T> call(final Subscriber<? super T> child) {
 ```
 
 
-### 4) Recursion/Loop Performance with Unsubscribe
+##### 4) Recursion/Loop Performance with Unsubscribe
 
 The `fromIterable` use case is 20x faster when implemented as a loop instead of recursive scheduler (see https://github.com/Netflix/RxJava/commit/a18b8c1a572b7b9509b7a7fe1a5075ce93657771).
 
@@ -283,7 +280,7 @@ Several places we can remove recursive scheduling used originally for unsubscrib
 
 
 
-## Schedulers
+#### Schedulers
 
 
 Schedulers were greatly simplified to a design based around `Action1<Inner>`. 
@@ -500,9 +497,9 @@ s.unsubscribe();
 
 
 
-## Migration Path
+#### Migration Path
 
-#### 1) Lift/OnSubscribe/Subscriber
+##### 1) Lift/OnSubscribe/Subscriber
 
 The `lift` function will not be used by most and is additive so will not affect backwards compatibility. The `Subscriber` type is also additive and for most use cases does not need to be used directly, the `Observer` interface can continue being used.
 
@@ -615,7 +612,7 @@ Observable.create(new OnSubscribe<Integer>() {
 
 
 
-#### 2) Schedulers
+##### 2) Schedulers
 
 Custom `Scheduler` implementations will need to be re-implemented and any direct use of the `Scheduler` interface will also need to be updated.
 
@@ -630,7 +627,7 @@ It is recommended to use `Subscriptions.create` for most `Subscription` usage.
 
 
 
-# The Future...
+#### The Future...
 
 We have most if not all operators from Rx.Net that we want or intend to port. We think we have got the `create`/`subscribe` signatures as we want and the `Subscription` and `Scheduler` interfaces are now clean. There is at least one more major topic related to back pressure that may result in signature change in a future release. Beyond that no further major signature changing work is expected prior to 1.0.
 
@@ -641,6 +638,7 @@ As we get closer to 1.0 there will be a release that focused on deleting all dep
 We appreciate your usage, feedback and contributions and hope the library is creating value for you!
 
 
+#### Pull Requests
 
 
 * [Pull 767](https://github.com/Netflix/RxJava/pull/767) Zip fix for multiple onCompleted and moved unsubscribe outside the lock.

From f5eaa1c3e00a5e695b45be31611867dfbf0c0f75 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 10 Mar 2014 10:49:10 -0700
Subject: [PATCH 092/422] Update CHANGES.md

---
 CHANGES.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 9451d876a4..8a9c54ef7e 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -369,7 +369,7 @@ Schedulers.newThread().schedule(new Action1<Inner>() {
     }
 
 });
-
+```
 
 The use of `Action1<Inner>` on both the outer and inner levels makes it so recursion that refer to `this` and it works easily. 
 
@@ -473,7 +473,7 @@ Schedulers.newThread().scheduleRecursive(new Action1<Recurse>() {
 
 
 });
-``
+```
 
 The methods on the `Inner` never return a `Subscription` because they are always a single thread/event-loop/actor/etc and controlled by the `Subscription` returned by the initial `Scheduler.schedule` method. This is part of clarifying the contract.
 

From dd2bd02365c00ffc056dfd7978ba31d87328a1b8 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 10 Mar 2014 10:51:04 -0700
Subject: [PATCH 093/422] 0.17.0-SNAPSHOT

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

diff --git a/gradle.properties b/gradle.properties
index 2e8a8bdd53..40da016b78 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-RC8-SNAPSHOT
+version=0.17.0-SNAPSHOT

From 04a6703e9eaa22e7784dcfe8562b09b22c89c6d1 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Mon, 10 Mar 2014 18:01:12 +0000
Subject: [PATCH 094/422] [Gradle Release Plugin] - pre tag commit:  '0.17.0'.

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

diff --git a/gradle.properties b/gradle.properties
index 40da016b78..9f28a3ffc2 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0-SNAPSHOT
+version=0.17.0

From 5425b32aa8519cae5c0adda22cf630296b2f13ad Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Mon, 10 Mar 2014 18:01:16 +0000
Subject: [PATCH 095/422] [Gradle Release Plugin] - new version commit: 
 '0.17.1-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index 9f28a3ffc2..641a9d1d9b 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.0
+version=0.17.1-SNAPSHOT

From a870624a9fc0c8ec0216acd41818ba570149c087 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 10 Mar 2014 12:42:51 -0700
Subject: [PATCH 096/422] Update CHANGES.md

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

diff --git a/CHANGES.md b/CHANGES.md
index 8a9c54ef7e..1c7481a9bb 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -545,7 +545,7 @@ Observable.create(new OnSubscribeFunc<Integer>() {
             @Override
             public void run() {
                 int i = 0;
-                while (s.isUnsubscribed()) {
+                while (!s.isUnsubscribed()) {
                     o.onNext(i++);
                 }
             }
@@ -565,7 +565,7 @@ Observable.create(new OnSubscribe<Integer>() {
     @Override
     public void call(Subscriber<? super Integer> subscriber) {
         int i = 0;
-        while (subscriber.isUnsubscribed()) {
+        while (!subscriber.isUnsubscribed()) {
             subscriber.onNext(i++);
         }
     }
@@ -584,7 +584,7 @@ Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void run() {
                 int i = 0;
-                while (subscriber.isUnsubscribed()) {
+                while (!subscriber.isUnsubscribed()) {
                     subscriber.onNext(i++);
                 }
             }
@@ -603,7 +603,7 @@ Observable.create(new OnSubscribe<Integer>() {
     @Override
     public void call(Subscriber<? super Integer> subscriber) {
         int i = 0;
-        while (subscriber.isUnsubscribed()) {
+        while (!subscriber.isUnsubscribed()) {
             subscriber.onNext(i++);
         }
     }

From c0c2e8b77e4b01954fcfd712fdefd90e25b387e5 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Mon, 10 Mar 2014 16:42:23 -0700
Subject: [PATCH 097/422] Make
 OperatorObserveOnTest.testNonBlockingOuterWhileBlockingOnNext deterministic

reported at https://twitter.com/jaceklaskowski/status/443153927069249536
---
 .../rx/operators/OperatorObserveOnTest.java   | 24 ++++++++++++-------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index 569aee115a..037060298b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -309,16 +309,17 @@ public void call(Integer t1) {
     @Test
     public void testNonBlockingOuterWhileBlockingOnNext() throws InterruptedException {
 
-        final CountDownLatch latch = new CountDownLatch(1);
+        final CountDownLatch completedLatch = new CountDownLatch(1);
+        final CountDownLatch nextLatch = 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<Integer>() {
+        Observable.range(1, 2).subscribeOn(Schedulers.newThread()).observeOn(Schedulers.newThread()).subscribe(new Observer<Integer>() {
 
             @Override
             public void onCompleted() {
                 System.out.println("onCompleted");
                 completeTime.set(System.nanoTime());
-                latch.countDown();
+                completedLatch.countDown();
             }
 
             @Override
@@ -328,20 +329,27 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(Integer t) {
-
+                // don't let this thing finish yet
+                try {
+                    if (!nextLatch.await(1000, TimeUnit.MILLISECONDS)) {
+                        throw new RuntimeException("it shouldn't have timed out");
+                    }
+                } catch (InterruptedException e) {
+                    throw new RuntimeException("it shouldn't have failed");
+                }
             }
 
         });
 
         long afterSubscribeTime = System.nanoTime();
-        System.out.println("After subscribe: " + latch.getCount());
-        assertEquals(1, latch.getCount());
-        latch.await();
+        System.out.println("After subscribe: " + completedLatch.getCount());
+        assertEquals(1, completedLatch.getCount());
+        nextLatch.countDown();
+        completedLatch.await(1000, TimeUnit.MILLISECONDS);
         assertTrue(completeTime.get() > afterSubscribeTime);
         System.out.println("onComplete nanos after subscribe: " + (completeTime.get() - afterSubscribeTime));
     }
 
-
     private static int randomIntFrom0to100() {
         // XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml
         long x = System.nanoTime();

From 731e0a024ec4747aea706f03b61bcd4bc71afe16 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 11 Mar 2014 14:36:51 +0100
Subject: [PATCH 098/422] Fixed ReplaySubject leak

---
 .../src/main/java/rx/subjects/AsyncSubject.java  |  2 +-
 .../main/java/rx/subjects/BehaviorSubject.java   |  2 +-
 .../main/java/rx/subjects/PublishSubject.java    |  2 +-
 .../src/main/java/rx/subjects/ReplaySubject.java | 16 ++++++++++++++--
 .../rx/subjects/SubjectSubscriptionManager.java  | 10 ++++++++--
 .../test/java/rx/subjects/ReplaySubjectTest.java | 11 +++++++++++
 6 files changed, 36 insertions(+), 7 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index 268628b013..7b50cd9468 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -82,7 +82,7 @@ public void call(SubjectObserver<? super T> o) {
                         // to send onCompleted if the last value is an onNext
                         emitValueToObserver(lastNotification.get(), o);
                     }
-                });
+                }, null);
 
         return new AsyncSubject<T>(onSubscribe, subscriptionManager, lastNotification);
     }
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 036da20a48..f59dc03133 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -128,7 +128,7 @@ public void call(SubjectObserver<? super T> o) {
                          */
                         lastNotification.get().accept(o);
                     }
-                });
+                }, null);
 
         return new BehaviorSubject<T>(onSubscribe, subscriptionManager, lastNotification);
     }
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 8cc484a36e..4d94a087fd 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -79,7 +79,7 @@ public void call(SubjectObserver<? super T> o) {
                          */
                         lastNotification.get().accept(o);
                     }
-                });
+                }, null);
 
         return new PublishSubject<T>(onSubscribe, subscriptionManager, lastNotification);
     }
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 264747d7f4..7d659822c2 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -84,8 +84,15 @@ public void call(SubjectObserver<? super T> o) {
 
                     @Override
                     public void call(SubjectObserver<? super T> o) {
+                        Integer idx = state.replayState.remove(o);
                         // we will finish replaying if there is anything left
-                        replayObserverFromIndex(state.history, state.replayState.get(o), o);
+                        replayObserverFromIndex(state.history, idx, o);
+                    }
+                }, 
+                new Action1<SubjectObserver<? super T>>() {
+                    @Override
+                    public void call(SubjectObserver<? super T> o) {
+                        state.replayState.remove(o);
                     }
                 });
 
@@ -229,5 +236,10 @@ public void complete(Notification<T> n) {
             terminalValue.set(n);
         }
     }
-
+    /**
+     * @return Returns the number of subscribers.
+     */
+    /* Support test.*/ int subscriberCount() {
+        return state.replayState.size();
+    }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 0524100659..e6626d434d 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -39,13 +39,16 @@
      *            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.
+     * @param onUnsubscribe called after the child subscription is removed from the state
      * @return
      */
-    public OnSubscribe<T> getOnSubscribeFunc(final Action1<SubjectObserver<? super T>> onSubscribe, final Action1<SubjectObserver<? super T>> onTerminated) {
+    public OnSubscribe<T> getOnSubscribeFunc(final Action1<SubjectObserver<? super T>> onSubscribe, 
+            final Action1<SubjectObserver<? super T>> onTerminated,
+            final Action1<SubjectObserver<? super T>> onUnsubscribe) {
         return new OnSubscribe<T>() {
             @Override
             public void call(Subscriber<? super T> actualOperator) {
-                SubjectObserver<T> observer = new SubjectObserver<T>(actualOperator);
+                final SubjectObserver<T> observer = new SubjectObserver<T>(actualOperator);
                 // invoke onSubscribe logic 
                 if (onSubscribe != null) {
                     onSubscribe.call(observer);
@@ -84,6 +87,9 @@ public void call() {
                                     // on unsubscribe remove it from the map of outbound observers to notify
                                     newState = current.removeObserver(subscription);
                                 } while (!state.compareAndSet(current, newState));
+                                if (onUnsubscribe != null) {
+                                    onUnsubscribe.call(observer);
+                                }
                             }
                         }));
 
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index 3a360300f5..5a963eba02 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -344,5 +344,16 @@ public void onNext(String v) {
         assertEquals("three", lastValueForObserver2.get());
 
     }
+    @Test
+    public void testSubscriptionLeak() {
+        ReplaySubject<Object> replaySubject = ReplaySubject.create();
+        
+        Subscription s = replaySubject.subscribe();
+
+        assertEquals(1, replaySubject.subscriberCount());
 
+        s.unsubscribe();
+        
+        assertEquals(0, replaySubject.subscriberCount());
+    }
 }

From 271eda44a52f5aa8dc1c9dac3679ec3fd0596eab Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 11 Mar 2014 14:41:43 +0100
Subject: [PATCH 099/422] Fixed byLine test to use line.separator system
 property instead of \n.

---
 .../src/test/java/rx/observables/StringObservableTest.java    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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 01dcc8f435..566ee92666 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
@@ -247,7 +247,9 @@ public void testFromReader() {
 
     @Test
     public void testByLine() {
-        List<Line> lines = StringObservable.byLine(Observable.from(Arrays.asList("qwer", "\nasdf\n", "zx", "cv"))).toList().toBlockingObservable().single();
+        String newLine = System.getProperty("line.separator");
+        
+        List<Line> lines = StringObservable.byLine(Observable.from(Arrays.asList("qwer", newLine + "asdf" + newLine, "zx", "cv"))).toList().toBlockingObservable().single();
 
         assertEquals(Arrays.asList(new Line(0, "qwer"), new Line(1, "asdf"), new Line(2, "zxcv")), lines);
     }

From 9f990cacf3db5fec605adaaa5e14c7d602786efd Mon Sep 17 00:00:00 2001
From: Rick Warren <rwarren@cs.stanford.edu>
Date: Tue, 11 Mar 2014 23:42:20 -0700
Subject: [PATCH 100/422] OperationToFuture must throw CancellationException on
 get() if cancelled.

The documentation for Future.get() requires the method to throw CancellationException if the Future was cancelled before the task completed. The Futures returned by OperationToFuture.toFuture() did not respect this contract. Now they do.
---
 .../java/rx/operators/OperationToFuture.java  |  4 ++
 .../rx/operators/OperationToFutureTest.java   | 37 ++++++++++++++++++-
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
index 005cd3a1e4..712930c4c5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import java.util.concurrent.CancellationException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
@@ -120,6 +121,9 @@ public T get(long timeout, TimeUnit unit) throws InterruptedException, Execution
             private T getValue() throws ExecutionException {
                 if (error.get() != null) {
                     throw new ExecutionException("Observable onError", error.get());
+                } else if (cancelled) {
+                    // Contract of Future.get() requires us to throw this:
+                    throw new CancellationException("Subscription unsubscribed");
                 } else {
                     return value.get();
                 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java b/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
index 8c2791c615..efe840dacc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
@@ -15,18 +15,23 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static rx.operators.OperationToFuture.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static rx.operators.OperationToFuture.toFuture;
 
 import java.util.List;
+import java.util.concurrent.CancellationException;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
 
@@ -77,6 +82,34 @@ public Subscription onSubscribe(Observer<? super String> observer) {
         }
     }
 
+    @Test(expected=CancellationException.class)
+    public void testGetAfterCancel() throws Exception {
+        Observable<String> obs = Observable.create(new OperationNeverComplete<String>());
+        Future<String> f = toFuture(obs);
+        boolean cancelled = f.cancel(true);
+        assertTrue(cancelled);  // because OperationNeverComplete never does
+        f.get();                // Future.get() docs require this to throw
+    }
+
+    @Test(expected=CancellationException.class)
+    public void testGetWithTimeoutAfterCancel() throws Exception {
+        Observable<String> obs = Observable.create(new OperationNeverComplete<String>());
+        Future<String> f = toFuture(obs);
+        boolean cancelled = f.cancel(true);
+        assertTrue(cancelled);  // because OperationNeverComplete never does
+        f.get(Long.MAX_VALUE, TimeUnit.NANOSECONDS);    // Future.get() docs require this to throw
+    }
+
+    /**
+     * Emits no observations. Used to simulate a long-running asynchronous operation.
+     */
+    private static class OperationNeverComplete<T> implements Observable.OnSubscribe<T> {
+        @Override
+        public void call(Subscriber<? super T> unused) {
+            // do nothing
+        }
+    }
+
     private static class TestException extends RuntimeException {
         private static final long serialVersionUID = 1L;
     }

From 16e17c428124c0e2ae675a0c76a1f205e07e061c Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 10:27:57 +0100
Subject: [PATCH 101/422] Bump Android plugin version to 0.9

---
 rxjava-contrib/rxjava-android-samples/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-android-samples/build.gradle b/rxjava-contrib/rxjava-android-samples/build.gradle
index db342a5e2a..0ba4fcdb79 100644
--- a/rxjava-contrib/rxjava-android-samples/build.gradle
+++ b/rxjava-contrib/rxjava-android-samples/build.gradle
@@ -5,7 +5,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:0.8.+'
+        classpath 'com.android.tools.build:gradle:0.9.+'
     }
 }
 

From 1275d0858aacb6ea810f30cff7ed45bc99c8e4a7 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 11:10:09 +0100
Subject: [PATCH 102/422] Switch to customizable Gradle wrapper

---
 .../gradle/wrapper/gradle-wrapper.properties                  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
index 5de946b072..169f28a055 100644
--- a/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
+++ b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Wed Apr 10 15:27:10 PDT 2013
+#Wed Mar 12 11:02:06 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-all.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-bin.zip

From a40f8c51cf287770230bcbdb930ca0a6a80f9ef4 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 11:11:31 +0100
Subject: [PATCH 103/422] Trigger samples build manually via Gradle build
 property

---
 .../rxjava-android-samples-build-wrapper/build.gradle     | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
index de7ef0162c..03513b751f 100644
--- a/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
+++ b/rxjava-contrib/rxjava-android-samples-build-wrapper/build.gradle
@@ -1,8 +1,6 @@
-def androidHome = System.getenv("ANDROID_HOME")
 tasks.build.doLast {
-  if (androidHome.isEmpty()) {
-    println("No Android SDK detected; skipping Android samples build")
-  } else {
+  def androidHome = System.getenv("ANDROID_HOME")
+  if (project.hasProperty('buildAndroidSamples') && !androidHome.isEmpty()) {
     println("Android SDK detected at $androidHome, running samples build")
     project.exec {
       workingDir '../rxjava-android-samples'
@@ -10,4 +8,4 @@ tasks.build.doLast {
       commandLine "./gradlew", "clean", "packageDebug"
     }
   }
-}
+}
\ No newline at end of file

From ffffa57f988f447745fb26992a5f7e6c62075be6 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 12:12:27 +0100
Subject: [PATCH 104/422] Revert to using the all Gradle wrapper dist type

---
 .../gradle/wrapper/gradle-wrapper.properties                  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
index 169f28a055..a4b6756f97 100644
--- a/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
+++ b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Wed Mar 12 11:02:06 CET 2014
+#Wed Mar 12 12:09:46 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

From ea73bd1f51aaff22215b839441aafbe3757a76d8 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 12 Mar 2014 15:01:35 +0100
Subject: [PATCH 105/422] OperatorSkipWhile

---
 rxjava-core/src/main/java/rx/Observable.java  |  6 +-
 .../java/rx/operators/OperationSkipWhile.java | 98 -------------------
 .../java/rx/operators/OperatorSkipWhile.java  | 78 +++++++++++++++
 .../rx/operators/OperationSkipWhileTest.java  | 33 +++++--
 4 files changed, 106 insertions(+), 109 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 5bfb5ad278..0f8fa4e5c8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -91,7 +91,7 @@
 import rx.operators.OperationSkip;
 import rx.operators.OperationSkipLast;
 import rx.operators.OperationSkipUntil;
-import rx.operators.OperationSkipWhile;
+import rx.operators.OperatorSkipWhile;
 import rx.operators.OperationSum;
 import rx.operators.OperationSwitch;
 import rx.operators.OperationSynchronize;
@@ -6427,7 +6427,7 @@ public final <U> Observable<T> skipUntil(Observable<U> other) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229685.aspx">MSDN: Observable.SkipWhile</a>
      */
     public final Observable<T> skipWhile(Func1<? super T, Boolean> predicate) {
-        return create(OperationSkipWhile.skipWhile(this, predicate));
+        return lift(new OperatorSkipWhile<T>(OperatorSkipWhile.toPredicate2(predicate)));
     }
 
     /**
@@ -6445,7 +6445,7 @@ public final Observable<T> skipWhile(Func1<? super T, Boolean> predicate) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211631.aspx">MSDN: Observable.SkipWhile</a>
      */
     public final Observable<T> skipWhileWithIndex(Func2<? super T, Integer, Boolean> predicate) {
-        return create(OperationSkipWhile.skipWhileWithIndex(this, predicate));
+        return lift(new OperatorSkipWhile<T>(predicate));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java b/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
deleted file mode 100644
index aaa2914986..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipWhile.java
+++ /dev/null
@@ -1,98 +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.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-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
- * as soon as the condition becomes false.
- */
-public final class OperationSkipWhile {
-    public static <T> OnSubscribeFunc<T> skipWhileWithIndex(Observable<? extends T> source, Func2<? super T, Integer, Boolean> predicate) {
-        return new SkipWhile<T>(source, predicate);
-    }
-
-    public static <T> OnSubscribeFunc<T> skipWhile(Observable<? extends T> source, final Func1<? super T, Boolean> predicate) {
-        return new SkipWhile<T>(source, new Func2<T, Integer, Boolean>() {
-            @Override
-            public Boolean call(T value, Integer index) {
-                return predicate.call(value);
-            }
-        });
-    }
-
-    private static class SkipWhile<T> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> source;
-        private final Func2<? super T, Integer, Boolean> predicate;
-        private final AtomicBoolean skipping = new AtomicBoolean(true);
-        private final AtomicInteger index = new AtomicInteger(0);
-
-        SkipWhile(Observable<? extends T> source, Func2<? super T, Integer, Boolean> pred) {
-            this.source = source;
-            this.predicate = pred;
-        }
-
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            return source.subscribe(new SkipWhileObserver(observer));
-        }
-
-        private class SkipWhileObserver implements Observer<T> {
-            private final Observer<? super T> observer;
-
-            public SkipWhileObserver(Observer<? super T> observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onCompleted() {
-                observer.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onNext(T next) {
-                if (!skipping.get()) {
-                    observer.onNext(next);
-                } else {
-                    try {
-                        if (!predicate.call(next, index.getAndIncrement())) {
-                            skipping.set(false);
-                            observer.onNext(next);
-                        } else {
-                        }
-                    } catch (Throwable t) {
-                        observer.onError(t);
-                    }
-                }
-            }
-
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java
new file mode 100644
index 0000000000..70e5fc220a
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java
@@ -0,0 +1,78 @@
+/**
+ * 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.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Subscriber;
+import rx.Subscription;
+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
+ * as soon as the condition becomes false.
+ */
+public final class OperatorSkipWhile<T> implements Operator<T, T> {
+    private final Func2<? super T, Integer, Boolean> predicate;
+
+    public OperatorSkipWhile(Func2<? super T, Integer, Boolean> predicate) {
+        this.predicate = predicate;
+    }
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new Subscriber<T>(child) {
+            boolean skipping = true;
+            int index;
+            @Override
+            public void onNext(T t) {
+                if (!skipping) {
+                    child.onNext(t);
+                } else {
+                    if (!predicate.call(t, index++)) {
+                        skipping = false;
+                        child.onNext(t);
+                    }
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+        };
+    }
+    /** Convert to Func2 type predicate. */
+    public static <T> Func2<T, Integer, Boolean> toPredicate2(final Func1<? super T, Boolean> predicate) {
+        return new Func2<T, Integer, Boolean>() {
+
+            @Override
+            public Boolean call(T t1, Integer t2) {
+                return predicate.call(t1);
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
index 708ac42d50..b769f4f453 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
@@ -15,9 +15,7 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperationSkipWhile.*;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -51,7 +49,7 @@ public Boolean call(Integer value, Integer index) {
     @Test
     public void testSkipWithIndex() {
         Observable<Integer> src = Observable.from(1, 2, 3, 4, 5);
-        Observable.create(skipWhileWithIndex(src, INDEX_LESS_THAN_THREE)).subscribe(w);
+        src.skipWhileWithIndex(INDEX_LESS_THAN_THREE).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext(4);
@@ -63,7 +61,7 @@ public void testSkipWithIndex() {
     @Test
     public void testSkipEmpty() {
         Observable<Integer> src = Observable.empty();
-        Observable.create(skipWhile(src, LESS_THAN_FIVE)).subscribe(w);
+        src.skipWhile(LESS_THAN_FIVE).subscribe(w);
         verify(w, never()).onNext(anyInt());
         verify(w, never()).onError(any(Throwable.class));
         verify(w, times(1)).onCompleted();
@@ -72,7 +70,7 @@ public void testSkipEmpty() {
     @Test
     public void testSkipEverything() {
         Observable<Integer> src = Observable.from(1, 2, 3, 4, 3, 2, 1);
-        Observable.create(skipWhile(src, LESS_THAN_FIVE)).subscribe(w);
+        src.skipWhile(LESS_THAN_FIVE).subscribe(w);
         verify(w, never()).onNext(anyInt());
         verify(w, never()).onError(any(Throwable.class));
         verify(w, times(1)).onCompleted();
@@ -81,7 +79,7 @@ public void testSkipEverything() {
     @Test
     public void testSkipNothing() {
         Observable<Integer> src = Observable.from(5, 3, 1);
-        Observable.create(skipWhile(src, LESS_THAN_FIVE)).subscribe(w);
+        src.skipWhile(LESS_THAN_FIVE).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext(5);
@@ -94,7 +92,7 @@ public void testSkipNothing() {
     @Test
     public void testSkipSome() {
         Observable<Integer> src = Observable.from(1, 2, 3, 4, 5, 3, 1, 5);
-        Observable.create(skipWhile(src, LESS_THAN_FIVE)).subscribe(w);
+        src.skipWhile(LESS_THAN_FIVE).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext(5);
@@ -108,11 +106,30 @@ public void testSkipSome() {
     @Test
     public void testSkipError() {
         Observable<Integer> src = Observable.from(1, 2, 42, 5, 3, 1);
-        Observable.create(skipWhile(src, LESS_THAN_FIVE)).subscribe(w);
+        src.skipWhile(LESS_THAN_FIVE).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, never()).onNext(anyInt());
         inOrder.verify(w, never()).onCompleted();
         inOrder.verify(w, times(1)).onError(any(RuntimeException.class));
     }
+    
+    @Test
+    public void testSkipManySubscribers() {
+        Observable<Integer> src = Observable.range(1, 10).skipWhile(LESS_THAN_FIVE);
+        int n = 5;
+        for (int i = 0; i < n; i++) {
+            @SuppressWarnings("unchecked")
+            Observer<Object> o = mock(Observer.class);
+            InOrder inOrder = inOrder(o);
+            
+            src.subscribe(o);
+            
+            for (int j = 5; j < 10; j++) {
+                inOrder.verify(o).onNext(j);
+            } 
+            inOrder.verify(o).onCompleted();
+            verify(o, never()).onError(any(Throwable.class));
+        }
+    }
 }

From 10fa25558ec092fee9e824849697abddd3f1c51c Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 15:54:30 +0100
Subject: [PATCH 106/422] Add full example for Activity + retained fragment +
 cache

---
 .../samples/src/main/AndroidManifest.xml      |   3 +-
 .../android/samples/RetainedFragment.java     |  65 -----------
 .../samples/RetainedFragmentActivity.java     | 105 ++++++++++++++++++
 .../samples/SampleFragmentActivity.java       |  17 ---
 .../android/samples/SampleObservables.java    |  19 +++-
 .../android/samples/SamplesApplication.java   |  13 +++
 ...ity.xml => retained_fragment_activity.xml} |   4 +-
 .../samples/src/main/res/menu/menu.xml        |   7 ++
 8 files changed, 145 insertions(+), 88 deletions(-)
 delete mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
 delete mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SamplesApplication.java
 rename rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/{sample_activity.xml => retained_fragment_activity.xml} (80%)
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/menu/menu.xml

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
index 6296812264..adcaf359f7 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
@@ -3,12 +3,13 @@
     package="com.netflix.rxjava.android.samples" >
 
     <application
+        android:name=".SamplesApplication"
         android:allowBackup="true"
         android:icon="@drawable/ic_launcher"
         android:theme="@style/AppTheme"
         android:label="@string/app_name">
         <activity
-            android:name=".SampleFragmentActivity">
+            android:name=".RetainedFragmentActivity">
 
             <intent-filter>
                 <category android:name="android.intent.category.LAUNCHER"/>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
deleted file mode 100644
index 0db00e3ac8..0000000000
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragment.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package com.netflix.rxjava.android.samples;
-
-import android.app.Fragment;
-import android.os.Bundle;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.TextView;
-
-import rx.Observable;
-import rx.Subscription;
-import rx.android.observables.AndroidObservable;
-import rx.functions.Action1;
-import rx.subscriptions.Subscriptions;
-
-/**
- * This fragment shows one of the most common use cases: listening for data emitted from a background
- * task on the UI.
- * <p/>
- * We achieve this by retaining the fragment, creating the observable sequence in onCreate (thus
- * also retaining the sequence), and connecting to it in onViewCreated. Note how we use the cache
- * operator to replay items already emitted. This ensure that if we should go through a configuration
- * change, and the activity gets destroyed, we do not lose any data, but simply cache and re-emit
- * it when the views get recreated.
- */
-public class RetainedFragment extends Fragment {
-
-    private Observable<String> strings;
-    private Subscription subscription = Subscriptions.empty();
-
-    public RetainedFragment() {
-        setRetainInstance(true);
-    }
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        strings = SampleObservables.numberStrings().cache();
-    }
-
-    @Override
-    public void onDestroyView() {
-        subscription.unsubscribe();
-        super.onDestroyView();
-    }
-
-    @Override
-    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-        return inflater.inflate(R.layout.retained_fragment, container, false);
-    }
-
-    @Override
-    public void onViewCreated(final View view, Bundle savedInstanceState) {
-        super.onViewCreated(view, savedInstanceState);
-
-        subscription = AndroidObservable.fromFragment(this, strings).subscribe(new Action1<String>() {
-            @Override
-            public void call(String s) {
-                final TextView textView = (TextView) view.findViewById(android.R.id.text1);
-                textView.setText(s);
-            }
-        });
-    }
-}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
new file mode 100644
index 0000000000..82c5225101
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
@@ -0,0 +1,105 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.widget.TextView;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import rx.Observable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Problem:
+ * You have a data source (where that data is potentially expensive to obtain), and you want to
+ * emit this data into a fragment. However, you want to gracefully deal with rotation changes and
+ * not lose any data already emitted.
+ * <p/>
+ * Solution:
+ * Combine {@link android.app.Fragment#setRetainInstance(boolean)} with
+ * {@link rx.android.schedulers.AndroidSchedulers#mainThread()} and {@link rx.Observable#cache()}
+ */
+public class RetainedFragmentActivity extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+        setTitle("Fake API call");
+        setContentView(R.layout.retained_fragment_activity);
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    public static class RetainedFragment extends Fragment {
+
+        // in a production app, you don't want to have JSON parser code in your fragment,
+        // but we'll simplify a little here
+        private static final Func1<String, String> PARSE_JSON = new Func1<String, String>() {
+            @Override
+            public String call(String json) {
+                try {
+                    JSONObject jsonObject = new JSONObject(json);
+                    return String.valueOf(jsonObject.getInt("result"));
+                } catch (JSONException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        };
+
+        private Observable<String> strings;
+        private Subscription subscription = Subscriptions.empty();
+
+        public RetainedFragment() {
+            setRetainInstance(true);
+        }
+
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            // simulate fetching a JSON document with a latency of 2 seconds
+            strings = SampleObservables.fakeApiCall(2000).map(PARSE_JSON)
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .cache();
+        }
+
+        @Override
+        public void onDestroyView() {
+            subscription.unsubscribe();
+            super.onDestroyView();
+        }
+
+        @Override
+        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+            getActivity().setProgressBarIndeterminateVisibility(true);
+            return inflater.inflate(R.layout.retained_fragment, container, false);
+        }
+
+        @Override
+        public void onViewCreated(final View view, Bundle savedInstanceState) {
+            super.onViewCreated(view, savedInstanceState);
+
+            final TextView textView = (TextView) view.findViewById(android.R.id.text1);
+
+            // (re-)subscribe to the sequence, which either emits the cached result or simply re-
+            // attaches the subscriber to wait for it to arrive
+            subscription = strings.subscribe(new Action1<String>() {
+                @Override
+                public void call(String result) {
+                    textView.setText(result);
+                    getActivity().setProgressBarIndeterminateVisibility(false);
+                }
+            });
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java
deleted file mode 100644
index 5da3b3b7e6..0000000000
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleFragmentActivity.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.netflix.rxjava.android.samples;
-
-import android.app.Activity;
-import android.os.Bundle;
-import android.os.StrictMode;
-
-public class SampleFragmentActivity extends Activity {
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        StrictMode.enableDefaults();
-
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.sample_activity);
-    }
-
-}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java
index e2b67b104a..7a17bedad5 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SampleObservables.java
@@ -3,6 +3,7 @@
 import android.os.SystemClock;
 
 import rx.Observable;
+import rx.Subscriber;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.schedulers.Schedulers;
@@ -12,8 +13,8 @@ public class SampleObservables {
     /**
      * Emits numbers as strings, where these numbers a generated on a background thread.
      */
-    public static Observable<String> numberStrings() {
-        return Observable.range(1, 10).map(new Func1<Integer, String>() {
+    public static Observable<String> numberStrings(int from, int to, final long delay) {
+        return Observable.range(from, to).map(new Func1<Integer, String>() {
             @Override
             public String call(Integer integer) {
                 return integer.toString();
@@ -21,9 +22,21 @@ public String call(Integer integer) {
         }).doOnNext(new Action1<String>() {
             @Override
             public void call(String s) {
-                SystemClock.sleep(1000);
+                SystemClock.sleep(delay);
             }
         }).subscribeOn(Schedulers.newThread());
     }
 
+    public static Observable<String> fakeApiCall(final long delay) {
+        return Observable.create(new Observable.OnSubscribe<String>() {
+            @Override
+            public void call(Subscriber<? super String> subscriber) {
+                // simulate I/O latency
+                SystemClock.sleep(delay);
+                final String fakeJson = "{\"result\": 42}";
+                subscriber.onNext(fakeJson);
+                subscriber.onCompleted();
+            }
+        }).subscribeOn(Schedulers.io());
+    }
 }
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SamplesApplication.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SamplesApplication.java
new file mode 100644
index 0000000000..e91e7d543e
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/SamplesApplication.java
@@ -0,0 +1,13 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Application;
+import android.os.StrictMode;
+
+public class SamplesApplication extends Application {
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        StrictMode.enableDefaults();
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/sample_activity.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity.xml
similarity index 80%
rename from rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/sample_activity.xml
rename to rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity.xml
index 5900d1d74e..e5eb51fb86 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/sample_activity.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity.xml
@@ -2,13 +2,13 @@
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
-    tools:context="com.netflix.rxjava.android.samples.SampleFragmentActivity">
+    tools:context="com.netflix.rxjava.android.samples.RetainedFragmentActivity">
 
     <fragment
         android:tag="retained_fragment"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
-        android:name="com.netflix.rxjava.android.samples.RetainedFragment"
+        android:name="com.netflix.rxjava.android.samples.RetainedFragmentActivity$RetainedFragment"
         tools:layout="@layout/retained_fragment" />
 
 </RelativeLayout>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/menu/menu.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/menu/menu.xml
new file mode 100644
index 0000000000..3c1d36c3d1
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/menu/menu.xml
@@ -0,0 +1,7 @@
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    
+    <item android:id="@+id/action_settings"
+        android:title="@string/action_settings"
+        android:orderInCategory="100"
+        android:showAsAction="never" />
+</menu>

From adb54b46922e901f052950caa28813092e8be687 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 16:05:31 +0100
Subject: [PATCH 107/422] Add sample for fragments and connectable observables

---
 .../samples/src/main/AndroidManifest.xml      |  9 ++
 .../samples/ListeningFragmentActivity.java    | 96 +++++++++++++++++++
 .../layout/listening_fragment_activity.xml    | 14 +++
 3 files changed, 119 insertions(+)
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listening_fragment_activity.xml

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
index adcaf359f7..18bbab228b 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
@@ -11,6 +11,15 @@
         <activity
             android:name=".RetainedFragmentActivity">
 
+            <intent-filter>
+                <category android:name="android.intent.category.LAUNCHER"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".ListeningFragmentActivity">
+
             <intent-filter>
                 <category android:name="android.intent.category.LAUNCHER"/>
                 <category android:name="android.intent.category.DEFAULT"/>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java
new file mode 100644
index 0000000000..b402135bc1
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java
@@ -0,0 +1,96 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import rx.Subscriber;
+import rx.Subscription;
+import rx.observables.ConnectableObservable;
+import rx.subscriptions.Subscriptions;
+
+import static rx.android.schedulers.AndroidSchedulers.mainThread;
+
+/**
+ * Problem:
+ * You have a background sequence which keeps emitting items (either a limited or unlimited number)
+ * and your UI component should be able to "listen in" to the sequence, i.e. it's okay to miss
+ * in-flight items when going e.g. through a screen rotation or being otherwise detached from the
+ * screen for a limited period of time. (Another example is a "page out" in a fragment ViewPager.)
+ * <p/>
+ * This is useful if you need behavior that mimics event buses. Think of a publishing
+ * Observable as a channel or queue on an event bus.
+ * <p/>
+ * Solution:
+ * Combine {@link android.app.Fragment#setRetainInstance(boolean)} with
+ * {@link rx.android.schedulers.AndroidSchedulers#mainThread()} and {@link rx.Observable#publish()}
+ */
+public class ListeningFragmentActivity extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.listening_fragment_activity);
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    public static class ListeningFragment extends Fragment {
+
+        private ConnectableObservable<String> strings;
+        private Subscription subscription = Subscriptions.empty();
+
+        public ListeningFragment() {
+            setRetainInstance(true);
+        }
+
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            strings = SampleObservables.numberStrings(1, 50, 250).observeOn(mainThread()).publish();
+            strings.connect(); // trigger the sequence
+        }
+
+        @Override
+        public void onDestroyView() {
+            subscription.unsubscribe(); // stop listening
+            super.onDestroyView();
+        }
+
+        @Override
+        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+            return inflater.inflate(R.layout.retained_fragment, container, false);
+        }
+
+        @Override
+        public void onViewCreated(final View view, Bundle savedInstanceState) {
+            super.onViewCreated(view, savedInstanceState);
+
+            final TextView textView = (TextView) view.findViewById(android.R.id.text1);
+
+            // re-connect to sequence
+            subscription = strings.subscribe(new Subscriber<String>() {
+
+                @Override
+                public void onCompleted() {
+                    Toast.makeText(getActivity(), "Done!", Toast.LENGTH_SHORT).show();
+                }
+
+                @Override
+                public void onError(Throwable throwable) {
+
+                }
+
+                @Override
+                public void onNext(String s) {
+                    textView.setText(s);
+                }
+            });
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listening_fragment_activity.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listening_fragment_activity.xml
new file mode 100644
index 0000000000..ecfc325d20
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listening_fragment_activity.xml
@@ -0,0 +1,14 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.netflix.rxjava.android.samples.ListeningFragmentActivity">
+
+    <fragment
+        android:tag="retained_fragment"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:name="com.netflix.rxjava.android.samples.ListeningFragmentActivity$ListeningFragment"
+        tools:layout="@layout/retained_fragment" />
+
+</RelativeLayout>

From a91c1d46f9fd7aa21a9544057fd79072f54d6210 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 16:13:03 +0100
Subject: [PATCH 108/422] Add sample for binding to list adapters in
 ListFragment

---
 .../samples/src/main/AndroidManifest.xml      |  9 +++
 .../android/samples/ListFragmentActivity.java | 75 +++++++++++++++++++
 .../res/layout/list_fragment_activity.xml     | 13 ++++
 3 files changed, 97 insertions(+)
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListFragmentActivity.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/list_fragment_activity.xml

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
index 18bbab228b..f307d55bb0 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
@@ -20,6 +20,15 @@
         <activity
             android:name=".ListeningFragmentActivity">
 
+            <intent-filter>
+                <category android:name="android.intent.category.LAUNCHER"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".ListFragmentActivity">
+
             <intent-filter>
                 <category android:name="android.intent.category.LAUNCHER"/>
                 <category android:name="android.intent.category.DEFAULT"/>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListFragmentActivity.java
new file mode 100644
index 0000000000..446bffa55d
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListFragmentActivity.java
@@ -0,0 +1,75 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Activity;
+import android.app.ListFragment;
+import android.os.Bundle;
+import android.widget.ArrayAdapter;
+
+import rx.Observable;
+import rx.Subscriber;
+
+import static rx.android.schedulers.AndroidSchedulers.mainThread;
+
+/**
+ * Problem:
+ * You have an asynchronous sequence that emits items to be displayed in a list. You want the data
+ * to survive rotation changes.
+ * <p/>
+ * Solution:
+ * Combine {@link android.app.Fragment#setRetainInstance(boolean)} in a ListFragment with
+ * {@link rx.android.schedulers.AndroidSchedulers#mainThread()} and an {@link rx.Observable.Operator}
+ * that binds to the list adapter.
+ */
+public class ListFragmentActivity extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setTitle("Lists");
+        setContentView(R.layout.list_fragment_activity);
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    public static class RetainedListFragment extends ListFragment {
+
+        private ArrayAdapter<String> adapter;
+
+        public RetainedListFragment() {
+            setRetainInstance(true);
+        }
+
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            adapter = new ArrayAdapter<String>(getActivity(), android.R.layout.simple_list_item_1);
+            setListAdapter(adapter);
+            SampleObservables.numberStrings(1, 20, 250)
+                    .observeOn(mainThread())
+                    .lift(new BindAdapter())
+                    .subscribe();
+        }
+
+        private final class BindAdapter implements Observable.Operator<String, String> {
+            @Override
+            public Subscriber<? super String> call(Subscriber<? super String> subscriber) {
+                return new Subscriber<String>() {
+                    @Override
+                    public void onCompleted() {
+                        adapter.notifyDataSetChanged();
+                    }
+
+                    @Override
+                    public void onError(Throwable throwable) {
+
+                    }
+
+                    @Override
+                    public void onNext(String strings) {
+                        adapter.add(strings);
+                    }
+                };
+            }
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/list_fragment_activity.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/list_fragment_activity.xml
new file mode 100644
index 0000000000..f741ee62dc
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/list_fragment_activity.xml
@@ -0,0 +1,13 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.netflix.rxjava.android.samples.ListeningFragmentActivity">
+
+    <fragment
+        android:tag="retained_list_fragment"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:name="com.netflix.rxjava.android.samples.ListFragmentActivity$RetainedListFragment" />
+
+</RelativeLayout>

From d7037b5c5270c0f6af0381af03d60fc4f916141d Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 18:20:46 +0100
Subject: [PATCH 109/422] OperatorWeakBinding supports predicates now

---
 .../observables/AndroidObservable.java        | 56 ++++++++++--
 .../rx/operators/OperatorWeakBinding.java     | 54 +++++++++---
 .../rx/operators/OperatorWeakBindingTest.java | 86 +++++++++++++++++++
 3 files changed, 178 insertions(+), 18 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.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 8da366265d..28d8d704aa 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
@@ -18,6 +18,7 @@
 import static rx.android.schedulers.AndroidSchedulers.mainThread;
 
 import rx.Observable;
+import rx.functions.Func1;
 import rx.operators.OperatorObserveFromAndroidComponent;
 import rx.operators.OperatorWeakBinding;
 
@@ -40,7 +41,30 @@ public final class AndroidObservable {
         USES_SUPPORT_FRAGMENTS = supportFragmentsAvailable;
     }
 
-    private AndroidObservable() {}
+    private static final Func1<Activity, Boolean> ACTIVITY_VALIDATOR = new Func1<Activity, Boolean>() {
+        @Override
+        public Boolean call(Activity activity) {
+            return !activity.isFinishing();
+        }
+    };
+
+    private static final Func1<Fragment, Boolean> FRAGMENT_VALIDATOR = new Func1<Fragment, Boolean>() {
+        @Override
+        public Boolean call(Fragment fragment) {
+            return fragment.isAdded();
+        }
+    };
+
+    private static final Func1<android.support.v4.app.Fragment, Boolean> FRAGMENTV4_VALIDATOR =
+            new Func1<android.support.v4.app.Fragment, Boolean>() {
+                @Override
+                public Boolean call(android.support.v4.app.Fragment fragment) {
+                    return fragment.isAdded();
+                }
+            };
+
+    private AndroidObservable() {
+    }
 
     /**
      * Transforms a source observable to be attached to the given Activity, in such a way that notifications will always
@@ -61,6 +85,7 @@ private AndroidObservable() {}
      * @param sourceObservable the observable sequence to observe from the given Activity
      * @param <T>
      * @return a new observable sequence that will emit notifications on the main UI thread
+     * @deprecated Use {@link #bindActivity(android.app.Activity, rx.Observable)} instead
      */
     @Deprecated
     public static <T> Observable<T> fromActivity(Activity activity, Observable<T> sourceObservable) {
@@ -91,6 +116,7 @@ public static <T> Observable<T> fromActivity(Activity activity, Observable<T> so
      * @param sourceObservable the observable sequence to observe from the given fragment
      * @param <T>
      * @return a new observable sequence that will emit notifications on the main UI thread
+     * @deprecated Use {@link #bindFragment(Object, rx.Observable)} instead
      */
     @Deprecated
     public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sourceObservable) {
@@ -104,18 +130,38 @@ public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sour
         }
     }
 
-    public static <T> Observable<T> bindActivity(Activity activity, Observable<T> cachedSequence) {
-        return cachedSequence.observeOn(mainThread()).lift(new OperatorWeakBinding<T, Activity>(activity));
+    /**
+     * Binds the given source sequence to the life-cycle of an activity.
+     * <p/>
+     * This helper will schedule the given sequence to be observed on the main UI thread and ensure
+     * that no notifications will be forwarded to the activity in case it gets destroyed by the Android runtime
+     * or garbage collected by the VM.
+     *
+     * @param activity the activity to bind the source sequence to
+     * @param source   the source sequence
+     */
+    public static <T> Observable<T> bindActivity(Activity activity, Observable<T> source) {
+        return source.observeOn(mainThread()).lift(new OperatorWeakBinding<T, Activity>(activity, ACTIVITY_VALIDATOR));
     }
 
+    /**
+     * Binds the given source sequence to the life-cycle of a fragment (native or support-v4).
+     * <p/>
+     * This helper will schedule the given sequence to be observed on the main UI thread and ensure
+     * that no notifications will be forwarded to the fragment in case it gets detached from its
+     * activity or garbage collected by the VM.
+     *
+     * @param fragment the fragment to bind the source sequence to
+     * @param source   the source sequence
+     */
     public static <T> Observable<T> bindFragment(Object fragment, Observable<T> cachedSequence) {
         Observable<T> source = cachedSequence.observeOn(mainThread());
         if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
             android.support.v4.app.Fragment f = (android.support.v4.app.Fragment) fragment;
-            return source.lift(new OperatorWeakBinding<T, android.support.v4.app.Fragment>(f));
+            return source.lift(new OperatorWeakBinding<T, android.support.v4.app.Fragment>(f, FRAGMENTV4_VALIDATOR));
         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && fragment instanceof Fragment) {
             Fragment f = (Fragment) fragment;
-            return source.lift(new OperatorWeakBinding<T, Fragment>(f));
+            return source.lift(new OperatorWeakBinding<T, Fragment>(f, FRAGMENT_VALIDATOR));
         } 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/operators/OperatorWeakBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
index 3392cc887a..43a501b489 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
@@ -2,40 +2,58 @@
 
 import rx.Observable;
 import rx.Subscriber;
+import rx.functions.Func1;
+import rx.functions.Functions;
 
 import android.util.Log;
 
 import java.lang.ref.WeakReference;
 
+/**
+ * Ties a source sequence to the life-cycle of the given target object, and/or the subscriber
+ * using weak references. When either object is gone, this operator automatically unsubscribes
+ * from the source sequence.
+ * <p/>
+ * You can also pass in an optional predicate function, which whenever it evaluates to false
+ * on the target object, will also result in the operator unsubscribing from the sequence.
+ *
+ * @param <T> the type of the objects emitted to a subscriber
+ * @param <R> the type of the target object to bind to
+ */
 public final class OperatorWeakBinding<T, R> implements Observable.Operator<T, T> {
 
     private static final String LOG_TAG = "WeakBinding";
 
-    private final WeakReference<R> boundRef;
+    final WeakReference<R> boundRef;
+    private final Func1<? super R, Boolean> predicate;
+
+    public OperatorWeakBinding(R bound, Func1<? super R, Boolean> predicate) {
+        boundRef = new WeakReference<R>(bound);
+        this.predicate = predicate;
+    }
 
     public OperatorWeakBinding(R bound) {
         boundRef = new WeakReference<R>(bound);
+        this.predicate = Functions.alwaysTrue();
     }
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        return new WeakSubscriber<T, R>(child, boundRef);
+        return new WeakSubscriber(child);
     }
 
-    private static final class WeakSubscriber<T, R> extends Subscriber<T> {
+    final class WeakSubscriber extends Subscriber<T> {
 
-        private final WeakReference<Subscriber<? super T>> subscriberRef;
-        private final WeakReference<R> boundRef;
+        final WeakReference<Subscriber<? super T>> subscriberRef;
 
-        private WeakSubscriber(Subscriber<? super T> op, WeakReference<R> boundRef) {
-            subscriberRef = new WeakReference<Subscriber<? super T>>(op);
-            this.boundRef = boundRef;
+        private WeakSubscriber(Subscriber<? super T> source) {
+            subscriberRef = new WeakReference<Subscriber<? super T>>(source);
         }
 
         @Override
         public void onCompleted() {
             Subscriber<? super T> sub = subscriberRef.get();
-            if (sub != null && boundRef.get() != null) {
+            if (shouldForwardNotification(sub)) {
                 sub.onCompleted();
             } else {
                 handleLostBinding(sub, "onCompleted");
@@ -45,7 +63,7 @@ public void onCompleted() {
         @Override
         public void onError(Throwable e) {
             Subscriber<? super T> sub = subscriberRef.get();
-            if (sub != null && boundRef.get() != null) {
+            if (shouldForwardNotification(sub)) {
                 sub.onError(e);
             } else {
                 handleLostBinding(sub, "onError");
@@ -55,21 +73,31 @@ public void onError(Throwable e) {
         @Override
         public void onNext(T t) {
             Subscriber<? super T> sub = subscriberRef.get();
-            if (sub != null && boundRef.get() != null) {
+            if (shouldForwardNotification(sub)) {
                 sub.onNext(t);
             } else {
                 handleLostBinding(sub, "onNext");
             }
         }
 
+        private boolean shouldForwardNotification(Subscriber<? super T> sub) {
+            final R target = boundRef.get();
+            return sub != null && target != null && predicate.call(target);
+        }
+
         private void handleLostBinding(Subscriber<? super T> sub, String context) {
             if (sub == null) {
                 Log.d(LOG_TAG, "subscriber gone; skipping " + context);
             } else {
-                Log.d(LOG_TAG, "bound component gone; skipping " + context);
+                final R r = boundRef.get();
+                if (r != null) { // the predicate failed to validate
+                    Log.d(LOG_TAG, "bound component has become invalid; skipping " + context);
+                } else {
+                    Log.d(LOG_TAG, "bound component gone; skipping " + context);
+                }
             }
+            Log.d(LOG_TAG, "unsubscribing...");
             unsubscribe();
         }
-
     }
 }
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
new file mode 100644
index 0000000000..e5445ce228
--- /dev/null
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
@@ -0,0 +1,86 @@
+package rx.operators;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+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 rx.Subscriber;
+import rx.functions.Functions;
+
+@RunWith(RobolectricTestRunner.class)
+public class OperatorWeakBindingTest {
+
+    @Mock
+    private Subscriber<String> subscriber;
+
+    @Before
+    public void setUp() throws Exception {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void shouldForwardAllNotificationsWhenSubscriberAndTargetAlive() {
+        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
+        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
+        weakSub.onNext("one");
+        weakSub.onNext("two");
+        weakSub.onCompleted();
+        weakSub.onError(new Exception());
+
+        verify(subscriber).onNext("one");
+        verify(subscriber).onNext("two");
+        verify(subscriber).onCompleted();
+        verify(subscriber).onError(any(Exception.class));
+    }
+
+    @Test
+    public void shouldUnsubscribeFromSourceSequenceWhenSubscriberReleased() {
+        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
+
+        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
+        weakSub.onNext("one");
+        weakSub.subscriberRef.clear();
+        weakSub.onNext("two");
+        weakSub.onCompleted();
+        weakSub.onError(new Exception());
+
+        verify(subscriber).onNext("one");
+        verifyNoMoreInteractions(subscriber);
+    }
+
+    @Test
+    public void shouldUnsubscribeFromSourceSequenceWhenTargetObjectReleased() {
+        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
+
+        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
+        weakSub.onNext("one");
+        op.boundRef.clear();
+        weakSub.onNext("two");
+        weakSub.onCompleted();
+        weakSub.onError(new Exception());
+
+        verify(subscriber).onNext("one");
+        verifyNoMoreInteractions(subscriber);
+    }
+
+    @Test
+    public void shouldUnsubscribeFromSourceSequenceWhenPredicateFailsToPass() {
+        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(
+                new Object(), Functions.alwaysFalse());
+
+        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
+        weakSub.onNext("one");
+        weakSub.onNext("two");
+        weakSub.onCompleted();
+        weakSub.onError(new Exception());
+
+        verifyZeroInteractions(subscriber);
+    }
+}

From 135b6c13e03dbb519f8163f5ee5b2c8d7c87684c Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 18:29:41 +0100
Subject: [PATCH 110/422] Some cleaning up

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

diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
index 43a501b489..b1adb3d34d 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
@@ -52,7 +52,7 @@ private WeakSubscriber(Subscriber<? super T> source) {
 
         @Override
         public void onCompleted() {
-            Subscriber<? super T> sub = subscriberRef.get();
+            final Subscriber<? super T> sub = subscriberRef.get();
             if (shouldForwardNotification(sub)) {
                 sub.onCompleted();
             } else {
@@ -62,7 +62,7 @@ public void onCompleted() {
 
         @Override
         public void onError(Throwable e) {
-            Subscriber<? super T> sub = subscriberRef.get();
+            final Subscriber<? super T> sub = subscriberRef.get();
             if (shouldForwardNotification(sub)) {
                 sub.onError(e);
             } else {
@@ -72,7 +72,7 @@ public void onError(Throwable e) {
 
         @Override
         public void onNext(T t) {
-            Subscriber<? super T> sub = subscriberRef.get();
+            final Subscriber<? super T> sub = subscriberRef.get();
             if (shouldForwardNotification(sub)) {
                 sub.onNext(t);
             } else {
@@ -90,7 +90,8 @@ private void handleLostBinding(Subscriber<? super T> sub, String context) {
                 Log.d(LOG_TAG, "subscriber gone; skipping " + context);
             } else {
                 final R r = boundRef.get();
-                if (r != null) { // the predicate failed to validate
+                if (r != null) {
+                    // the predicate failed to validate
                     Log.d(LOG_TAG, "bound component has become invalid; skipping " + context);
                 } else {
                     Log.d(LOG_TAG, "bound component gone; skipping " + context);

From 2f0670ecc6fdae7ce8cf30848e79a773f520934e Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Wed, 12 Mar 2014 18:31:12 +0100
Subject: [PATCH 111/422] Guard the log calls

---
 .../java/rx/operators/OperatorWeakBinding.java     | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
index b1adb3d34d..986341396f 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
@@ -87,18 +87,24 @@ private boolean shouldForwardNotification(Subscriber<? super T> sub) {
 
         private void handleLostBinding(Subscriber<? super T> sub, String context) {
             if (sub == null) {
-                Log.d(LOG_TAG, "subscriber gone; skipping " + context);
+                log("subscriber gone; skipping " + context);
             } else {
                 final R r = boundRef.get();
                 if (r != null) {
                     // the predicate failed to validate
-                    Log.d(LOG_TAG, "bound component has become invalid; skipping " + context);
+                    log("bound component has become invalid; skipping " + context);
                 } else {
-                    Log.d(LOG_TAG, "bound component gone; skipping " + context);
+                    log("bound component gone; skipping " + context);
                 }
             }
-            Log.d(LOG_TAG, "unsubscribing...");
+            log("unsubscribing...");
             unsubscribe();
         }
+
+        private void log(String message) {
+            if (Log.isLoggable(LOG_TAG, Log.DEBUG)) {
+                Log.d(LOG_TAG, message);
+            }
+        }
     }
 }

From 45afeb9fb5ce49a9f0e4d931057ebaf6990111ab Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Thu, 13 Mar 2014 11:14:25 +0100
Subject: [PATCH 112/422] Forward subscription of wrapped subscriber

---
 .../rx/operators/OperatorWeakBinding.java     |  1 +
 .../rx/operators/OperatorWeakBindingTest.java | 42 +++++++++++--------
 2 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
index 986341396f..3cc8258302 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
@@ -47,6 +47,7 @@ final class WeakSubscriber extends Subscriber<T> {
         final WeakReference<Subscriber<? super T>> subscriberRef;
 
         private WeakSubscriber(Subscriber<? super T> source) {
+            super(source);
             subscriberRef = new WeakReference<Subscriber<? super T>>(source);
         }
 
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
index e5445ce228..6dd72c606d 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
@@ -1,24 +1,21 @@
 package rx.operators;
 
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.junit.Assert.assertEquals;
 
 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 rx.Subscriber;
 import rx.functions.Functions;
+import rx.observers.TestSubscriber;
+
+import java.util.Arrays;
 
 @RunWith(RobolectricTestRunner.class)
 public class OperatorWeakBindingTest {
 
-    @Mock
-    private Subscriber<String> subscriber;
+    private TestSubscriber<String> subscriber = new TestSubscriber<String>();
 
     @Before
     public void setUp() throws Exception {
@@ -34,10 +31,9 @@ public void shouldForwardAllNotificationsWhenSubscriberAndTargetAlive() {
         weakSub.onCompleted();
         weakSub.onError(new Exception());
 
-        verify(subscriber).onNext("one");
-        verify(subscriber).onNext("two");
-        verify(subscriber).onCompleted();
-        verify(subscriber).onError(any(Exception.class));
+        subscriber.assertReceivedOnNext(Arrays.asList("one", "two"));
+        assertEquals(1, subscriber.getOnCompletedEvents().size());
+        assertEquals(1, subscriber.getOnErrorEvents().size());
     }
 
     @Test
@@ -51,8 +47,9 @@ public void shouldUnsubscribeFromSourceSequenceWhenSubscriberReleased() {
         weakSub.onCompleted();
         weakSub.onError(new Exception());
 
-        verify(subscriber).onNext("one");
-        verifyNoMoreInteractions(subscriber);
+        subscriber.assertReceivedOnNext(Arrays.asList("one"));
+        assertEquals(0, subscriber.getOnCompletedEvents().size());
+        assertEquals(0, subscriber.getOnErrorEvents().size());
     }
 
     @Test
@@ -66,8 +63,9 @@ public void shouldUnsubscribeFromSourceSequenceWhenTargetObjectReleased() {
         weakSub.onCompleted();
         weakSub.onError(new Exception());
 
-        verify(subscriber).onNext("one");
-        verifyNoMoreInteractions(subscriber);
+        subscriber.assertReceivedOnNext(Arrays.asList("one"));
+        assertEquals(0, subscriber.getOnCompletedEvents().size());
+        assertEquals(0, subscriber.getOnErrorEvents().size());
     }
 
     @Test
@@ -81,6 +79,16 @@ public void shouldUnsubscribeFromSourceSequenceWhenPredicateFailsToPass() {
         weakSub.onCompleted();
         weakSub.onError(new Exception());
 
-        verifyZeroInteractions(subscriber);
+        assertEquals(0, subscriber.getOnNextEvents().size());
+        assertEquals(0, subscriber.getOnCompletedEvents().size());
+        assertEquals(0, subscriber.getOnErrorEvents().size());
+    }
+
+    @Test
+    public void unsubscribeWillUnsubscribeFromWrappedSubscriber() {
+        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
+
+        op.call(subscriber).unsubscribe();
+        subscriber.assertUnsubscribed();
     }
 }

From 7ba5be9797ad17bdcbc34307049fdfc1f33ac8f3 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Thu, 13 Mar 2014 11:18:01 +0100
Subject: [PATCH 113/422] Rewrite AndroidObservableTest to test the new
 operator

---
 .../java/rx/android/observables/AndroidObservable.java |  4 +++-
 .../rx/android/observables/AndroidObservableTest.java  | 10 +++++-----
 2 files changed, 8 insertions(+), 6 deletions(-)

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 28d8d704aa..46d0e48285 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
@@ -141,6 +141,7 @@ public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sour
      * @param source   the source sequence
      */
     public static <T> Observable<T> bindActivity(Activity activity, Observable<T> source) {
+        Assertions.assertUiThread();
         return source.observeOn(mainThread()).lift(new OperatorWeakBinding<T, Activity>(activity, ACTIVITY_VALIDATOR));
     }
 
@@ -155,7 +156,8 @@ public static <T> Observable<T> bindActivity(Activity activity, Observable<T> so
      * @param source   the source sequence
      */
     public static <T> Observable<T> bindFragment(Object fragment, Observable<T> cachedSequence) {
-        Observable<T> source = cachedSequence.observeOn(mainThread());
+        Assertions.assertUiThread();
+        final Observable<T> source = cachedSequence.observeOn(mainThread());
         if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
             android.support.v4.app.Fragment f = (android.support.v4.app.Fragment) fragment;
             return source.lift(new OperatorWeakBinding<T, android.support.v4.app.Fragment>(f, FRAGMENTV4_VALIDATOR));
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
index 0591c6454e..fe7263da0f 100644
--- 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
@@ -69,21 +69,21 @@ public void setup() {
 
     @Test
     public void itSupportsFragmentsFromTheSupportV4Library() {
-        AndroidObservable.fromFragment(supportFragment, Observable.just("success")).subscribe(new TestObserver<String>(observer));
+        AndroidObservable.bindFragment(supportFragment, Observable.just("success")).subscribe(new TestObserver<String>(observer));
         verify(observer).onNext("success");
         verify(observer).onCompleted();
     }
 
     @Test
     public void itSupportsNativeFragments() {
-        AndroidObservable.fromFragment(fragment, Observable.just("success")).subscribe(new TestObserver<String>(observer));
+        AndroidObservable.bindFragment(fragment, Observable.just("success")).subscribe(new TestObserver<String>(observer));
         verify(observer).onNext("success");
         verify(observer).onCompleted();
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void itThrowsIfObjectPassedIsNotAFragment() {
-        AndroidObservable.fromFragment("not a fragment", Observable.never());
+        AndroidObservable.bindFragment("not a fragment", Observable.never());
     }
 
     @Test(expected = IllegalStateException.class)
@@ -91,7 +91,7 @@ public void itThrowsIfObserverCallsFromFragmentFromBackgroundThread() throws Thr
         final Future<Object> future = Executors.newSingleThreadExecutor().submit(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
-                AndroidObservable.fromFragment(fragment, Observable.empty());
+                AndroidObservable.bindFragment(fragment, Observable.empty());
                 return null;
             }
         });
@@ -107,7 +107,7 @@ public void itThrowsIfObserverCallsFromActivityFromBackgroundThread() throws Thr
         final Future<Object> future = Executors.newSingleThreadExecutor().submit(new Callable<Object>() {
             @Override
             public Object call() throws Exception {
-                AndroidObservable.fromActivity(activity, Observable.empty());
+                AndroidObservable.bindActivity(activity, Observable.empty());
                 return null;
             }
         });

From 4feddf8ae49db32d7441f8d274377f951b5ffb8b Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 13 Mar 2014 09:37:11 -0700
Subject: [PATCH 114/422] Retry Unit Test from #879

From https://github.com/Netflix/RxJava/issues/879
---
 .../java/rx/operators/OperatorRetryTest.java  | 42 +++++++++++++++++--
 1 file changed, 38 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
index 6fbcf19678..1092156fd8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
@@ -18,7 +18,6 @@
 import static org.junit.Assert.*;
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.operators.OperatorRetry.*;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -26,6 +25,7 @@
 import org.mockito.InOrder;
 
 import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
 import rx.functions.Action1;
@@ -130,7 +130,7 @@ public Subscription onSubscribe(Observer<? super String> o) {
             return Subscriptions.empty();
         }
     }
-    
+
     @Test
     public void testUnsubscribeFromRetry() {
         PublishSubject<Integer> subject = PublishSubject.create();
@@ -139,10 +139,44 @@ public void testUnsubscribeFromRetry() {
             @Override
             public void call(Integer n) {
                 count.incrementAndGet();
-            }});
+            }
+        });
         subject.onNext(1);
         sub.unsubscribe();
         subject.onNext(2);
-        assertEquals(1,count.get());
+        assertEquals(1, count.get());
+    }
+
+    @Test
+    public void testRetryAllowsSubscriptionAfterAllSubscriptionsUnsubsribed() throws InterruptedException {
+        final AtomicInteger subsCount = new AtomicInteger(0);
+        OnSubscribeFunc<String> onSubscribe = new OnSubscribeFunc<String>() {
+            @Override
+            public Subscription onSubscribe(Observer<? super String> observer) {
+                subsCount.incrementAndGet();
+                return new Subscription() {
+                    boolean unsubscribed = false;
+
+                    @Override
+                    public void unsubscribe() {
+                        subsCount.decrementAndGet();
+                        unsubscribed = true;
+                    }
+
+                    @Override
+                    public boolean isUnsubscribed() {
+                        return unsubscribed;
+                    }
+                };
+            }
+        };
+        Observable<String> stream = Observable.create(onSubscribe);
+        Observable<String> streamWithRetry = stream.retry();
+        Subscription sub = streamWithRetry.subscribe();
+        assertEquals(1, subsCount.get());
+        sub.unsubscribe();
+        assertEquals(0, subsCount.get());
+        streamWithRetry.subscribe();
+        assertEquals(1, subsCount.get());
     }
 }

From 9a0f54f2c0d498c43ab4df621233262b969cccb2 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 28 Feb 2014 13:21:14 -0800
Subject: [PATCH 115/422] OperationSynchronize -> OperatorSynchronize

---
 rxjava-core/src/main/java/rx/Observable.java  |   8 +-
 .../rx/operators/OperationSynchronize.java    |  99 ---
 .../rx/operators/OperatorSynchronize.java     |  75 ++
 .../rx/operators/OperatorSynchronizeTest.java | 688 ++++++++++++++++++
 4 files changed, 767 insertions(+), 103 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSynchronize.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 0d9f74d60e..772ca0ed72 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.OperatorSkipWhile;
 import rx.operators.OperationSum;
 import rx.operators.OperationSwitch;
-import rx.operators.OperationSynchronize;
 import rx.operators.OperationTakeLast;
 import rx.operators.OperationTakeTimed;
 import rx.operators.OperationTakeUntil;
@@ -122,6 +121,7 @@
 import rx.operators.OperatorScan;
 import rx.operators.OperatorSkip;
 import rx.operators.OperatorSubscribeOn;
+import rx.operators.OperatorSynchronize;
 import rx.operators.OperatorTake;
 import rx.operators.OperatorTimeout;
 import rx.operators.OperatorTimeoutWithSelector;
@@ -2712,7 +2712,7 @@ public final static <T> Observable<T> switchOnNext(Observable<? extends Observab
      */
     @Deprecated
     public final static <T> Observable<T> synchronize(Observable<T> source) {
-        return create(OperationSynchronize.synchronize(source));
+        return source.synchronize();
     }
 
     /**
@@ -7261,7 +7261,7 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-synchronize">RxJava Wiki: synchronize()</a>
      */
     public final Observable<T> synchronize() {
-        return create(OperationSynchronize.synchronize(this));
+        return lift(new OperatorSynchronize<T>());
     }
 
     /**
@@ -7285,7 +7285,7 @@ public final Observable<T> synchronize() {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-synchronize">RxJava Wiki: synchronize()</a>
      */
     public final Observable<T> synchronize(Object lock) {
-        return create(OperationSynchronize.synchronize(this, lock));
+        return lift(new OperatorSynchronize<T>(lock));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java b/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
deleted file mode 100644
index e94411b313..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSynchronize.java
+++ /dev/null
@@ -1,99 +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.observers.SynchronizedObserver;
-
-/**
- * Wraps an Observable in another Observable that ensures that the resulting Observable is
- * chronologically well-behaved.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/synchronize.png">
- * <p>
- * A well-behaved Observable does not interleave its invocations of the <code>onNext</code>,
- * <code>onCompleted</code>, and <code>onError</code> methods of its Observers; it invokes
- * <code>onCompleted</code> or <code>onError</code> only once; and it never invokes
- * <code>onNext</code> after invoking either <code>onCompleted</code> or <code>onError</code>. The
- * synchronize operation enforces this, and the Observable it returns invokes <code>onNext</code>
- * and <code>onCompleted</code> or <code>onError</code> synchronously.
- * <p>
- * NOTE: {@link Observable#create} already wraps Observables so this is generally redundant.
- * 
- * @param <T>
- *            The type of the observable sequence.
- */
-public final class OperationSynchronize<T> {
-
-    /**
-     * Accepts an observable and wraps it in another observable which ensures that the resulting observable is well-behaved.
-     * 
-     * A well-behaved observable ensures onNext, onCompleted, or onError calls to its subscribers are
-     * not interleaved, onCompleted and onError are only called once respectively, and no
-     * onNext calls follow onCompleted and onError calls.
-     * 
-     * @param observable
-     * @param <T>
-     * @return the wrapped synchronized observable sequence
-     */
-    public static <T> OnSubscribeFunc<T> synchronize(Observable<? extends T> observable) {
-        return new Synchronize<T>(observable, null);
-    }
-
-    /**
-     * Accepts an observable and wraps it in another observable which ensures that the resulting observable is well-behaved.
-     * This is accomplished by acquiring a mutual-exclusion lock for the object provided as the lock parameter.
-     * 
-     * A well-behaved observable ensures onNext, onCompleted, or onError calls to its subscribers are
-     * not interleaved, onCompleted and onError are only called once respectively, and no
-     * onNext calls follow onCompleted and onError calls.
-     * 
-     * @param observable
-     * @param lock
-     *            The lock object to synchronize each observer call on
-     * @param <T>
-     * @return the wrapped synchronized observable sequence
-     */
-    public static <T> OnSubscribeFunc<T> synchronize(Observable<? extends T> observable, Object lock) {
-        return new Synchronize<T>(observable, lock);
-    }
-
-    private static class Synchronize<T> implements OnSubscribeFunc<T> {
-
-        public Synchronize(Observable<? extends T> innerObservable, Object lock) {
-            this.innerObservable = innerObservable;
-            this.lock = lock;
-        }
-
-        private Observable<? extends T> innerObservable;
-        private SynchronizedObserver<T> atomicObserver;
-        private Object lock;
-
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            if (lock == null) {
-                atomicObserver = new SynchronizedObserver<T>(observer);
-            }
-            else {
-                atomicObserver = new SynchronizedObserver<T>(observer, lock);
-            }
-            return innerObservable.subscribe(atomicObserver);
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSynchronize.java b/rxjava-core/src/main/java/rx/operators/OperatorSynchronize.java
new file mode 100644
index 0000000000..0cdc9eded8
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSynchronize.java
@@ -0,0 +1,75 @@
+/**
+ * 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.observers.SynchronizedSubscriber;
+
+/**
+ * Wraps an Observable in another Observable that ensures that the resulting Observable is
+ * chronologically well-behaved.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/synchronize.png">
+ * <p>
+ * A well-behaved Observable does not interleave its invocations of the <code>onNext</code>,
+ * <code>onCompleted</code>, and <code>onError</code> methods of its Observers; it invokes
+ * <code>onCompleted</code> or <code>onError</code> only once; and it never invokes
+ * <code>onNext</code> after invoking either <code>onCompleted</code> or <code>onError</code>. The
+ * synchronize operation enforces this, and the Observable it returns invokes <code>onNext</code>
+ * and <code>onCompleted</code> or <code>onError</code> synchronously.
+ * <p>
+ * NOTE: {@link Observable#create} already wraps Observables so this is generally redundant.
+ * 
+ * @param <T>
+ *            The type of the observable sequence.
+ */
+public final class OperatorSynchronize<T> implements Operator<T, T> {
+
+    final Object lock;
+
+    public OperatorSynchronize(Object lock) {
+        this.lock = lock;
+    }
+
+    public OperatorSynchronize() {
+        this.lock = new Object();
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> s) {
+        return new SynchronizedSubscriber<T>(new Subscriber<T>(s) {
+
+            @Override
+            public void onCompleted() {
+                s.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+            }
+
+            @Override
+            public void onNext(T t) {
+                s.onNext(t);
+            }
+
+        }, lock);
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java
new file mode 100644
index 0000000000..9ec9396f5b
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java
@@ -0,0 +1,688 @@
+/**
+ * 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.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+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.Subscriber;
+import rx.Subscription;
+import rx.observers.TestSubscriber;
+
+public class OperatorSynchronizeTest {
+
+    @Mock
+    Observer<String> observer;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testSingleThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        w.synchronize().subscribe(observer);
+        onSubscribe.waitToFinish();
+
+        verify(observer, times(1)).onNext("one");
+        verify(observer, times(1)).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+    }
+
+    @Test
+    public void testMultiThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        w.synchronize().subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        assertEquals(3, busyobserver.onNextCount.get());
+        assertFalse(busyobserver.onError);
+        assertTrue(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedBasicWithLock() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        Object lock = new Object();
+        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyobserver, lock, 10, 100);
+
+        externalBusyThread.start();
+
+        w.synchronize(lock).subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        try {
+            externalBusyThread.join(10000);
+            assertFalse(externalBusyThread.isAlive());
+            assertFalse(externalBusyThread.fail);
+        } catch (InterruptedException e) {
+            // ignore
+        }
+
+        assertEquals(3, busyobserver.onNextCount.get());
+        assertFalse(busyobserver.onError);
+        assertTrue(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPE() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        w.synchronize().subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+
+        // we can't know how many onNext calls will occur since they each run on a separate thread
+        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
+        // assertEquals(3, busyobserver.onNextCount.get());
+        assertTrue(busyobserver.onNextCount.get() < 4);
+        assertTrue(busyobserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPEAndLock() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        Object lock = new Object();
+        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyobserver, lock, 10, 100);
+
+        externalBusyThread.start();
+
+        w.synchronize(lock).subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        try {
+            externalBusyThread.join(10000);
+            assertFalse(externalBusyThread.isAlive());
+            assertFalse(externalBusyThread.fail);
+        } catch (InterruptedException e) {
+            // ignore
+        }
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+
+        // we can't know how many onNext calls will occur since they each run on a separate thread
+        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
+        // assertEquals(3, busyobserver.onNextCount.get());
+        assertTrue(busyobserver.onNextCount.get() < 4);
+        assertTrue(busyobserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPEinMiddle() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        w.synchronize().subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+        // this should not be the full number of items since the error should stop it before it completes all 9
+        System.out.println("onNext count: " + busyobserver.onNextCount.get());
+        assertTrue(busyobserver.onNextCount.get() < 9);
+        assertTrue(busyobserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        // verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPEinMiddleAndLock() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        Object lock = new Object();
+        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyobserver, lock, 10, 100);
+
+        externalBusyThread.start();
+
+        w.synchronize(lock).subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        try {
+            externalBusyThread.join(10000);
+            assertFalse(externalBusyThread.isAlive());
+            assertFalse(externalBusyThread.fail);
+        } catch (InterruptedException e) {
+            // ignore
+        }
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+        // this should not be the full number of items since the error should stop it before it completes all 9
+        System.out.println("onNext count: " + busyobserver.onNextCount.get());
+        assertTrue(busyobserver.onNextCount.get() < 9);
+        assertTrue(busyobserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        // verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    /**
+     * A thread that will pass data to onNext
+     */
+    public static class OnNextThread implements Runnable {
+
+        private final Observer<String> observer;
+        private final int numStringsToSend;
+
+        OnNextThread(Observer<String> observer, int numStringsToSend) {
+            this.observer = observer;
+            this.numStringsToSend = numStringsToSend;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < numStringsToSend; i++) {
+                observer.onNext("aString");
+            }
+        }
+    }
+
+    /**
+     * A thread that will call onError or onNext
+     */
+    public static class CompletionThread implements Runnable {
+
+        private final Observer<String> observer;
+        private final TestConcurrencyobserverEvent event;
+        private final Future<?>[] waitOnThese;
+
+        CompletionThread(Observer<String> observer, TestConcurrencyobserverEvent event, Future<?>... waitOnThese) {
+            this.observer = observer;
+            this.event = event;
+            this.waitOnThese = waitOnThese;
+        }
+
+        @Override
+        public void run() {
+            /* if we have 'waitOnThese' futures, we'll wait on them before proceeding */
+            if (waitOnThese != null) {
+                for (Future<?> f : waitOnThese) {
+                    try {
+                        f.get();
+                    } catch (Throwable e) {
+                        System.err.println("Error while waiting on future in CompletionThread");
+                    }
+                }
+            }
+
+            /* send the event */
+            if (event == TestConcurrencyobserverEvent.onError) {
+                observer.onError(new RuntimeException("mocked exception"));
+            } else if (event == TestConcurrencyobserverEvent.onCompleted) {
+                observer.onCompleted();
+
+            } else {
+                throw new IllegalArgumentException("Expecting either onError or onCompleted");
+            }
+        }
+    }
+
+    private static enum TestConcurrencyobserverEvent {
+        onCompleted, onError, onNext
+    }
+
+    private static class TestConcurrencyobserver extends Subscriber<String> {
+
+        /**
+         * used to store the order and number of events received
+         */
+        private final LinkedBlockingQueue<TestConcurrencyobserverEvent> events = new LinkedBlockingQueue<TestConcurrencyobserverEvent>();
+        private final int waitTime;
+
+        @SuppressWarnings("unused")
+        public TestConcurrencyobserver(int waitTimeInNext) {
+            this.waitTime = waitTimeInNext;
+        }
+
+        public TestConcurrencyobserver() {
+            this.waitTime = 0;
+        }
+
+        @Override
+        public void onCompleted() {
+            events.add(TestConcurrencyobserverEvent.onCompleted);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            events.add(TestConcurrencyobserverEvent.onError);
+        }
+
+        @Override
+        public void onNext(String args) {
+            events.add(TestConcurrencyobserverEvent.onNext);
+            // do some artificial work to make the thread scheduling/timing vary
+            int s = 0;
+            for (int i = 0; i < 20; i++) {
+                s += s * i;
+            }
+
+            if (waitTime > 0) {
+                try {
+                    Thread.sleep(waitTime);
+                } catch (InterruptedException e) {
+                    // ignore
+                }
+            }
+        }
+
+        /**
+         * Assert the order of events is correct and return the number of onNext executions.
+         * 
+         * @param expectedEndingEvent
+         * @return int count of onNext calls
+         * @throws IllegalStateException
+         *             If order of events was invalid.
+         */
+        public int assertEvents(TestConcurrencyobserverEvent expectedEndingEvent) throws IllegalStateException {
+            int nextCount = 0;
+            boolean finished = false;
+            for (TestConcurrencyobserverEvent e : events) {
+                if (e == TestConcurrencyobserverEvent.onNext) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onNext but we're already finished.");
+                    }
+                    nextCount++;
+                } else if (e == TestConcurrencyobserverEvent.onError) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onError but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onError != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                } else if (e == TestConcurrencyobserverEvent.onCompleted) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onCompleted but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onCompleted != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                }
+            }
+
+            return nextCount;
+        }
+
+    }
+
+    /**
+     * This spawns a single thread for the subscribe execution
+     */
+    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        private Thread t = null;
+
+        public TestSingleThreadedObservable(final Subscription s, final String... values) {
+            this.s = s;
+            this.values = values;
+
+        }
+
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestSingleThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestSingleThreadedObservable thread");
+                        for (String s : values) {
+                            System.out.println("TestSingleThreadedObservable onNext: " + s);
+                            observer.onNext(s);
+                        }
+                        observer.onCompleted();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+            });
+            System.out.println("starting TestSingleThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestSingleThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+    /**
+     * This spawns a thread for the subscription, then a separate thread for each onNext call.
+     */
+    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        Thread t = null;
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+        ExecutorService threadPool;
+
+        public TestMultiThreadedObservable(Subscription s, String... values) {
+            this.s = s;
+            this.values = values;
+            this.threadPool = Executors.newCachedThreadPool();
+        }
+
+        @Override
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestMultiThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestMultiThreadedObservable thread");
+                        for (final String s : values) {
+                            threadPool.execute(new Runnable() {
+
+                                @Override
+                                public void run() {
+                                    threadsRunning.incrementAndGet();
+                                    try {
+                                        // perform onNext call
+                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
+                                        if (s == null) {
+                                            // force an error
+                                            throw new NullPointerException();
+                                        }
+                                        observer.onNext(s);
+                                        // capture 'maxThreads'
+                                        int concurrentThreads = threadsRunning.get();
+                                        int maxThreads = maxConcurrentThreads.get();
+                                        if (concurrentThreads > maxThreads) {
+                                            maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                                        }
+                                    } catch (Throwable e) {
+                                        observer.onError(e);
+                                    } finally {
+                                        threadsRunning.decrementAndGet();
+                                    }
+                                }
+                            });
+                        }
+                        // we are done spawning threads
+                        threadPool.shutdown();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+
+                    // wait until all threads are done, then mark it as COMPLETED
+                    try {
+                        // wait for all the threads to finish
+                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    observer.onCompleted();
+                }
+            });
+            System.out.println("starting TestMultiThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestMultiThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    private static class BusyObserver extends Subscriber<String> {
+        volatile boolean onCompleted = false;
+        volatile boolean onError = false;
+        AtomicInteger onNextCount = new AtomicInteger();
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+
+        @Override
+        public void onCompleted() {
+            threadsRunning.incrementAndGet();
+
+            System.out.println(">>> Busyobserver received onCompleted");
+            onCompleted = true;
+
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            }
+            threadsRunning.decrementAndGet();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            threadsRunning.incrementAndGet();
+
+            System.out.println(">>> Busyobserver received onError: " + e.getMessage());
+            onError = true;
+
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            }
+            threadsRunning.decrementAndGet();
+        }
+
+        @Override
+        public void onNext(String args) {
+            threadsRunning.incrementAndGet();
+            try {
+                onNextCount.incrementAndGet();
+                System.out.println(">>> Busyobserver received onNext: " + args);
+                try {
+                    // simulate doing something computational
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            } finally {
+                // capture 'maxThreads'
+                int concurrentThreads = threadsRunning.get();
+                int maxThreads = maxConcurrentThreads.get();
+                if (concurrentThreads > maxThreads) {
+                    maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                }
+                threadsRunning.decrementAndGet();
+            }
+        }
+
+    }
+
+    private static class ExternalBusyThread extends Thread {
+
+        private BusyObserver observer;
+        private Object lock;
+        private int lockTimes;
+        private int waitTime;
+        public volatile boolean fail;
+
+        public ExternalBusyThread(BusyObserver observer, Object lock, int lockTimes, int waitTime) {
+            this.observer = observer;
+            this.lock = lock;
+            this.lockTimes = lockTimes;
+            this.waitTime = waitTime;
+            this.fail = false;
+        }
+
+        @Override
+        public void run() {
+            Random r = new Random();
+            for (int i = 0; i < lockTimes; i++) {
+                synchronized (lock) {
+                    int oldOnNextCount = observer.onNextCount.get();
+                    boolean oldOnCompleted = observer.onCompleted;
+                    boolean oldOnError = observer.onError;
+                    try {
+                        Thread.sleep(r.nextInt(waitTime));
+                    } catch (InterruptedException e) {
+                        // ignore
+                    }
+                    // Since we own the lock, onNextCount, onCompleted and
+                    // onError must not be changed.
+                    int newOnNextCount = observer.onNextCount.get();
+                    boolean newOnCompleted = observer.onCompleted;
+                    boolean newOnError = observer.onError;
+                    if (oldOnNextCount != newOnNextCount) {
+                        System.out.println(">>> ExternalBusyThread received different onNextCount: "
+                                + oldOnNextCount
+                                + " -> "
+                                + newOnNextCount);
+                        fail = true;
+                        break;
+                    }
+                    if (oldOnCompleted != newOnCompleted) {
+                        System.out.println(">>> ExternalBusyThread received different onCompleted: "
+                                + oldOnCompleted
+                                + " -> "
+                                + newOnCompleted);
+                        fail = true;
+                        break;
+                    }
+                    if (oldOnError != newOnError) {
+                        System.out.println(">>> ExternalBusyThread received different onError: "
+                                + oldOnError
+                                + " -> "
+                                + newOnError);
+                        fail = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+    }
+}

From 4427d03db0d8ba67137654447c6c7a57615c0b00 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 28 Feb 2014 21:11:32 -0800
Subject: [PATCH 116/422] OperatorSerialize

---
 rxjava-core/src/main/java/rx/Observable.java  |   9 +-
 .../java/rx/observers/SerializedObserver.java | 183 ++++++
 .../rx/observers/SerializedSubscriber.java    |  28 +
 .../java/rx/operators/OperatorSerialize.java  |  46 ++
 .../OperatorSerializePerformance.java         | 230 +++++++
 .../OperatorSynchronizePerformance.java       | 236 +++++++
 .../rx/observers/SerializedObserverTest.java  | 575 ++++++++++++++++++
 .../rx/operators/OperatorSerializeTest.java   | 566 +++++++++++++++++
 8 files changed, 1871 insertions(+), 2 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/observers/SerializedObserver.java
 create mode 100644 rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSerialize.java
 create mode 100644 rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
 create mode 100644 rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
 create mode 100644 rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 772ca0ed72..7874ff8f3f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -52,7 +52,6 @@
 import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationAll;
-import rx.operators.OperatorAmb;
 import rx.operators.OperationAny;
 import rx.operators.OperationAsObservable;
 import rx.operators.OperationAverage;
@@ -91,7 +90,6 @@
 import rx.operators.OperationSkip;
 import rx.operators.OperationSkipLast;
 import rx.operators.OperationSkipUntil;
-import rx.operators.OperatorSkipWhile;
 import rx.operators.OperationSum;
 import rx.operators.OperationSwitch;
 import rx.operators.OperationTakeLast;
@@ -106,6 +104,7 @@
 import rx.operators.OperationToObservableFuture;
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
+import rx.operators.OperatorAmb;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorFilter;
@@ -119,7 +118,9 @@
 import rx.operators.OperatorRepeat;
 import rx.operators.OperatorRetry;
 import rx.operators.OperatorScan;
+import rx.operators.OperatorSerialize;
 import rx.operators.OperatorSkip;
+import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorSynchronize;
 import rx.operators.OperatorTake;
@@ -6197,6 +6198,10 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
         return lift(new OperatorScan<R, T>(initialValue, accumulator));
     }
 
+    public final Observable<T> serialize() {
+        return lift(new OperatorSerialize<T>());
+    }
+    
     /**
      * 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
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
new file mode 100644
index 0000000000..fd4730290f
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -0,0 +1,183 @@
+package rx.observers;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Observer;
+
+public class SerializedObserver<T> implements Observer<T> {
+
+    private final AtomicReference<State> state = new AtomicReference<State>(State.createNew());
+    private final Observer<T> s;
+
+    public SerializedObserver(Observer<T> s) {
+        this.s = s;
+    }
+
+    @Override
+    public void onCompleted() {
+        State current = null;
+        State newState = null;
+        do {
+            current = state.get();
+            if (current.isTerminated()) {
+                // already received terminal state
+                return;
+            }
+            newState = current.complete();
+        } while (!state.compareAndSet(current, newState));
+        if (newState.count == 0) {
+            s.onCompleted();
+        }
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        State current = null;
+        State newState = null;
+        do {
+            current = state.get();
+            if (current.isTerminated()) {
+                // already received terminal state
+                return;
+            }
+            newState = current.error(e);
+        } while (!state.compareAndSet(current, newState));
+        if (newState.count == 0) {
+            s.onError(e);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void onNext(T t) {
+        State current = null;
+        State newState = null;
+        do {
+            current = state.get();
+            if (current.isTerminated()) {
+                // already received terminal state
+                return;
+            }
+            newState = current.increment(t);
+        } while (!state.compareAndSet(current, newState));
+
+        if (newState.count == 1) {
+            // this thread wins and will emit then drain queue if it concurrently gets added to
+            try {
+                s.onNext(t);
+            } finally {
+                // decrement after finishing
+                do {
+                    current = state.get();
+                    newState = current.decrement();
+                } while (!state.compareAndSet(current, newState));
+            }
+
+            // drain queue if exists
+            // we do "if" instead of "while" so we don't starve one thread
+            if (newState.queue.length > 0) {
+                Object[] items = newState.queue;
+                for (int i = 0; i < items.length; i++) {
+                    s.onNext((T) items[i]);
+                }
+                // clear state of queue
+                do {
+                    current = state.get();
+                    newState = current.drain(items.length);
+                } while (!state.compareAndSet(current, newState));
+                terminateIfNecessary(newState);
+            } else {
+                terminateIfNecessary(newState);
+            }
+
+        }
+    }
+
+    private void terminateIfNecessary(State state) {
+        if (state.isTerminated()) {
+            if (state.onComplete) {
+                s.onCompleted();
+            } else {
+                s.onError(state.onError);
+            }
+        }
+    }
+
+    public static class State {
+        final int count;
+        final Object[] queue;
+        final boolean onComplete;
+        final Throwable onError;
+
+        private final static Object[] EMPTY = new Object[0];
+
+        private final static State NON_TERMINATED_EMPTY = new State(0, false, null, EMPTY);
+        private final static State NON_TERMINATED_SINGLE = new State(1, false, null, EMPTY);
+
+        public State(int count, boolean onComplete, Throwable onError, Object[] queue) {
+            this.count = count;
+            this.queue = queue;
+            this.onComplete = onComplete;
+            this.onError = onError;
+        }
+
+        public static State createNew() {
+            return new State(0, false, null, EMPTY);
+        }
+
+        public boolean isTerminated() {
+            return onComplete || onError != null;
+        }
+
+        public State complete() {
+            return new State(count, true, onError, queue);
+        }
+
+        public State error(Throwable e) {
+            return new State(count, onComplete, e, queue);
+        }
+
+        AtomicInteger max = new AtomicInteger();
+
+        public State increment(Object item) {
+            if (count == 0) {
+                // no concurrent requests so don't queue, we'll process immediately
+                if (isTerminated()) {
+                    // return count of 0 meaning don't emit as we are terminated
+                    return new State(0, onComplete, onError, EMPTY);
+                } else {
+                    return NON_TERMINATED_SINGLE;
+                }
+            } else {
+                // concurrent requests so need to queue
+                int idx = queue.length;
+                Object[] newQueue = new Object[idx + 1];
+                System.arraycopy(queue, 0, newQueue, 0, idx);
+                newQueue[idx] = item;
+
+                if (max.get() < newQueue.length) {
+                    max.set(newQueue.length);
+                    System.out.println("max queue: " + newQueue.length);
+                }
+
+                return new State(count + 1, onComplete, onError, newQueue);
+            }
+        }
+
+        public State decrement() {
+            if (count > 1 || isTerminated()) {
+                return new State(count - 1, onComplete, onError, queue);
+            } else {
+                return NON_TERMINATED_EMPTY;
+            }
+        }
+
+        public State drain(int c) {
+            Object[] newQueue = new Object[queue.length - c];
+            System.arraycopy(queue, c, newQueue, 0, newQueue.length);
+            return new State(count - c, onComplete, onError, newQueue);
+        }
+
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
new file mode 100644
index 0000000000..377cef9d74
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
@@ -0,0 +1,28 @@
+package rx.observers;
+
+import rx.Observer;
+import rx.Subscriber;
+
+public class SerializedSubscriber<T> extends Subscriber<T> {
+
+    private final Observer<T> s;
+
+    public SerializedSubscriber(Subscriber<T> s) {
+        this.s = new SerializedObserver<T>(s);
+    }
+
+    @Override
+    public void onCompleted() {
+        s.onCompleted();
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        s.onError(e);
+    }
+
+    @Override
+    public void onNext(T t) {
+        s.onNext(t);
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSerialize.java b/rxjava-core/src/main/java/rx/operators/OperatorSerialize.java
new file mode 100644
index 0000000000..f41620bab2
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSerialize.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.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.observers.SerializedSubscriber;
+
+public final class OperatorSerialize<T> implements Operator<T, T> {
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> s) {
+        return new SerializedSubscriber<T>(new Subscriber<T>(s) {
+
+            @Override
+            public void onCompleted() {
+                s.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+            }
+
+            @Override
+            public void onNext(T t) {
+                s.onNext(t);
+            }
+
+        });
+    }
+
+}
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
new file mode 100644
index 0000000000..79596d5733
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
@@ -0,0 +1,230 @@
+package rx.operators;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.perf.AbstractPerformanceTester;
+import rx.perf.IntegerSumObserver;
+import rx.schedulers.Schedulers;
+
+public class OperatorSerializePerformance extends AbstractPerformanceTester {
+    //    static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
+
+    //    static int reps = Integer.MAX_VALUE / 1024; // timeSingleStream
+
+    static int reps = 1000; // interval streams
+
+    OperatorSerializePerformance() {
+        super(reps);
+    }
+
+    public static void main(String args[]) {
+
+        final OperatorSerializePerformance spt = new OperatorSerializePerformance();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    spt.timeTwoStreams();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * Run: 10 - 36,891,795 ops/sec
+     * Run: 11 - 29,854,808 ops/sec
+     * Run: 12 - 36,162,140 ops/sec
+     * Run: 13 - 35,727,201 ops/sec
+     * Run: 14 - 34,897,262 ops/sec
+     */
+    public long timeSingleStream() {
+
+        final Observable<Integer> s1 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
+
+        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                final CountDownLatch latch = new CountDownLatch(1);
+                // first
+                s1.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                s.onCompleted();
+            }
+
+        }).serialize();
+
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        //        System.out.println("sum : " + o.sum);
+
+        return o.sum;
+    }
+
+    public long timeTwoStreams() {
+
+        final Observable<Integer> s1 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
+        final Observable<Integer> s2 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
+
+        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                final CountDownLatch latch = new CountDownLatch(2);
+                // first
+                s1.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                // second
+                s2.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                s.onCompleted();
+            }
+
+        }).serialize();
+
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        System.out.println("sum : " + o.sum);
+
+        return o.sum;
+    }
+
+    /**
+     * Run: 10 - 1,996 ops/sec
+     * Run: 11 - 1,996 ops/sec
+     * Run: 12 - 1,996 ops/sec
+     * Run: 13 - 1,996 ops/sec
+     * Run: 14 - 1,996 ops/sec
+     */
+    public long timeTwoStreamsIntervals() {
+
+        final Observable<Integer> s1 = Observable.interval(1, TimeUnit.MILLISECONDS).take(reps / 2).flatMap(new Func1<Long, Observable<Integer>>() {
+
+            @Override
+            public Observable<Integer> call(Long l) {
+                return Observable.range(l.intValue(), 100);
+            }
+
+        }).subscribeOn(Schedulers.newThread());
+        final Observable<Integer> s2 = Observable.range(1, reps / 2).subscribeOn(Schedulers.newThread());
+
+        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                final CountDownLatch latch = new CountDownLatch(2);
+                // first
+                s1.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                // second
+                s2.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                s.onCompleted();
+            }
+
+        }).serialize();
+
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        //        System.out.println("sum : " + o.sum);
+
+        return o.sum;
+    }
+
+}
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
new file mode 100644
index 0000000000..fdd3ced3d3
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
@@ -0,0 +1,236 @@
+package rx.operators;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.perf.AbstractPerformanceTester;
+import rx.perf.IntegerSumObserver;
+import rx.schedulers.Schedulers;
+
+public class OperatorSynchronizePerformance extends AbstractPerformanceTester {
+    //    static int reps = Integer.MAX_VALUE / 1024;
+
+    static int reps = 1000; // timeTwoStreamsIntervals
+
+    OperatorSynchronizePerformance() {
+        super(reps);
+    }
+
+    public static void main(String args[]) {
+
+        final OperatorSynchronizePerformance spt = new OperatorSynchronizePerformance();
+        try {
+            spt.runTest(new Action0() {
+
+                @Override
+                public void call() {
+                    spt.timeTwoStreamsIntervals();
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * Run: 10 - 59,593,390 ops/sec
+     * Run: 11 - 55,784,194 ops/sec
+     * Run: 12 - 58,778,300 ops/sec
+     * Run: 13 - 60,679,696 ops/sec
+     * Run: 14 - 59,370,693 ops/sec
+     */
+    public long timeSingleStream() {
+
+        final Observable<Integer> s1 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
+
+        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                final CountDownLatch latch = new CountDownLatch(1);
+                // first
+                s1.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                s.onCompleted();
+            }
+
+        }).synchronize();
+
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        //        System.out.println("sum : " + o.sum);
+
+        return o.sum;
+    }
+
+    /**
+     * Run: 10 - 9,139,226 ops/sec
+     * Run: 11 - 8,456,526 ops/sec
+     * Run: 12 - 8,072,174 ops/sec
+     * Run: 13 - 8,667,381 ops/sec
+     * Run: 14 - 8,853,370 ops/sec
+     */
+    public long timeTwoStreams() {
+
+        final Observable<Integer> s1 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
+        final Observable<Integer> s2 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
+
+        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                final CountDownLatch latch = new CountDownLatch(2);
+                // first
+                s1.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                // second
+                s2.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                s.onCompleted();
+            }
+
+        }).synchronize();
+
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        //        System.out.println("sum : " + o.sum);
+
+        return o.sum;
+    }
+
+    /**
+     * Run: 10 - 1,996 ops/sec
+     * Run: 11 - 1,997 ops/sec
+     * Run: 12 - 1,996 ops/sec
+     * Run: 13 - 1,996 ops/sec
+     * Run: 14 - 1,995 ops/sec
+     * 
+     * @return
+     */
+    public long timeTwoStreamsIntervals() {
+
+        final Observable<Integer> s1 = Observable.interval(1, TimeUnit.MILLISECONDS).take(reps / 2).flatMap(new Func1<Long, Observable<Integer>>() {
+
+            @Override
+            public Observable<Integer> call(Long l) {
+                return Observable.range(l.intValue(), 100);
+            }
+
+        }).subscribeOn(Schedulers.newThread());
+        final Observable<Integer> s2 = Observable.range(1, reps / 2).subscribeOn(Schedulers.newThread());
+
+        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                final CountDownLatch latch = new CountDownLatch(2);
+                // first
+                s1.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                // second
+                s2.doOnTerminate(new Action0() {
+
+                    @Override
+                    public void call() {
+                        latch.countDown();
+                    }
+
+                }).subscribe(new Action1<Integer>() {
+
+                    @Override
+                    public void call(Integer t1) {
+                        s.onNext(t1);
+                    }
+
+                });
+
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                s.onCompleted();
+            }
+
+        }).synchronize();
+
+        IntegerSumObserver o = new IntegerSumObserver();
+        s.subscribe(o);
+        //                System.out.println("sum : " + o.sum);
+
+        return o.sum;
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
new file mode 100644
index 0000000000..bbdc17c65f
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -0,0 +1,575 @@
+/**
+ * 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.observers;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+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.Subscriber;
+import rx.Subscription;
+
+public class SerializedObserverTest {
+
+    @Mock
+    Subscriber<String> observer;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testSingleThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        SerializedObserver<String> aw = new SerializedObserver<String>(observer);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+
+        verify(observer, times(1)).onNext("one");
+        verify(observer, times(1)).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+    }
+
+    @Test
+    public void testMultiThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyObserver = new BusyObserver();
+        SerializedObserver<String> aw = new SerializedObserver<String>(busyObserver);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+
+        assertEquals(3, busyObserver.onNextCount.get());
+        assertFalse(busyObserver.onError);
+        assertTrue(busyObserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyObserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPE() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyObserver = new BusyObserver();
+        SerializedObserver<String> aw = new SerializedObserver<String>(busyObserver);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+
+        // we can't know how many onNext calls will occur since they each run on a separate thread
+        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
+        // assertEquals(3, busyObserver.onNextCount.get());
+        assertTrue(busyObserver.onNextCount.get() < 4);
+        assertTrue(busyObserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyObserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyObserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPEinMiddle() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyObserver = new BusyObserver();
+        SerializedObserver<String> aw = new SerializedObserver<String>(busyObserver);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+        // this should not be the full number of items since the error should stop it before it completes all 9
+        System.out.println("onNext count: " + busyObserver.onNextCount.get());
+        assertTrue(busyObserver.onNextCount.get() < 9);
+        assertTrue(busyObserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyObserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        // verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyObserver.maxConcurrentThreads.get());
+    }
+
+    /**
+     * A non-realistic use case that tries to expose thread-safety issues by throwing lots of out-of-order
+     * events on many threads.
+     * 
+     * @param w
+     * @param tw
+     */
+    @Test
+    public void runConcurrencyTest() {
+        ExecutorService tp = Executors.newFixedThreadPool(20);
+        try {
+            TestConcurrencyObserver tw = new TestConcurrencyObserver();
+            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
+            SerializedObserver<String> w = new SerializedObserver<String>(new SafeSubscriber<String>(tw));
+
+            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
+            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
+            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
+            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
+            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
+            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
+            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
+            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
+
+            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4));
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                // ignore
+            }
+            Future<?> f11 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            Future<?> f12 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            Future<?> f13 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            Future<?> f14 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            // // the next 4 onError events should wait on same as f10
+            Future<?> f15 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+            Future<?> f16 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+            Future<?> f17 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+            Future<?> f18 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+
+            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10, f11, f12, f13, f14, f15, f16, f17, f18);
+            @SuppressWarnings("unused")
+            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
+            // System.out.println("Number of events executed: " + numNextEvents);
+        } catch (Throwable e) {
+            fail("Concurrency test failed: " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            tp.shutdown();
+            try {
+                tp.awaitTermination(5000, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private static void waitOnThreads(Future<?>... futures) {
+        for (Future<?> f : futures) {
+            try {
+                f.get(10, TimeUnit.SECONDS);
+            } catch (Throwable e) {
+                System.err.println("Failed while waiting on future.");
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * A thread that will pass data to onNext
+     */
+    public static class OnNextThread implements Runnable {
+
+        private final Observer<String> Observer;
+        private final int numStringsToSend;
+
+        OnNextThread(Observer<String> Observer, int numStringsToSend) {
+            this.Observer = Observer;
+            this.numStringsToSend = numStringsToSend;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < numStringsToSend; i++) {
+                Observer.onNext("aString");
+            }
+        }
+    }
+
+    /**
+     * A thread that will call onError or onNext
+     */
+    public static class CompletionThread implements Runnable {
+
+        private final Observer<String> Observer;
+        private final TestConcurrencyObserverEvent event;
+        private final Future<?>[] waitOnThese;
+
+        CompletionThread(Observer<String> Observer, TestConcurrencyObserverEvent event, Future<?>... waitOnThese) {
+            this.Observer = Observer;
+            this.event = event;
+            this.waitOnThese = waitOnThese;
+        }
+
+        @Override
+        public void run() {
+            /* if we have 'waitOnThese' futures, we'll wait on them before proceeding */
+            if (waitOnThese != null) {
+                for (Future<?> f : waitOnThese) {
+                    try {
+                        f.get();
+                    } catch (Throwable e) {
+                        System.err.println("Error while waiting on future in CompletionThread");
+                    }
+                }
+            }
+
+            /* send the event */
+            if (event == TestConcurrencyObserverEvent.onError) {
+                Observer.onError(new RuntimeException("mocked exception"));
+            } else if (event == TestConcurrencyObserverEvent.onCompleted) {
+                Observer.onCompleted();
+
+            } else {
+                throw new IllegalArgumentException("Expecting either onError or onCompleted");
+            }
+        }
+    }
+
+    private static enum TestConcurrencyObserverEvent {
+        onCompleted, onError, onNext
+    }
+
+    private static class TestConcurrencyObserver extends Subscriber<String> {
+
+        /**
+         * used to store the order and number of events received
+         */
+        private final LinkedBlockingQueue<TestConcurrencyObserverEvent> events = new LinkedBlockingQueue<TestConcurrencyObserverEvent>();
+        private final int waitTime;
+
+        @SuppressWarnings("unused")
+        public TestConcurrencyObserver(int waitTimeInNext) {
+            this.waitTime = waitTimeInNext;
+        }
+
+        public TestConcurrencyObserver() {
+            this.waitTime = 0;
+        }
+
+        @Override
+        public void onCompleted() {
+            events.add(TestConcurrencyObserverEvent.onCompleted);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            events.add(TestConcurrencyObserverEvent.onError);
+        }
+
+        @Override
+        public void onNext(String args) {
+            events.add(TestConcurrencyObserverEvent.onNext);
+            // do some artificial work to make the thread scheduling/timing vary
+            int s = 0;
+            for (int i = 0; i < 20; i++) {
+                s += s * i;
+            }
+
+            if (waitTime > 0) {
+                try {
+                    Thread.sleep(waitTime);
+                } catch (InterruptedException e) {
+                    // ignore
+                }
+            }
+        }
+
+        /**
+         * Assert the order of events is correct and return the number of onNext executions.
+         * 
+         * @param expectedEndingEvent
+         * @return int count of onNext calls
+         * @throws IllegalStateException
+         *             If order of events was invalid.
+         */
+        public int assertEvents(TestConcurrencyObserverEvent expectedEndingEvent) throws IllegalStateException {
+            int nextCount = 0;
+            boolean finished = false;
+            for (TestConcurrencyObserverEvent e : events) {
+                if (e == TestConcurrencyObserverEvent.onNext) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onNext but we're already finished.");
+                    }
+                    nextCount++;
+                } else if (e == TestConcurrencyObserverEvent.onError) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onError but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onError != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                } else if (e == TestConcurrencyObserverEvent.onCompleted) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onCompleted but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onCompleted != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                }
+            }
+
+            return nextCount;
+        }
+
+    }
+
+    /**
+     * This spawns a single thread for the subscribe execution
+     */
+    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        private Thread t = null;
+
+        public TestSingleThreadedObservable(final Subscription s, final String... values) {
+            this.s = s;
+            this.values = values;
+
+        }
+
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestSingleThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestSingleThreadedObservable thread");
+                        for (String s : values) {
+                            System.out.println("TestSingleThreadedObservable onNext: " + s);
+                            observer.onNext(s);
+                        }
+                        observer.onCompleted();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+            });
+            System.out.println("starting TestSingleThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestSingleThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+    /**
+     * This spawns a thread for the subscription, then a separate thread for each onNext call.
+     */
+    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        Thread t = null;
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+        ExecutorService threadPool;
+
+        public TestMultiThreadedObservable(Subscription s, String... values) {
+            this.s = s;
+            this.values = values;
+            this.threadPool = Executors.newCachedThreadPool();
+        }
+
+        @Override
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestMultiThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestMultiThreadedObservable thread");
+                        for (final String s : values) {
+                            threadPool.execute(new Runnable() {
+
+                                @Override
+                                public void run() {
+                                    threadsRunning.incrementAndGet();
+                                    try {
+                                        // perform onNext call
+                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
+                                        if (s == null) {
+                                            // force an error
+                                            throw new NullPointerException();
+                                        }
+                                        observer.onNext(s);
+                                        // capture 'maxThreads'
+                                        int concurrentThreads = threadsRunning.get();
+                                        int maxThreads = maxConcurrentThreads.get();
+                                        if (concurrentThreads > maxThreads) {
+                                            maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                                        }
+                                    } catch (Throwable e) {
+                                        observer.onError(e);
+                                    } finally {
+                                        threadsRunning.decrementAndGet();
+                                    }
+                                }
+                            });
+                        }
+                        // we are done spawning threads
+                        threadPool.shutdown();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+
+                    // wait until all threads are done, then mark it as COMPLETED
+                    try {
+                        // wait for all the threads to finish
+                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    observer.onCompleted();
+                }
+            });
+            System.out.println("starting TestMultiThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestMultiThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    private static class BusyObserver extends Subscriber<String> {
+        volatile boolean onCompleted = false;
+        volatile boolean onError = false;
+        AtomicInteger onNextCount = new AtomicInteger();
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+
+        @Override
+        public void onCompleted() {
+            threadsRunning.incrementAndGet();
+
+            System.out.println(">>> BusyObserver received onCompleted");
+            onCompleted = true;
+
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            }
+            threadsRunning.decrementAndGet();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            threadsRunning.incrementAndGet();
+
+            System.out.println(">>> BusyObserver received onError: " + e.getMessage());
+            onError = true;
+
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            }
+            threadsRunning.decrementAndGet();
+        }
+
+        @Override
+        public void onNext(String args) {
+            threadsRunning.incrementAndGet();
+            try {
+                onNextCount.incrementAndGet();
+                System.out.println(">>> BusyObserver received onNext: " + args);
+                try {
+                    // simulate doing something computational
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            } finally {
+                // capture 'maxThreads'
+                int concurrentThreads = threadsRunning.get();
+                int maxThreads = maxConcurrentThreads.get();
+                if (concurrentThreads > maxThreads) {
+                    maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                }
+                threadsRunning.decrementAndGet();
+            }
+        }
+
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
new file mode 100644
index 0000000000..6e396b2139
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
@@ -0,0 +1,566 @@
+/**
+ * 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.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+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.Subscriber;
+import rx.Subscription;
+
+public class OperatorSerializeTest {
+
+    @Mock
+    Observer<String> observer;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testSingleThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        w.serialize().subscribe(observer);
+        onSubscribe.waitToFinish();
+
+        verify(observer, times(1)).onNext("one");
+        verify(observer, times(1)).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+    }
+
+    @Test
+    public void testMultiThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        w.serialize().subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        assertEquals(3, busyobserver.onNextCount.get());
+        assertFalse(busyobserver.onError);
+        assertTrue(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPE() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        w.serialize().subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+
+        // we can't know how many onNext calls will occur since they each run on a separate thread
+        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
+        // assertEquals(3, busyobserver.onNextCount.get());
+        assertTrue(busyobserver.onNextCount.get() < 4);
+        assertTrue(busyobserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPEinMiddle() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyobserver = new BusyObserver();
+
+        w.serialize().subscribe(busyobserver);
+        onSubscribe.waitToFinish();
+
+        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+        // this should not be the full number of items since the error should stop it before it completes all 9
+        System.out.println("onNext count: " + busyobserver.onNextCount.get());
+        assertTrue(busyobserver.onNextCount.get() < 9);
+        assertTrue(busyobserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyobserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        // verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyobserver.maxConcurrentThreads.get());
+    }
+
+    /**
+     * A thread that will pass data to onNext
+     */
+    public static class OnNextThread implements Runnable {
+
+        private final Observer<String> observer;
+        private final int numStringsToSend;
+
+        OnNextThread(Observer<String> observer, int numStringsToSend) {
+            this.observer = observer;
+            this.numStringsToSend = numStringsToSend;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < numStringsToSend; i++) {
+                observer.onNext("aString");
+            }
+        }
+    }
+
+    /**
+     * A thread that will call onError or onNext
+     */
+    public static class CompletionThread implements Runnable {
+
+        private final Observer<String> observer;
+        private final TestConcurrencyobserverEvent event;
+        private final Future<?>[] waitOnThese;
+
+        CompletionThread(Observer<String> observer, TestConcurrencyobserverEvent event, Future<?>... waitOnThese) {
+            this.observer = observer;
+            this.event = event;
+            this.waitOnThese = waitOnThese;
+        }
+
+        @Override
+        public void run() {
+            /* if we have 'waitOnThese' futures, we'll wait on them before proceeding */
+            if (waitOnThese != null) {
+                for (Future<?> f : waitOnThese) {
+                    try {
+                        f.get();
+                    } catch (Throwable e) {
+                        System.err.println("Error while waiting on future in CompletionThread");
+                    }
+                }
+            }
+
+            /* send the event */
+            if (event == TestConcurrencyobserverEvent.onError) {
+                observer.onError(new RuntimeException("mocked exception"));
+            } else if (event == TestConcurrencyobserverEvent.onCompleted) {
+                observer.onCompleted();
+
+            } else {
+                throw new IllegalArgumentException("Expecting either onError or onCompleted");
+            }
+        }
+    }
+
+    private static enum TestConcurrencyobserverEvent {
+        onCompleted, onError, onNext
+    }
+
+    private static class TestConcurrencyobserver extends Subscriber<String> {
+
+        /**
+         * used to store the order and number of events received
+         */
+        private final LinkedBlockingQueue<TestConcurrencyobserverEvent> events = new LinkedBlockingQueue<TestConcurrencyobserverEvent>();
+        private final int waitTime;
+
+        @SuppressWarnings("unused")
+        public TestConcurrencyobserver(int waitTimeInNext) {
+            this.waitTime = waitTimeInNext;
+        }
+
+        public TestConcurrencyobserver() {
+            this.waitTime = 0;
+        }
+
+        @Override
+        public void onCompleted() {
+            events.add(TestConcurrencyobserverEvent.onCompleted);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            events.add(TestConcurrencyobserverEvent.onError);
+        }
+
+        @Override
+        public void onNext(String args) {
+            events.add(TestConcurrencyobserverEvent.onNext);
+            // do some artificial work to make the thread scheduling/timing vary
+            int s = 0;
+            for (int i = 0; i < 20; i++) {
+                s += s * i;
+            }
+
+            if (waitTime > 0) {
+                try {
+                    Thread.sleep(waitTime);
+                } catch (InterruptedException e) {
+                    // ignore
+                }
+            }
+        }
+
+        /**
+         * Assert the order of events is correct and return the number of onNext executions.
+         * 
+         * @param expectedEndingEvent
+         * @return int count of onNext calls
+         * @throws IllegalStateException
+         *             If order of events was invalid.
+         */
+        public int assertEvents(TestConcurrencyobserverEvent expectedEndingEvent) throws IllegalStateException {
+            int nextCount = 0;
+            boolean finished = false;
+            for (TestConcurrencyobserverEvent e : events) {
+                if (e == TestConcurrencyobserverEvent.onNext) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onNext but we're already finished.");
+                    }
+                    nextCount++;
+                } else if (e == TestConcurrencyobserverEvent.onError) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onError but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onError != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                } else if (e == TestConcurrencyobserverEvent.onCompleted) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onCompleted but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onCompleted != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                }
+            }
+
+            return nextCount;
+        }
+
+    }
+
+    /**
+     * This spawns a single thread for the subscribe execution
+     */
+    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        private Thread t = null;
+
+        public TestSingleThreadedObservable(final Subscription s, final String... values) {
+            this.s = s;
+            this.values = values;
+
+        }
+
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestSingleThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestSingleThreadedObservable thread");
+                        for (String s : values) {
+                            System.out.println("TestSingleThreadedObservable onNext: " + s);
+                            observer.onNext(s);
+                        }
+                        observer.onCompleted();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+            });
+            System.out.println("starting TestSingleThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestSingleThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+    /**
+     * This spawns a thread for the subscription, then a separate thread for each onNext call.
+     */
+    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        Thread t = null;
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+        ExecutorService threadPool;
+
+        public TestMultiThreadedObservable(Subscription s, String... values) {
+            this.s = s;
+            this.values = values;
+            this.threadPool = Executors.newCachedThreadPool();
+        }
+
+        @Override
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestMultiThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestMultiThreadedObservable thread");
+                        for (final String s : values) {
+                            threadPool.execute(new Runnable() {
+
+                                @Override
+                                public void run() {
+                                    threadsRunning.incrementAndGet();
+                                    try {
+                                        // perform onNext call
+                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
+                                        if (s == null) {
+                                            // force an error
+                                            throw new NullPointerException();
+                                        }
+                                        observer.onNext(s);
+                                        // capture 'maxThreads'
+                                        int concurrentThreads = threadsRunning.get();
+                                        int maxThreads = maxConcurrentThreads.get();
+                                        if (concurrentThreads > maxThreads) {
+                                            maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                                        }
+                                    } catch (Throwable e) {
+                                        observer.onError(e);
+                                    } finally {
+                                        threadsRunning.decrementAndGet();
+                                    }
+                                }
+                            });
+                        }
+                        // we are done spawning threads
+                        threadPool.shutdown();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+
+                    // wait until all threads are done, then mark it as COMPLETED
+                    try {
+                        // wait for all the threads to finish
+                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    observer.onCompleted();
+                }
+            });
+            System.out.println("starting TestMultiThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestMultiThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    private static class BusyObserver extends Subscriber<String> {
+        volatile boolean onCompleted = false;
+        volatile boolean onError = false;
+        AtomicInteger onNextCount = new AtomicInteger();
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+
+        @Override
+        public void onCompleted() {
+            threadsRunning.incrementAndGet();
+
+            System.out.println(">>> Busyobserver received onCompleted");
+            onCompleted = true;
+
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            }
+            threadsRunning.decrementAndGet();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            threadsRunning.incrementAndGet();
+
+            System.out.println(">>> Busyobserver received onError: " + e.getMessage());
+            onError = true;
+
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            }
+            threadsRunning.decrementAndGet();
+        }
+
+        @Override
+        public void onNext(String args) {
+            threadsRunning.incrementAndGet();
+            try {
+                onNextCount.incrementAndGet();
+                System.out.println(">>> Busyobserver received onNext: " + args);
+                try {
+                    // simulate doing something computational
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            } finally {
+                // capture 'maxThreads'
+                int concurrentThreads = threadsRunning.get();
+                int maxThreads = maxConcurrentThreads.get();
+                if (concurrentThreads > maxThreads) {
+                    maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                }
+                threadsRunning.decrementAndGet();
+            }
+        }
+
+    }
+
+    private static class ExternalBusyThread extends Thread {
+
+        private BusyObserver observer;
+        private Object lock;
+        private int lockTimes;
+        private int waitTime;
+        public volatile boolean fail;
+
+        public ExternalBusyThread(BusyObserver observer, Object lock, int lockTimes, int waitTime) {
+            this.observer = observer;
+            this.lock = lock;
+            this.lockTimes = lockTimes;
+            this.waitTime = waitTime;
+            this.fail = false;
+        }
+
+        @Override
+        public void run() {
+            Random r = new Random();
+            for (int i = 0; i < lockTimes; i++) {
+                synchronized (lock) {
+                    int oldOnNextCount = observer.onNextCount.get();
+                    boolean oldOnCompleted = observer.onCompleted;
+                    boolean oldOnError = observer.onError;
+                    try {
+                        Thread.sleep(r.nextInt(waitTime));
+                    } catch (InterruptedException e) {
+                        // ignore
+                    }
+                    // Since we own the lock, onNextCount, onCompleted and
+                    // onError must not be changed.
+                    int newOnNextCount = observer.onNextCount.get();
+                    boolean newOnCompleted = observer.onCompleted;
+                    boolean newOnError = observer.onError;
+                    if (oldOnNextCount != newOnNextCount) {
+                        System.out.println(">>> ExternalBusyThread received different onNextCount: "
+                                + oldOnNextCount
+                                + " -> "
+                                + newOnNextCount);
+                        fail = true;
+                        break;
+                    }
+                    if (oldOnCompleted != newOnCompleted) {
+                        System.out.println(">>> ExternalBusyThread received different onCompleted: "
+                                + oldOnCompleted
+                                + " -> "
+                                + newOnCompleted);
+                        fail = true;
+                        break;
+                    }
+                    if (oldOnError != newOnError) {
+                        System.out.println(">>> ExternalBusyThread received different onError: "
+                                + oldOnError
+                                + " -> "
+                                + newOnError);
+                        fail = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+    }
+}

From 8b3862e679c545bb2185cd0745c1e4cac6ef582a Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Sat, 1 Mar 2014 10:14:57 -0800
Subject: [PATCH 117/422] not quite functional ... and slow

---
 .../java/rx/observers/SerializedObserver.java | 146 ++++++++++--------
 .../OperatorSerializePerformance.java         |   4 +-
 .../perf/java/rx/perf/IntegerSumObserver.java |   1 +
 .../rx/observers/SerializedObserverTest.java  | 115 ++++++++++----
 .../observers/SynchronizedObserverTest.java   |  53 ++++++-
 5 files changed, 218 insertions(+), 101 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index fd4730290f..1652f948ca 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -26,9 +26,8 @@ public void onCompleted() {
             }
             newState = current.complete();
         } while (!state.compareAndSet(current, newState));
-        if (newState.count == 0) {
-            s.onCompleted();
-        }
+        System.out.println("********** onCompleted");
+        terminateIfNecessary(newState);
     }
 
     @Override
@@ -43,9 +42,8 @@ public void onError(Throwable e) {
             }
             newState = current.error(e);
         } while (!state.compareAndSet(current, newState));
-        if (newState.count == 0) {
-            s.onError(e);
-        }
+        System.out.println("********** onError");
+        terminateIfNecessary(newState);
     }
 
     @SuppressWarnings("unchecked")
@@ -59,71 +57,82 @@ public void onNext(T t) {
                 // already received terminal state
                 return;
             }
-            newState = current.increment(t);
+            newState = current.offerItem(t);
         } while (!state.compareAndSet(current, newState));
 
-        if (newState.count == 1) {
+        if (newState.shouldProcess()) {
             // this thread wins and will emit then drain queue if it concurrently gets added to
-            try {
-                s.onNext(t);
-            } finally {
-                // decrement after finishing
-                do {
-                    current = state.get();
-                    newState = current.decrement();
-                } while (!state.compareAndSet(current, newState));
-            }
+            s.onNext(t);
 
             // drain queue if exists
             // we do "if" instead of "while" so we don't starve one thread
-            if (newState.queue.length > 0) {
-                Object[] items = newState.queue;
-                for (int i = 0; i < items.length; i++) {
-                    s.onNext((T) items[i]);
-                }
-                // clear state of queue
-                do {
-                    current = state.get();
-                    newState = current.drain(items.length);
-                } while (!state.compareAndSet(current, newState));
-                terminateIfNecessary(newState);
-            } else {
-                terminateIfNecessary(newState);
+            Object[] items = newState.queue;
+            for (int i = 0; i < items.length; i++) {
+                s.onNext((T) items[i]);
             }
 
+            // finish processing to let this thread move on
+            do {
+                current = state.get();
+                newState = current.finishProcessing(items.length + 1); // the + 1 is for the first onNext of itself
+            } while (!state.compareAndSet(current, newState));
+            System.out.println("********** finishProcessing");
+            terminateIfNecessary(newState);
         }
     }
 
-    private void terminateIfNecessary(State state) {
-        if (state.isTerminated()) {
-            if (state.onComplete) {
-                s.onCompleted();
-            } else {
-                s.onError(state.onError);
+    @SuppressWarnings("unchecked")
+    private void terminateIfNecessary(State current) {
+        if (current.isTerminated()) {
+            State newState = null;
+            do {
+                current = state.get();
+                newState = current.startTermination();
+            } while (!state.compareAndSet(current, newState));
+            if (newState.shouldProcess()) {
+                // drain any items left
+                for (int i = 0; i < newState.queue.length; i++) {
+                    s.onNext((T) newState.queue[i]);
+                }
+
+                // now terminate
+                if (newState.onComplete) {
+                    s.onCompleted();
+                } else {
+                    s.onError(newState.onError);
+                }
             }
         }
     }
 
     public static class State {
-        final int count;
+        final boolean shouldProcess;
+        final boolean isSomeoneProcessing;
+        final int queueSize;
         final Object[] queue;
         final boolean onComplete;
         final Throwable onError;
 
         private final static Object[] EMPTY = new Object[0];
 
-        private final static State NON_TERMINATED_EMPTY = new State(0, false, null, EMPTY);
-        private final static State NON_TERMINATED_SINGLE = new State(1, false, null, EMPTY);
+        private final static State NON_TERMINATED_EMPTY = new State(false, false, 0, false, null, EMPTY);
+        private final static State NON_TERMINATED_PROCESS_SELF = new State(true, true, 1, false, null, EMPTY);
 
-        public State(int count, boolean onComplete, Throwable onError, Object[] queue) {
-            this.count = count;
+        public State(boolean shouldProcess, boolean isSomeoneProcessing, int queueSize, boolean onComplete, Throwable onError, Object[] queue) {
+            this.shouldProcess = shouldProcess;
+            this.isSomeoneProcessing = isSomeoneProcessing;
+            this.queueSize = queueSize;
             this.queue = queue;
             this.onComplete = onComplete;
             this.onError = onError;
         }
 
         public static State createNew() {
-            return new State(0, false, null, EMPTY);
+            return new State(false, false, 0, false, null, EMPTY);
+        }
+
+        public boolean shouldProcess() {
+            return shouldProcess;
         }
 
         public boolean isTerminated() {
@@ -131,53 +140,64 @@ public boolean isTerminated() {
         }
 
         public State complete() {
-            return new State(count, true, onError, queue);
+            return new State(false, isSomeoneProcessing, queueSize, true, onError, queue);
         }
 
         public State error(Throwable e) {
-            return new State(count, onComplete, e, queue);
+            // immediately empty the queue and emit error as soon as possible
+            return new State(false, isSomeoneProcessing, queueSize, onComplete, e, EMPTY);
+        }
+
+        public State startTermination() {
+            if (isSomeoneProcessing) {
+                System.out.println("start terminate and DO NOT process => queue size: " + (queueSize + 1));
+                return new State(false, isSomeoneProcessing, queueSize, onComplete, onError, queue);
+            } else {
+                System.out.println("start terminate and process => queue size: " + (queueSize + 1));
+                return new State(true, isSomeoneProcessing, queueSize, onComplete, onError, queue);
+            }
         }
 
         AtomicInteger max = new AtomicInteger();
 
-        public State increment(Object item) {
-            if (count == 0) {
+        public State offerItem(Object item) {
+            if (queueSize == 0) {
                 // no concurrent requests so don't queue, we'll process immediately
                 if (isTerminated()) {
                     // return count of 0 meaning don't emit as we are terminated
-                    return new State(0, onComplete, onError, EMPTY);
+                    return new State(false, false, 0, onComplete, onError, EMPTY);
                 } else {
-                    return NON_TERMINATED_SINGLE;
+                    return NON_TERMINATED_PROCESS_SELF;
                 }
             } else {
-                // concurrent requests so need to queue
+                // there are items queued so we need to queue
                 int idx = queue.length;
                 Object[] newQueue = new Object[idx + 1];
                 System.arraycopy(queue, 0, newQueue, 0, idx);
                 newQueue[idx] = item;
 
-                if (max.get() < newQueue.length) {
-                    max.set(newQueue.length);
-                    System.out.println("max queue: " + newQueue.length);
+                if (isSomeoneProcessing) {
+                    // we just add to queue
+                    return new State(false, isSomeoneProcessing, queueSize + 1, onComplete, onError, newQueue);
+                } else {
+                    // we add to queue and claim work
+                    return new State(false, true, queueSize + 1, onComplete, onError, newQueue);
                 }
-
-                return new State(count + 1, onComplete, onError, newQueue);
             }
         }
 
-        public State decrement() {
-            if (count > 1 || isTerminated()) {
-                return new State(count - 1, onComplete, onError, queue);
+        public State finishProcessing(int numOnNextSent) {
+            int numOnNextFromQueue = numOnNextSent - 1; // we remove the "self" onNext as it doesn't affect the queue
+            int size = queueSize - numOnNextFromQueue;
+            System.out.println("finishProcessing => queue size: " + size + "   after processing: " + numOnNextSent);
+            if (size > 1 || isTerminated()) {
+                Object[] newQueue = new Object[queue.length - numOnNextFromQueue];
+                System.arraycopy(queue, numOnNextFromQueue, newQueue, 0, newQueue.length);
+                return new State(false, false, size, onComplete, onError, newQueue);
             } else {
                 return NON_TERMINATED_EMPTY;
             }
         }
 
-        public State drain(int c) {
-            Object[] newQueue = new Object[queue.length - c];
-            System.arraycopy(queue, c, newQueue, 0, newQueue.length);
-            return new State(count - c, onComplete, onError, newQueue);
-        }
-
     }
 }
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
index 79596d5733..d33c04c0b3 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
@@ -14,11 +14,11 @@
 import rx.schedulers.Schedulers;
 
 public class OperatorSerializePerformance extends AbstractPerformanceTester {
-    //    static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
+        static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
 
     //    static int reps = Integer.MAX_VALUE / 1024; // timeSingleStream
 
-    static int reps = 1000; // interval streams
+//    static int reps = 1000; // interval streams
 
     OperatorSerializePerformance() {
         super(reps);
diff --git a/rxjava-core/src/perf/java/rx/perf/IntegerSumObserver.java b/rxjava-core/src/perf/java/rx/perf/IntegerSumObserver.java
index 31d10f0cab..28a522fbd8 100644
--- a/rxjava-core/src/perf/java/rx/perf/IntegerSumObserver.java
+++ b/rxjava-core/src/perf/java/rx/perf/IntegerSumObserver.java
@@ -13,6 +13,7 @@ public void onCompleted() {
 
     @Override
     public void onError(Throwable e) {
+        e.printStackTrace();
         throw new RuntimeException(e);
     }
 
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index bbdc17c65f..4c0124bc88 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -19,7 +19,6 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
-import java.util.Random;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
@@ -136,7 +135,13 @@ public void testMultiThreadedWithNPEinMiddle() {
         w.subscribe(aw);
         onSubscribe.waitToFinish();
 
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+        System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyObserver.maxConcurrentThreads.get());
+
         // this should not be the full number of items since the error should stop it before it completes all 9
         System.out.println("onNext count: " + busyObserver.onNextCount.get());
         assertTrue(busyObserver.onNextCount.get() < 9);
@@ -146,11 +151,6 @@ public void testMultiThreadedWithNPEinMiddle() {
         // non-deterministic because unsubscribe happens after 'waitToFinish' releases
         // so commenting out for now as this is not a critical thing to test here
         // verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
     }
 
     /**
@@ -161,7 +161,7 @@ public void testMultiThreadedWithNPEinMiddle() {
      * @param tw
      */
     @Test
-    public void runConcurrencyTest() {
+    public void runOutOfOrderConcurrencyTest() {
         ExecutorService tp = Executors.newFixedThreadPool(20);
         try {
             TestConcurrencyObserver tw = new TestConcurrencyObserver();
@@ -196,7 +196,7 @@ public void runConcurrencyTest() {
             waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10, f11, f12, f13, f14, f15, f16, f17, f18);
             @SuppressWarnings("unused")
             int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
-            // System.out.println("Number of events executed: " + numNextEvents);
+            //            System.out.println("Number of events executed: " + numNextEvents);
         } catch (Throwable e) {
             fail("Concurrency test failed: " + e.getMessage());
             e.printStackTrace();
@@ -210,10 +210,59 @@ public void runConcurrencyTest() {
         }
     }
 
+    /**
+     * 
+     * @param w
+     * @param tw
+     */
+    @Test
+    public void runConcurrencyTest() {
+        ExecutorService tp = Executors.newFixedThreadPool(20);
+        try {
+            TestConcurrencyObserver tw = new TestConcurrencyObserver();
+            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
+            SerializedObserver<String> w = new SerializedObserver<String>(new SafeSubscriber<String>(tw));
+
+            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
+            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
+            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
+            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
+            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
+            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
+            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
+            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
+
+            // 12000 + 5000 + 75000 + 13500 + 22000 + 15000 + 7500 + 23500 = 173500
+
+            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4, f5, f6, f7, f8));
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                // ignore
+            }
+
+            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10);
+            @SuppressWarnings("unused")
+            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
+            assertEquals(173500, numNextEvents);
+            // System.out.println("Number of events executed: " + numNextEvents);
+        } catch (Throwable e) {
+            fail("Concurrency test failed: " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            tp.shutdown();
+            try {
+                tp.awaitTermination(25000, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
     private static void waitOnThreads(Future<?>... futures) {
         for (Future<?> f : futures) {
             try {
-                f.get(10, TimeUnit.SECONDS);
+                f.get(20, TimeUnit.SECONDS);
             } catch (Throwable e) {
                 System.err.println("Failed while waiting on future.");
                 e.printStackTrace();
@@ -521,31 +570,23 @@ private static class BusyObserver extends Subscriber<String> {
         @Override
         public void onCompleted() {
             threadsRunning.incrementAndGet();
-
-            System.out.println(">>> BusyObserver received onCompleted");
-            onCompleted = true;
-
-            int concurrentThreads = threadsRunning.get();
-            int maxThreads = maxConcurrentThreads.get();
-            if (concurrentThreads > maxThreads) {
-                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            try {
+                onCompleted = true;
+            } finally {
+                captureMaxThreads();
+                threadsRunning.decrementAndGet();
             }
-            threadsRunning.decrementAndGet();
         }
 
         @Override
         public void onError(Throwable e) {
             threadsRunning.incrementAndGet();
-
-            System.out.println(">>> BusyObserver received onError: " + e.getMessage());
-            onError = true;
-
-            int concurrentThreads = threadsRunning.get();
-            int maxThreads = maxConcurrentThreads.get();
-            if (concurrentThreads > maxThreads) {
-                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+            try {
+                onError = true;
+            } finally {
+                captureMaxThreads();
+                threadsRunning.decrementAndGet();
             }
-            threadsRunning.decrementAndGet();
         }
 
         @Override
@@ -553,7 +594,6 @@ public void onNext(String args) {
             threadsRunning.incrementAndGet();
             try {
                 onNextCount.incrementAndGet();
-                System.out.println(">>> BusyObserver received onNext: " + args);
                 try {
                     // simulate doing something computational
                     Thread.sleep(200);
@@ -562,14 +602,21 @@ public void onNext(String args) {
                 }
             } finally {
                 // capture 'maxThreads'
-                int concurrentThreads = threadsRunning.get();
-                int maxThreads = maxConcurrentThreads.get();
-                if (concurrentThreads > maxThreads) {
-                    maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-                }
+                captureMaxThreads();
                 threadsRunning.decrementAndGet();
             }
         }
 
+        protected void captureMaxThreads() {
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                if (concurrentThreads > 1) {
+                    new RuntimeException("should not be greater than 1").printStackTrace();
+                }
+            }
+        }
+
     }
 }
diff --git a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
index bdaad282c6..aad021d2e3 100644
--- a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
@@ -288,7 +288,7 @@ public void testMultiThreadedWithNPEinMiddleAndLock() {
      * @param tw
      */
     @Test
-    public void runConcurrencyTest() {
+    public void runOutOfOrderConcurrencyTest() {
         ExecutorService tp = Executors.newFixedThreadPool(20);
         try {
             TestConcurrencyObserver tw = new TestConcurrencyObserver();
@@ -304,7 +304,7 @@ public void runConcurrencyTest() {
             Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
             Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
 
-            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4));
+            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4, f5, f6, f7, f8));
             try {
                 Thread.sleep(1);
             } catch (InterruptedException e) {
@@ -337,6 +337,55 @@ public void runConcurrencyTest() {
         }
     }
 
+    /**
+     * 
+     * @param w
+     * @param tw
+     */
+    @Test
+    public void runConcurrencyTest() {
+        ExecutorService tp = Executors.newFixedThreadPool(20);
+        try {
+            TestConcurrencyObserver tw = new TestConcurrencyObserver();
+            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
+            SynchronizedObserver<String> w = new SynchronizedObserver<String>(new SafeSubscriber<String>(tw));
+
+            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
+            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
+            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
+            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
+            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
+            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
+            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
+            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
+
+            // 12000 + 5000 + 75000 + 13500 + 22000 + 15000 + 7500 + 23500 = 173500
+
+            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4));
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                // ignore
+            }
+
+            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10);
+            @SuppressWarnings("unused")
+            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
+            assertEquals(173500, numNextEvents);
+            // System.out.println("Number of events executed: " + numNextEvents);
+        } catch (Throwable e) {
+            fail("Concurrency test failed: " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            tp.shutdown();
+            try {
+                tp.awaitTermination(5000, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
     private static void waitOnThreads(Future<?>... futures) {
         for (Future<?> f : futures) {
             try {

From cc3c6546583e9a0d6d8463f5054ade172e28ffd2 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 11 Mar 2014 13:56:31 -0700
Subject: [PATCH 118/422] Functional now ... it seems.

---
 .../java/rx/observers/SerializedObserver.java | 97 +++++++++++--------
 .../OperatorSerializePerformance.java         |  2 +-
 .../OperatorSynchronizePerformance.java       |  6 +-
 .../rx/observers/SerializedObserverTest.java  | 22 +++--
 4 files changed, 76 insertions(+), 51 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 1652f948ca..462f38f1ff 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -1,5 +1,8 @@
 package rx.observers;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -14,6 +17,11 @@ public SerializedObserver(Observer<T> s) {
         this.s = s;
     }
 
+    final AtomicInteger received = new AtomicInteger();
+    final AtomicInteger counter = new AtomicInteger();
+    final AtomicInteger offered = new AtomicInteger();
+    static AtomicInteger decremented = new AtomicInteger();
+
     @Override
     public void onCompleted() {
         State current = null;
@@ -26,7 +34,6 @@ public void onCompleted() {
             }
             newState = current.complete();
         } while (!state.compareAndSet(current, newState));
-        System.out.println("********** onCompleted");
         terminateIfNecessary(newState);
     }
 
@@ -42,43 +49,54 @@ public void onError(Throwable e) {
             }
             newState = current.error(e);
         } while (!state.compareAndSet(current, newState));
-        System.out.println("********** onError");
         terminateIfNecessary(newState);
     }
 
+    AtomicInteger conc = new AtomicInteger();
+    AtomicInteger lost = new AtomicInteger();
+    Set<Object> items = Collections.synchronizedSet(new HashSet<Object>());
+
     @SuppressWarnings("unchecked")
     @Override
     public void onNext(T t) {
         State current = null;
         State newState = null;
+
+        int contention = 0;
+        State orig = null;
         do {
             current = state.get();
+            if (orig == null) {
+                orig = current;
+            }
             if (current.isTerminated()) {
                 // already received terminal state
                 return;
             }
             newState = current.offerItem(t);
+            contention++;
         } while (!state.compareAndSet(current, newState));
 
+        do {
+            current = state.get();
+            newState = current.startProcessing();
+        } while (!state.compareAndSet(current, newState));
         if (newState.shouldProcess()) {
-            // this thread wins and will emit then drain queue if it concurrently gets added to
-            s.onNext(t);
-
-            // drain queue if exists
-            // we do "if" instead of "while" so we don't starve one thread
+            // drain queue 
             Object[] items = newState.queue;
             for (int i = 0; i < items.length; i++) {
                 s.onNext((T) items[i]);
+                counter.incrementAndGet();
             }
 
             // finish processing to let this thread move on
             do {
                 current = state.get();
-                newState = current.finishProcessing(items.length + 1); // the + 1 is for the first onNext of itself
+                newState = current.finishProcessing(items.length);
             } while (!state.compareAndSet(current, newState));
-            System.out.println("********** finishProcessing");
-            terminateIfNecessary(newState);
+
         }
+        terminateIfNecessary(newState);
     }
 
     @SuppressWarnings("unchecked")
@@ -89,6 +107,7 @@ private void terminateIfNecessary(State current) {
                 current = state.get();
                 newState = current.startTermination();
             } while (!state.compareAndSet(current, newState));
+
             if (newState.shouldProcess()) {
                 // drain any items left
                 for (int i = 0; i < newState.queue.length; i++) {
@@ -114,9 +133,9 @@ public static class State {
         final Throwable onError;
 
         private final static Object[] EMPTY = new Object[0];
+        private final static Object[] PROCESS_SELF = new Object[1];
 
         private final static State NON_TERMINATED_EMPTY = new State(false, false, 0, false, null, EMPTY);
-        private final static State NON_TERMINATED_PROCESS_SELF = new State(true, true, 1, false, null, EMPTY);
 
         public State(boolean shouldProcess, boolean isSomeoneProcessing, int queueSize, boolean onComplete, Throwable onError, Object[] queue) {
             this.shouldProcess = shouldProcess;
@@ -145,59 +164,59 @@ public State complete() {
 
         public State error(Throwable e) {
             // immediately empty the queue and emit error as soon as possible
-            return new State(false, isSomeoneProcessing, queueSize, onComplete, e, EMPTY);
+            return new State(false, isSomeoneProcessing, 0, onComplete, e, EMPTY);
         }
 
         public State startTermination() {
             if (isSomeoneProcessing) {
-                System.out.println("start terminate and DO NOT process => queue size: " + (queueSize + 1));
                 return new State(false, isSomeoneProcessing, queueSize, onComplete, onError, queue);
             } else {
-                System.out.println("start terminate and process => queue size: " + (queueSize + 1));
-                return new State(true, isSomeoneProcessing, queueSize, onComplete, onError, queue);
+                return new State(true, true, queueSize, onComplete, onError, queue);
             }
         }
 
-        AtomicInteger max = new AtomicInteger();
-
         public State offerItem(Object item) {
-            if (queueSize == 0) {
-                // no concurrent requests so don't queue, we'll process immediately
-                if (isTerminated()) {
-                    // return count of 0 meaning don't emit as we are terminated
-                    return new State(false, false, 0, onComplete, onError, EMPTY);
-                } else {
-                    return NON_TERMINATED_PROCESS_SELF;
-                }
+            if (isTerminated()) {
+                // return count of 0 meaning don't emit as we are terminated
+                return new State(false, isSomeoneProcessing, 0, onComplete, onError, EMPTY);
             } else {
-                // there are items queued so we need to queue
                 int idx = queue.length;
                 Object[] newQueue = new Object[idx + 1];
                 System.arraycopy(queue, 0, newQueue, 0, idx);
                 newQueue[idx] = item;
 
-                if (isSomeoneProcessing) {
-                    // we just add to queue
-                    return new State(false, isSomeoneProcessing, queueSize + 1, onComplete, onError, newQueue);
-                } else {
-                    // we add to queue and claim work
-                    return new State(false, true, queueSize + 1, onComplete, onError, newQueue);
-                }
+                // we just add to queue
+                return new State(false, isSomeoneProcessing, queueSize + 1, onComplete, onError, newQueue);
+            }
+        }
+
+        public State startProcessing() {
+            if (isSomeoneProcessing) {
+                return new State(false, true, queueSize, onComplete, onError, queue);
+            } else {
+                return new State(true, true, queueSize, onComplete, onError, queue);
             }
         }
 
         public State finishProcessing(int numOnNextSent) {
-            int numOnNextFromQueue = numOnNextSent - 1; // we remove the "self" onNext as it doesn't affect the queue
-            int size = queueSize - numOnNextFromQueue;
-            System.out.println("finishProcessing => queue size: " + size + "   after processing: " + numOnNextSent);
-            if (size > 1 || isTerminated()) {
-                Object[] newQueue = new Object[queue.length - numOnNextFromQueue];
-                System.arraycopy(queue, numOnNextFromQueue, newQueue, 0, newQueue.length);
+            int size = queueSize - numOnNextSent;
+            if (size > 0 || isTerminated()) {
+                // if size == 0 but we are terminated then it's an empty queue
+                Object[] newQueue = EMPTY;
+                if (size > 0) {
+                    newQueue = new Object[queue.length - numOnNextSent];
+                    System.arraycopy(queue, numOnNextSent, newQueue, 0, newQueue.length);
+                }
                 return new State(false, false, size, onComplete, onError, newQueue);
             } else {
                 return NON_TERMINATED_EMPTY;
             }
         }
 
+        @Override
+        public String toString() {
+            return "State => shouldProcess: " + shouldProcess + " processing: " + isSomeoneProcessing + " queueSize: " + queueSize + " queue: " + queue.length + " terminated: " + isTerminated();
+        }
+
     }
 }
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
index d33c04c0b3..e46f983d32 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
@@ -147,7 +147,7 @@ public void call(Integer t1) {
 
         IntegerSumObserver o = new IntegerSumObserver();
         s.subscribe(o);
-        System.out.println("sum : " + o.sum);
+//        System.out.println("sum : " + o.sum);
 
         return o.sum;
     }
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
index fdd3ced3d3..a7396693fb 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
@@ -14,9 +14,9 @@
 import rx.schedulers.Schedulers;
 
 public class OperatorSynchronizePerformance extends AbstractPerformanceTester {
-    //    static int reps = Integer.MAX_VALUE / 1024;
+    static int reps = Integer.MAX_VALUE / 1024;
 
-    static int reps = 1000; // timeTwoStreamsIntervals
+    //    static int reps = 1000; // timeTwoStreamsIntervals
 
     OperatorSynchronizePerformance() {
         super(reps);
@@ -30,7 +30,7 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    spt.timeTwoStreamsIntervals();
+                    spt.timeTwoStreams();
                 }
             });
         } catch (Exception e) {
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index 4c0124bc88..07cd117c14 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -19,6 +19,7 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
@@ -92,8 +93,8 @@ public void testMultiThreadedBasic() {
         assertEquals(1, busyObserver.maxConcurrentThreads.get());
     }
 
-    @Test
-    public void testMultiThreadedWithNPE() {
+    @Test(timeout=1000)
+    public void testMultiThreadedWithNPE() throws InterruptedException {
         Subscription s = mock(Subscription.class);
         TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
         Observable<String> w = Observable.create(onSubscribe);
@@ -103,8 +104,9 @@ public void testMultiThreadedWithNPE() {
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
+        busyObserver.terminalEvent.await();
 
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
+        System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
 
         // we can't know how many onNext calls will occur since they each run on a separate thread
         // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
@@ -286,7 +288,7 @@ public static class OnNextThread implements Runnable {
         @Override
         public void run() {
             for (int i = 0; i < numStringsToSend; i++) {
-                Observer.onNext("aString");
+                Observer.onNext(Thread.currentThread().getId() + "-" + i);
             }
         }
     }
@@ -296,12 +298,12 @@ public void run() {
      */
     public static class CompletionThread implements Runnable {
 
-        private final Observer<String> Observer;
+        private final Observer<String> observer;
         private final TestConcurrencyObserverEvent event;
         private final Future<?>[] waitOnThese;
 
         CompletionThread(Observer<String> Observer, TestConcurrencyObserverEvent event, Future<?>... waitOnThese) {
-            this.Observer = Observer;
+            this.observer = Observer;
             this.event = event;
             this.waitOnThese = waitOnThese;
         }
@@ -321,9 +323,9 @@ public void run() {
 
             /* send the event */
             if (event == TestConcurrencyObserverEvent.onError) {
-                Observer.onError(new RuntimeException("mocked exception"));
+                observer.onError(new RuntimeException("mocked exception"));
             } else if (event == TestConcurrencyObserverEvent.onCompleted) {
-                Observer.onCompleted();
+                observer.onCompleted();
 
             } else {
                 throw new IllegalArgumentException("Expecting either onError or onCompleted");
@@ -566,6 +568,7 @@ private static class BusyObserver extends Subscriber<String> {
         AtomicInteger onNextCount = new AtomicInteger();
         AtomicInteger threadsRunning = new AtomicInteger();
         AtomicInteger maxConcurrentThreads = new AtomicInteger();
+        final CountDownLatch terminalEvent = new CountDownLatch(1);
 
         @Override
         public void onCompleted() {
@@ -575,17 +578,20 @@ public void onCompleted() {
             } finally {
                 captureMaxThreads();
                 threadsRunning.decrementAndGet();
+                terminalEvent.countDown();
             }
         }
 
         @Override
         public void onError(Throwable e) {
+            System.out.println(">>>>>>>>>>>>>>>>>>>> onError received: " + e);
             threadsRunning.incrementAndGet();
             try {
                 onError = true;
             } finally {
                 captureMaxThreads();
                 threadsRunning.decrementAndGet();
+                terminalEvent.countDown();
             }
         }
 

From 423b470372103725405e03c2784b4812bac949c4 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 11 Mar 2014 16:10:26 -0700
Subject: [PATCH 119/422] Migrate Merge from Synchronize to Serialize

---
 .../src/main/java/rx/observers/SerializedObserver.java        | 4 ++--
 .../src/main/java/rx/observers/SerializedSubscriber.java      | 2 +-
 rxjava-core/src/main/java/rx/operators/OperatorMerge.java     | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 462f38f1ff..72a0f9969e 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -11,9 +11,9 @@
 public class SerializedObserver<T> implements Observer<T> {
 
     private final AtomicReference<State> state = new AtomicReference<State>(State.createNew());
-    private final Observer<T> s;
+    private final Observer<? super T> s;
 
-    public SerializedObserver(Observer<T> s) {
+    public SerializedObserver(Observer<? super T> s) {
         this.s = s;
     }
 
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
index 377cef9d74..2d674f4cd9 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
@@ -7,7 +7,7 @@ public class SerializedSubscriber<T> extends Subscriber<T> {
 
     private final Observer<T> s;
 
-    public SerializedSubscriber(Subscriber<T> s) {
+    public SerializedSubscriber(Subscriber<? super T> s) {
         this.s = new SerializedObserver<T>(s);
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
index 5b51485224..b3d822ca84 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
@@ -20,7 +20,7 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.observers.SynchronizedSubscriber;
+import rx.observers.SerializedSubscriber;
 import rx.subscriptions.CompositeSubscription;
 
 /**
@@ -36,7 +36,7 @@ public final class OperatorMerge<T> implements Operator<T, Observable<? extends
     @Override
     public Subscriber<Observable<? extends T>> call(final Subscriber<? super T> outerOperation) {
 
-        final Subscriber<T> o = new SynchronizedSubscriber<T>(outerOperation);
+        final Subscriber<T> o = new SerializedSubscriber<T>(outerOperation);
         final CompositeSubscription childrenSubscriptions = new CompositeSubscription();
         outerOperation.add(childrenSubscriptions);
 

From 34a2561f9010bf81506da54ead6858e77ab5de40 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 12 Mar 2014 09:41:21 -0700
Subject: [PATCH 120/422] Experimenting with different implementations and
 performance

---
 .../java/rx/observers/SerializedObserver.java | 236 ++++--------------
 .../SerializedObserverViaStateMachine.java    | 215 ++++++++++++++++
 .../rx/observers/SerializedSubscriber.java    |   2 +-
 .../OperatorSerializePerformance.java         |  45 +++-
 ...SerializedObserverViaStateMachineTest.java |   5 +
 5 files changed, 300 insertions(+), 203 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
 create mode 100644 rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 72a0f9969e..ae5cdf1a0e 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -1,222 +1,70 @@
 package rx.observers;
 
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observer;
 
 public class SerializedObserver<T> implements Observer<T> {
+    private final Observer<? super T> actual;
+    private final AtomicInteger count = new AtomicInteger();
+    private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
 
-    private final AtomicReference<State> state = new AtomicReference<State>(State.createNew());
-    private final Observer<? super T> s;
+    private static Sentinel NULL_SENTINEL = new Sentinel();
+    private static Sentinel COMPLETE_SENTINEL = new Sentinel();
 
-    public SerializedObserver(Observer<? super T> s) {
-        this.s = s;
+    private static class Sentinel {
+
+    }
+
+    private static class ErrorSentinel extends Sentinel {
+        final Throwable e;
+
+        ErrorSentinel(Throwable e) {
+            this.e = e;
+        }
     }
 
-    final AtomicInteger received = new AtomicInteger();
-    final AtomicInteger counter = new AtomicInteger();
-    final AtomicInteger offered = new AtomicInteger();
-    static AtomicInteger decremented = new AtomicInteger();
+    public SerializedObserver(Observer<? super T> s) {
+        this.actual = s;
+    }
 
     @Override
     public void onCompleted() {
-        State current = null;
-        State newState = null;
-        do {
-            current = state.get();
-            if (current.isTerminated()) {
-                // already received terminal state
-                return;
-            }
-            newState = current.complete();
-        } while (!state.compareAndSet(current, newState));
-        terminateIfNecessary(newState);
+        queue.add(COMPLETE_SENTINEL);
+        doIt();
     }
 
     @Override
-    public void onError(Throwable e) {
-        State current = null;
-        State newState = null;
-        do {
-            current = state.get();
-            if (current.isTerminated()) {
-                // already received terminal state
-                return;
-            }
-            newState = current.error(e);
-        } while (!state.compareAndSet(current, newState));
-        terminateIfNecessary(newState);
+    public void onError(final Throwable e) {
+        queue.add(new ErrorSentinel(e));
+        doIt();
     }
 
-    AtomicInteger conc = new AtomicInteger();
-    AtomicInteger lost = new AtomicInteger();
-    Set<Object> items = Collections.synchronizedSet(new HashSet<Object>());
-
-    @SuppressWarnings("unchecked")
     @Override
     public void onNext(T t) {
-        State current = null;
-        State newState = null;
-
-        int contention = 0;
-        State orig = null;
-        do {
-            current = state.get();
-            if (orig == null) {
-                orig = current;
-            }
-            if (current.isTerminated()) {
-                // already received terminal state
-                return;
-            }
-            newState = current.offerItem(t);
-            contention++;
-        } while (!state.compareAndSet(current, newState));
-
-        do {
-            current = state.get();
-            newState = current.startProcessing();
-        } while (!state.compareAndSet(current, newState));
-        if (newState.shouldProcess()) {
-            // drain queue 
-            Object[] items = newState.queue;
-            for (int i = 0; i < items.length; i++) {
-                s.onNext((T) items[i]);
-                counter.incrementAndGet();
-            }
-
-            // finish processing to let this thread move on
-            do {
-                current = state.get();
-                newState = current.finishProcessing(items.length);
-            } while (!state.compareAndSet(current, newState));
-
-        }
-        terminateIfNecessary(newState);
+        queue.add(t);
+        doIt();
     }
 
-    @SuppressWarnings("unchecked")
-    private void terminateIfNecessary(State current) {
-        if (current.isTerminated()) {
-            State newState = null;
+    public void doIt() {
+        if (count.getAndIncrement() == 0) {
             do {
-                current = state.get();
-                newState = current.startTermination();
-            } while (!state.compareAndSet(current, newState));
-
-            if (newState.shouldProcess()) {
-                // drain any items left
-                for (int i = 0; i < newState.queue.length; i++) {
-                    s.onNext((T) newState.queue[i]);
-                }
-
-                // now terminate
-                if (newState.onComplete) {
-                    s.onCompleted();
-                } else {
-                    s.onError(newState.onError);
+                Object v = queue.poll();
+                if (v != null) {
+                    if (v instanceof Sentinel) {
+                        if (v == NULL_SENTINEL) {
+                            actual.onNext(null);
+                        } else if (v == COMPLETE_SENTINEL) {
+                            actual.onCompleted();
+                        } else if (v instanceof ErrorSentinel) {
+                            actual.onError(((ErrorSentinel) v).e);
+                        }
+                    } else {
+                        actual.onNext((T) v);
+                    }
                 }
-            }
-        }
-    }
-
-    public static class State {
-        final boolean shouldProcess;
-        final boolean isSomeoneProcessing;
-        final int queueSize;
-        final Object[] queue;
-        final boolean onComplete;
-        final Throwable onError;
-
-        private final static Object[] EMPTY = new Object[0];
-        private final static Object[] PROCESS_SELF = new Object[1];
-
-        private final static State NON_TERMINATED_EMPTY = new State(false, false, 0, false, null, EMPTY);
-
-        public State(boolean shouldProcess, boolean isSomeoneProcessing, int queueSize, boolean onComplete, Throwable onError, Object[] queue) {
-            this.shouldProcess = shouldProcess;
-            this.isSomeoneProcessing = isSomeoneProcessing;
-            this.queueSize = queueSize;
-            this.queue = queue;
-            this.onComplete = onComplete;
-            this.onError = onError;
+            } while (count.decrementAndGet() > 0);
         }
-
-        public static State createNew() {
-            return new State(false, false, 0, false, null, EMPTY);
-        }
-
-        public boolean shouldProcess() {
-            return shouldProcess;
-        }
-
-        public boolean isTerminated() {
-            return onComplete || onError != null;
-        }
-
-        public State complete() {
-            return new State(false, isSomeoneProcessing, queueSize, true, onError, queue);
-        }
-
-        public State error(Throwable e) {
-            // immediately empty the queue and emit error as soon as possible
-            return new State(false, isSomeoneProcessing, 0, onComplete, e, EMPTY);
-        }
-
-        public State startTermination() {
-            if (isSomeoneProcessing) {
-                return new State(false, isSomeoneProcessing, queueSize, onComplete, onError, queue);
-            } else {
-                return new State(true, true, queueSize, onComplete, onError, queue);
-            }
-        }
-
-        public State offerItem(Object item) {
-            if (isTerminated()) {
-                // return count of 0 meaning don't emit as we are terminated
-                return new State(false, isSomeoneProcessing, 0, onComplete, onError, EMPTY);
-            } else {
-                int idx = queue.length;
-                Object[] newQueue = new Object[idx + 1];
-                System.arraycopy(queue, 0, newQueue, 0, idx);
-                newQueue[idx] = item;
-
-                // we just add to queue
-                return new State(false, isSomeoneProcessing, queueSize + 1, onComplete, onError, newQueue);
-            }
-        }
-
-        public State startProcessing() {
-            if (isSomeoneProcessing) {
-                return new State(false, true, queueSize, onComplete, onError, queue);
-            } else {
-                return new State(true, true, queueSize, onComplete, onError, queue);
-            }
-        }
-
-        public State finishProcessing(int numOnNextSent) {
-            int size = queueSize - numOnNextSent;
-            if (size > 0 || isTerminated()) {
-                // if size == 0 but we are terminated then it's an empty queue
-                Object[] newQueue = EMPTY;
-                if (size > 0) {
-                    newQueue = new Object[queue.length - numOnNextSent];
-                    System.arraycopy(queue, numOnNextSent, newQueue, 0, newQueue.length);
-                }
-                return new State(false, false, size, onComplete, onError, newQueue);
-            } else {
-                return NON_TERMINATED_EMPTY;
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "State => shouldProcess: " + shouldProcess + " processing: " + isSomeoneProcessing + " queueSize: " + queueSize + " queue: " + queue.length + " terminated: " + isTerminated();
-        }
-
     }
 }
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
new file mode 100644
index 0000000000..fdd6e844ad
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
@@ -0,0 +1,215 @@
+package rx.observers;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Observer;
+
+public class SerializedObserverViaStateMachine<T> implements Observer<T> {
+
+    private final AtomicReference<State> state = new AtomicReference<State>(State.createNew());
+    private final Observer<? super T> s;
+
+    public SerializedObserverViaStateMachine(Observer<? super T> s) {
+        this.s = s;
+    }
+
+    @Override
+    public void onCompleted() {
+        State current = null;
+        State newState = null;
+        do {
+            current = state.get();
+            if (current.isTerminated()) {
+                // already received terminal state
+                return;
+            }
+            newState = current.complete();
+        } while (!state.compareAndSet(current, newState));
+        terminateIfNecessary(newState);
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        State current = null;
+        State newState = null;
+        do {
+            current = state.get();
+            if (current.isTerminated()) {
+                // already received terminal state
+                return;
+            }
+            newState = current.error(e);
+        } while (!state.compareAndSet(current, newState));
+        terminateIfNecessary(newState);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void onNext(T t) {
+        State current = null;
+        State newState = null;
+
+        State orig = null;
+        do {
+            current = state.get();
+            if (orig == null) {
+                orig = current;
+            }
+            if (current.isTerminated()) {
+                // already received terminal state
+                return;
+            }
+            newState = current.offerItem(t);
+        } while (!state.compareAndSet(current, newState));
+
+        if (newState.shouldProcess()) {
+            if (newState == State.PROCESS_SELF) {
+                s.onNext(t);
+
+                // finish processing to let this thread move on
+                do {
+                    current = state.get();
+                    newState = current.finishProcessing(1);
+                } while (!state.compareAndSet(current, newState));
+            } else {
+                // drain queue 
+                Object[] items = newState.queue;
+                for (int i = 0; i < items.length; i++) {
+                    s.onNext((T) items[i]);
+                }
+
+                // finish processing to let this thread move on
+                do {
+                    current = state.get();
+                    newState = current.finishProcessing(items.length);
+                } while (!state.compareAndSet(current, newState));
+            }
+        }
+        terminateIfNecessary(newState);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void terminateIfNecessary(State current) {
+        if (current.isTerminated()) {
+            State newState = null;
+            do {
+                current = state.get();
+                newState = current.startTermination();
+            } while (!state.compareAndSet(current, newState));
+
+            if (newState.shouldProcess()) {
+                // drain any items left
+                for (int i = 0; i < newState.queue.length; i++) {
+                    s.onNext((T) newState.queue[i]);
+                }
+
+                // now terminate
+                if (newState.onComplete) {
+                    s.onCompleted();
+                } else {
+                    s.onError(newState.onError);
+                }
+            }
+        }
+    }
+
+    public static class State {
+        final boolean shouldProcess;
+        final boolean isSomeoneProcessing;
+        final int queueSize;
+        final Object[] queue;
+        final boolean onComplete;
+        final Throwable onError;
+
+        private final static Object[] EMPTY = new Object[0];
+        private final static Object[] PROCESS_SELF_QUEUE = new Object[1];
+
+        private final static State NON_TERMINATED_EMPTY = new State(false, false, 0, false, null, EMPTY);
+        private final static State PROCESS_SELF = new State(true, true, 1, false, null, PROCESS_SELF_QUEUE);
+
+        public State(boolean shouldProcess, boolean isSomeoneProcessing, int queueSize, boolean onComplete, Throwable onError, Object[] queue) {
+            this.shouldProcess = shouldProcess;
+            this.isSomeoneProcessing = isSomeoneProcessing;
+            this.queueSize = queueSize;
+            this.queue = queue;
+            this.onComplete = onComplete;
+            this.onError = onError;
+        }
+
+        public static State createNew() {
+            return new State(false, false, 0, false, null, EMPTY);
+        }
+
+        public boolean shouldProcess() {
+            return shouldProcess;
+        }
+
+        public boolean isTerminated() {
+            return onComplete || onError != null;
+        }
+
+        public State complete() {
+            return new State(false, isSomeoneProcessing, queueSize, true, onError, queue);
+        }
+
+        public State error(Throwable e) {
+            // immediately empty the queue and emit error as soon as possible
+            return new State(false, isSomeoneProcessing, 0, onComplete, e, EMPTY);
+        }
+
+        public State startTermination() {
+            if (isSomeoneProcessing) {
+                return new State(false, isSomeoneProcessing, queueSize, onComplete, onError, queue);
+            } else {
+                return new State(true, true, queueSize, onComplete, onError, queue);
+            }
+        }
+
+        public State offerItem(Object item) {
+            if (queueSize == 0) {
+                if (isTerminated()) {
+                    // return count of 0 meaning don't emit as we are terminated
+                    return new State(false, isSomeoneProcessing, 0, onComplete, onError, EMPTY);
+                } else {
+                    // no concurrent requests so don't queue, we'll process immediately
+                    return PROCESS_SELF;
+                }
+            } else {
+                // there are items queued so we need to queue
+                int idx = queue.length;
+                Object[] newQueue = new Object[idx + 1];
+                System.arraycopy(queue, 0, newQueue, 0, idx);
+                newQueue[idx] = item;
+
+                if (isSomeoneProcessing) {
+                    // we just add to queue
+                    return new State(false, true, queueSize + 1, onComplete, onError, newQueue);
+                } else {
+                    // we add to queue and claim work
+                    return new State(true, true, queueSize + 1, onComplete, onError, newQueue);
+                }
+            }
+        }
+
+        public State finishProcessing(int numOnNextSent) {
+            int size = queueSize - numOnNextSent;
+            if (size > 0 || isTerminated()) {
+                // if size == 0 but we are terminated then it's an empty queue
+                Object[] newQueue = EMPTY;
+                if (size > 0) {
+                    newQueue = new Object[queue.length - numOnNextSent];
+                    System.arraycopy(queue, numOnNextSent, newQueue, 0, newQueue.length);
+                }
+                return new State(false, false, size, onComplete, onError, newQueue);
+            } else {
+                return NON_TERMINATED_EMPTY;
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "State => shouldProcess: " + shouldProcess + " processing: " + isSomeoneProcessing + " queueSize: " + queueSize + " queue: " + queue.length + " terminated: " + isTerminated();
+        }
+
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
index 2d674f4cd9..0eecc1e24e 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
@@ -8,7 +8,7 @@ public class SerializedSubscriber<T> extends Subscriber<T> {
     private final Observer<T> s;
 
     public SerializedSubscriber(Subscriber<? super T> s) {
-        this.s = new SerializedObserver<T>(s);
+        this.s = new SerializedObserverViaStateMachine<T>(s);
     }
 
     @Override
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
index e46f983d32..3bebb580c0 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
@@ -14,11 +14,11 @@
 import rx.schedulers.Schedulers;
 
 public class OperatorSerializePerformance extends AbstractPerformanceTester {
-        static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
+    static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
 
     //    static int reps = Integer.MAX_VALUE / 1024; // timeSingleStream
 
-//    static int reps = 1000; // interval streams
+    //    static int reps = 1000; // interval streams
 
     OperatorSerializePerformance() {
         super(reps);
@@ -33,6 +33,7 @@ public static void main(String args[]) {
                 @Override
                 public void call() {
                     spt.timeTwoStreams();
+                    //                    spt.timeSingleStream();
                 }
             });
         } catch (Exception e) {
@@ -42,11 +43,22 @@ public void call() {
     }
 
     /**
-     * Run: 10 - 36,891,795 ops/sec
-     * Run: 11 - 29,854,808 ops/sec
-     * Run: 12 - 36,162,140 ops/sec
-     * Run: 13 - 35,727,201 ops/sec
-     * Run: 14 - 34,897,262 ops/sec
+     * 
+     * -> state machine technique
+     * 
+     * Run: 10 - 34,668,810 ops/sec
+     * Run: 11 - 32,874,312 ops/sec
+     * Run: 12 - 33,389,339 ops/sec
+     * Run: 13 - 35,269,946 ops/sec
+     * Run: 14 - 34,165,013 ops/sec
+     * 
+     * -> using "observeOn" technique
+     * 
+     * Run: 10 - 19,548,387 ops/sec
+     * Run: 11 - 19,471,069 ops/sec
+     * Run: 12 - 19,480,112 ops/sec
+     * Run: 13 - 18,720,550 ops/sec
+     * Run: 14 - 19,070,383 ops/sec
      */
     public long timeSingleStream() {
 
@@ -91,6 +103,23 @@ public void call(Integer t1) {
         return o.sum;
     }
 
+    /**
+     * -> state machine technique
+     * 
+     * Run: 10 - 3,432,256 ops/sec
+     * Run: 11 - 3,570,444 ops/sec
+     * Run: 12 - 3,791,137 ops/sec
+     * Run: 13 - 3,664,579 ops/sec
+     * Run: 14 - 5,211,156 ops/sec
+     * 
+     * -> using "observeOn" technique
+     * 
+     * Run: 10 - 3,995,336 ops/sec
+     * Run: 11 - 4,033,077 ops/sec
+     * Run: 12 - 4,510,978 ops/sec
+     * Run: 13 - 3,218,915 ops/sec
+     * Run: 14 - 3,938,549 ops/sec
+     */
     public long timeTwoStreams() {
 
         final Observable<Integer> s1 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
@@ -147,7 +176,7 @@ public void call(Integer t1) {
 
         IntegerSumObserver o = new IntegerSumObserver();
         s.subscribe(o);
-//        System.out.println("sum : " + o.sum);
+        //        System.out.println("sum : " + o.sum);
 
         return o.sum;
     }
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
new file mode 100644
index 0000000000..491c3d8657
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
@@ -0,0 +1,5 @@
+package rx.observers;
+
+public class SerializedObserverViaStateMachineTest extends SerializedObserverTest {
+
+}

From 2136f8f73175f193fd5fdd124d140b544a0f3ba3 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 12 Mar 2014 09:42:35 -0700
Subject: [PATCH 121/422] Clarify names during testing

---
 ...a => SerializedObserverViaQueueAndCounter.java} |  4 ++--
 ... SerializedObserverViaQueueAndCounterTest.java} | 14 +++++++-------
 .../SerializedObserverViaStateMachineTest.java     |  2 +-
 3 files changed, 10 insertions(+), 10 deletions(-)
 rename rxjava-core/src/main/java/rx/observers/{SerializedObserver.java => SerializedObserverViaQueueAndCounter.java} (92%)
 rename rxjava-core/src/test/java/rx/observers/{SerializedObserverTest.java => SerializedObserverViaQueueAndCounterTest.java} (96%)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
similarity index 92%
rename from rxjava-core/src/main/java/rx/observers/SerializedObserver.java
rename to rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
index ae5cdf1a0e..60e62d429d 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
@@ -5,7 +5,7 @@
 
 import rx.Observer;
 
-public class SerializedObserver<T> implements Observer<T> {
+public class SerializedObserverViaQueueAndCounter<T> implements Observer<T> {
     private final Observer<? super T> actual;
     private final AtomicInteger count = new AtomicInteger();
     private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
@@ -25,7 +25,7 @@ private static class ErrorSentinel extends Sentinel {
         }
     }
 
-    public SerializedObserver(Observer<? super T> s) {
+    public SerializedObserverViaQueueAndCounter(Observer<? super T> s) {
         this.actual = s;
     }
 
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
similarity index 96%
rename from rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
rename to rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
index 07cd117c14..7734245321 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
@@ -37,7 +37,7 @@
 import rx.Subscriber;
 import rx.Subscription;
 
-public class SerializedObserverTest {
+public class SerializedObserverViaQueueAndCounterTest {
 
     @Mock
     Subscriber<String> observer;
@@ -53,7 +53,7 @@ public void testSingleThreadedBasic() {
         TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
         Observable<String> w = Observable.create(onSubscribe);
 
-        SerializedObserver<String> aw = new SerializedObserver<String>(observer);
+        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(observer);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -75,7 +75,7 @@ public void testMultiThreadedBasic() {
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyObserver = new BusyObserver();
-        SerializedObserver<String> aw = new SerializedObserver<String>(busyObserver);
+        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(busyObserver);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -100,7 +100,7 @@ public void testMultiThreadedWithNPE() throws InterruptedException {
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyObserver = new BusyObserver();
-        SerializedObserver<String> aw = new SerializedObserver<String>(busyObserver);
+        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(busyObserver);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -132,7 +132,7 @@ public void testMultiThreadedWithNPEinMiddle() {
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyObserver = new BusyObserver();
-        SerializedObserver<String> aw = new SerializedObserver<String>(busyObserver);
+        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(busyObserver);
 
         w.subscribe(aw);
         onSubscribe.waitToFinish();
@@ -168,7 +168,7 @@ public void runOutOfOrderConcurrencyTest() {
         try {
             TestConcurrencyObserver tw = new TestConcurrencyObserver();
             // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
-            SerializedObserver<String> w = new SerializedObserver<String>(new SafeSubscriber<String>(tw));
+            SerializedObserverViaQueueAndCounter<String> w = new SerializedObserverViaQueueAndCounter<String>(new SafeSubscriber<String>(tw));
 
             Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
             Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
@@ -223,7 +223,7 @@ public void runConcurrencyTest() {
         try {
             TestConcurrencyObserver tw = new TestConcurrencyObserver();
             // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
-            SerializedObserver<String> w = new SerializedObserver<String>(new SafeSubscriber<String>(tw));
+            SerializedObserverViaQueueAndCounter<String> w = new SerializedObserverViaQueueAndCounter<String>(new SafeSubscriber<String>(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/observers/SerializedObserverViaStateMachineTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
index 491c3d8657..18fb4ce4aa 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
@@ -1,5 +1,5 @@
 package rx.observers;
 
-public class SerializedObserverViaStateMachineTest extends SerializedObserverTest {
+public class SerializedObserverViaStateMachineTest extends SerializedObserverViaQueueAndCounterTest {
 
 }

From 7c16c51c345dcf41f7f0c232c048e2b0d9c528a4 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 12 Mar 2014 09:50:11 -0700
Subject: [PATCH 122/422] Unit tests for each

---
 .../rx/observers/SerializedObserverTest.java  | 630 ++++++++++++++++++
 ...ializedObserverViaQueueAndCounterTest.java | 611 +----------------
 ...SerializedObserverViaStateMachineTest.java |   7 +-
 3 files changed, 640 insertions(+), 608 deletions(-)
 create mode 100644 rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java

diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
new file mode 100644
index 0000000000..9b7656be29
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -0,0 +1,630 @@
+/**
+ * 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.observers;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+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.Subscriber;
+import rx.Subscription;
+
+public abstract class SerializedObserverTest {
+
+    @Mock
+    Subscriber<String> observer;
+
+    @Before
+    public void before() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    protected abstract Observer<String> serializedObserver(Observer<String> o);
+
+    @Test
+    public void testSingleThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        Observer<String> aw = serializedObserver(observer);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+
+        verify(observer, times(1)).onNext("one");
+        verify(observer, times(1)).onNext("two");
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+    }
+
+    @Test
+    public void testMultiThreadedBasic() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyObserver = new BusyObserver();
+        Observer<String> aw = serializedObserver(busyObserver);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+
+        assertEquals(3, busyObserver.onNextCount.get());
+        assertFalse(busyObserver.onError);
+        assertTrue(busyObserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //            verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyObserver.maxConcurrentThreads.get());
+    }
+
+    @Test(timeout = 1000)
+    public void testMultiThreadedWithNPE() throws InterruptedException {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyObserver = new BusyObserver();
+        Observer<String> aw = serializedObserver(busyObserver);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+        busyObserver.terminalEvent.await();
+
+        System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
+
+        // we can't know how many onNext calls will occur since they each run on a separate thread
+        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
+        // assertEquals(3, busyObserver.onNextCount.get());
+        assertTrue(busyObserver.onNextCount.get() < 4);
+        assertTrue(busyObserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyObserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        //verify(s, times(1)).unsubscribe();
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyObserver.maxConcurrentThreads.get());
+    }
+
+    @Test
+    public void testMultiThreadedWithNPEinMiddle() {
+        Subscription s = mock(Subscription.class);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
+        Observable<String> w = Observable.create(onSubscribe);
+
+        BusyObserver busyObserver = new BusyObserver();
+        Observer<String> aw = serializedObserver(busyObserver);
+
+        w.subscribe(aw);
+        onSubscribe.waitToFinish();
+
+        System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
+
+        // we can have concurrency ...
+        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+        // ... but the onNext execution should be single threaded
+        assertEquals(1, busyObserver.maxConcurrentThreads.get());
+
+        // this should not be the full number of items since the error should stop it before it completes all 9
+        System.out.println("onNext count: " + busyObserver.onNextCount.get());
+        assertTrue(busyObserver.onNextCount.get() < 9);
+        assertTrue(busyObserver.onError);
+        // no onCompleted because onError was invoked
+        assertFalse(busyObserver.onCompleted);
+        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+        // so commenting out for now as this is not a critical thing to test here
+        // verify(s, times(1)).unsubscribe();
+    }
+
+    /**
+     * A non-realistic use case that tries to expose thread-safety issues by throwing lots of out-of-order
+     * events on many threads.
+     * 
+     * @param w
+     * @param tw
+     */
+    @Test
+    public void runOutOfOrderConcurrencyTest() {
+        ExecutorService tp = Executors.newFixedThreadPool(20);
+        try {
+            TestConcurrencyObserver tw = new TestConcurrencyObserver();
+            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
+            Observer<String> w = serializedObserver(new SafeSubscriber<String>(tw));
+
+            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
+            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
+            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
+            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
+            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
+            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
+            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
+            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
+
+            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4));
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                // ignore
+            }
+            Future<?> f11 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            Future<?> f12 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            Future<?> f13 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            Future<?> f14 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
+            // // the next 4 onError events should wait on same as f10
+            Future<?> f15 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+            Future<?> f16 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+            Future<?> f17 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+            Future<?> f18 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
+
+            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10, f11, f12, f13, f14, f15, f16, f17, f18);
+            @SuppressWarnings("unused")
+            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
+            //            System.out.println("Number of events executed: " + numNextEvents);
+        } catch (Throwable e) {
+            fail("Concurrency test failed: " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            tp.shutdown();
+            try {
+                tp.awaitTermination(5000, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * 
+     * @param w
+     * @param tw
+     */
+    @Test
+    public void runConcurrencyTest() {
+        ExecutorService tp = Executors.newFixedThreadPool(20);
+        try {
+            TestConcurrencyObserver tw = new TestConcurrencyObserver();
+            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
+            Observer<String> w = serializedObserver(new SafeSubscriber<String>(tw));
+
+            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
+            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
+            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
+            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
+            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
+            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
+            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
+            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
+
+            // 12000 + 5000 + 75000 + 13500 + 22000 + 15000 + 7500 + 23500 = 173500
+
+            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4, f5, f6, f7, f8));
+            try {
+                Thread.sleep(1);
+            } catch (InterruptedException e) {
+                // ignore
+            }
+
+            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10);
+            @SuppressWarnings("unused")
+            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
+            assertEquals(173500, numNextEvents);
+            // System.out.println("Number of events executed: " + numNextEvents);
+        } catch (Throwable e) {
+            fail("Concurrency test failed: " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            tp.shutdown();
+            try {
+                tp.awaitTermination(25000, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private static void waitOnThreads(Future<?>... futures) {
+        for (Future<?> f : futures) {
+            try {
+                f.get(20, TimeUnit.SECONDS);
+            } catch (Throwable e) {
+                System.err.println("Failed while waiting on future.");
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * A thread that will pass data to onNext
+     */
+    public static class OnNextThread implements Runnable {
+
+        private final Observer<String> Observer;
+        private final int numStringsToSend;
+
+        OnNextThread(Observer<String> Observer, int numStringsToSend) {
+            this.Observer = Observer;
+            this.numStringsToSend = numStringsToSend;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < numStringsToSend; i++) {
+                Observer.onNext(Thread.currentThread().getId() + "-" + i);
+            }
+        }
+    }
+
+    /**
+     * A thread that will call onError or onNext
+     */
+    public static class CompletionThread implements Runnable {
+
+        private final Observer<String> observer;
+        private final TestConcurrencyObserverEvent event;
+        private final Future<?>[] waitOnThese;
+
+        CompletionThread(Observer<String> Observer, TestConcurrencyObserverEvent event, Future<?>... waitOnThese) {
+            this.observer = Observer;
+            this.event = event;
+            this.waitOnThese = waitOnThese;
+        }
+
+        @Override
+        public void run() {
+            /* if we have 'waitOnThese' futures, we'll wait on them before proceeding */
+            if (waitOnThese != null) {
+                for (Future<?> f : waitOnThese) {
+                    try {
+                        f.get();
+                    } catch (Throwable e) {
+                        System.err.println("Error while waiting on future in CompletionThread");
+                    }
+                }
+            }
+
+            /* send the event */
+            if (event == TestConcurrencyObserverEvent.onError) {
+                observer.onError(new RuntimeException("mocked exception"));
+            } else if (event == TestConcurrencyObserverEvent.onCompleted) {
+                observer.onCompleted();
+
+            } else {
+                throw new IllegalArgumentException("Expecting either onError or onCompleted");
+            }
+        }
+    }
+
+    private static enum TestConcurrencyObserverEvent {
+        onCompleted, onError, onNext
+    }
+
+    private static class TestConcurrencyObserver extends Subscriber<String> {
+
+        /**
+         * used to store the order and number of events received
+         */
+        private final LinkedBlockingQueue<TestConcurrencyObserverEvent> events = new LinkedBlockingQueue<TestConcurrencyObserverEvent>();
+        private final int waitTime;
+
+        @SuppressWarnings("unused")
+        public TestConcurrencyObserver(int waitTimeInNext) {
+            this.waitTime = waitTimeInNext;
+        }
+
+        public TestConcurrencyObserver() {
+            this.waitTime = 0;
+        }
+
+        @Override
+        public void onCompleted() {
+            events.add(TestConcurrencyObserverEvent.onCompleted);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            events.add(TestConcurrencyObserverEvent.onError);
+        }
+
+        @Override
+        public void onNext(String args) {
+            events.add(TestConcurrencyObserverEvent.onNext);
+            // do some artificial work to make the thread scheduling/timing vary
+            int s = 0;
+            for (int i = 0; i < 20; i++) {
+                s += s * i;
+            }
+
+            if (waitTime > 0) {
+                try {
+                    Thread.sleep(waitTime);
+                } catch (InterruptedException e) {
+                    // ignore
+                }
+            }
+        }
+
+        /**
+         * Assert the order of events is correct and return the number of onNext executions.
+         * 
+         * @param expectedEndingEvent
+         * @return int count of onNext calls
+         * @throws IllegalStateException
+         *             If order of events was invalid.
+         */
+        public int assertEvents(TestConcurrencyObserverEvent expectedEndingEvent) throws IllegalStateException {
+            int nextCount = 0;
+            boolean finished = false;
+            for (TestConcurrencyObserverEvent e : events) {
+                if (e == TestConcurrencyObserverEvent.onNext) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onNext but we're already finished.");
+                    }
+                    nextCount++;
+                } else if (e == TestConcurrencyObserverEvent.onError) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onError but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onError != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                } else if (e == TestConcurrencyObserverEvent.onCompleted) {
+                    if (finished) {
+                        // already finished, we shouldn't get this again
+                        throw new IllegalStateException("Received onCompleted but we're already finished.");
+                    }
+                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onCompleted != expectedEndingEvent) {
+                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
+                    }
+                    finished = true;
+                }
+            }
+
+            return nextCount;
+        }
+
+    }
+
+    /**
+     * This spawns a single thread for the subscribe execution
+     */
+    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        private Thread t = null;
+
+        public TestSingleThreadedObservable(final Subscription s, final String... values) {
+            this.s = s;
+            this.values = values;
+
+        }
+
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestSingleThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestSingleThreadedObservable thread");
+                        for (String s : values) {
+                            System.out.println("TestSingleThreadedObservable onNext: " + s);
+                            observer.onNext(s);
+                        }
+                        observer.onCompleted();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+            });
+            System.out.println("starting TestSingleThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestSingleThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+    /**
+     * This spawns a thread for the subscription, then a separate thread for each onNext call.
+     */
+    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
+
+        final Subscription s;
+        final String[] values;
+        Thread t = null;
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+        ExecutorService threadPool;
+
+        public TestMultiThreadedObservable(Subscription s, String... values) {
+            this.s = s;
+            this.values = values;
+            this.threadPool = Executors.newCachedThreadPool();
+        }
+
+        @Override
+        public Subscription onSubscribe(final Observer<? super String> observer) {
+            System.out.println("TestMultiThreadedObservable subscribed to ...");
+            t = new Thread(new Runnable() {
+
+                @Override
+                public void run() {
+                    try {
+                        System.out.println("running TestMultiThreadedObservable thread");
+                        for (final String s : values) {
+                            threadPool.execute(new Runnable() {
+
+                                @Override
+                                public void run() {
+                                    threadsRunning.incrementAndGet();
+                                    try {
+                                        // perform onNext call
+                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
+                                        if (s == null) {
+                                            // force an error
+                                            throw new NullPointerException();
+                                        }
+                                        observer.onNext(s);
+                                        // capture 'maxThreads'
+                                        int concurrentThreads = threadsRunning.get();
+                                        int maxThreads = maxConcurrentThreads.get();
+                                        if (concurrentThreads > maxThreads) {
+                                            maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                                        }
+                                    } catch (Throwable e) {
+                                        observer.onError(e);
+                                    } finally {
+                                        threadsRunning.decrementAndGet();
+                                    }
+                                }
+                            });
+                        }
+                        // we are done spawning threads
+                        threadPool.shutdown();
+                    } catch (Throwable e) {
+                        throw new RuntimeException(e);
+                    }
+
+                    // wait until all threads are done, then mark it as COMPLETED
+                    try {
+                        // wait for all the threads to finish
+                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    observer.onCompleted();
+                }
+            });
+            System.out.println("starting TestMultiThreadedObservable thread");
+            t.start();
+            System.out.println("done starting TestMultiThreadedObservable thread");
+            return s;
+        }
+
+        public void waitToFinish() {
+            try {
+                t.join();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    private static class BusyObserver extends Subscriber<String> {
+        volatile boolean onCompleted = false;
+        volatile boolean onError = false;
+        AtomicInteger onNextCount = new AtomicInteger();
+        AtomicInteger threadsRunning = new AtomicInteger();
+        AtomicInteger maxConcurrentThreads = new AtomicInteger();
+        final CountDownLatch terminalEvent = new CountDownLatch(1);
+
+        @Override
+        public void onCompleted() {
+            threadsRunning.incrementAndGet();
+            try {
+                onCompleted = true;
+            } finally {
+                captureMaxThreads();
+                threadsRunning.decrementAndGet();
+                terminalEvent.countDown();
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            System.out.println(">>>>>>>>>>>>>>>>>>>> onError received: " + e);
+            threadsRunning.incrementAndGet();
+            try {
+                onError = true;
+            } finally {
+                captureMaxThreads();
+                threadsRunning.decrementAndGet();
+                terminalEvent.countDown();
+            }
+        }
+
+        @Override
+        public void onNext(String args) {
+            threadsRunning.incrementAndGet();
+            try {
+                onNextCount.incrementAndGet();
+                try {
+                    // simulate doing something computational
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            } finally {
+                // capture 'maxThreads'
+                captureMaxThreads();
+                threadsRunning.decrementAndGet();
+            }
+        }
+
+        protected void captureMaxThreads() {
+            int concurrentThreads = threadsRunning.get();
+            int maxThreads = maxConcurrentThreads.get();
+            if (concurrentThreads > maxThreads) {
+                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
+                if (concurrentThreads > 1) {
+                    new RuntimeException("should not be greater than 1").printStackTrace();
+                }
+            }
+        }
+
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
index 7734245321..2e3f49ec7a 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
@@ -15,614 +15,11 @@
  */
 package rx.observers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
-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.Subscriber;
-import rx.Subscription;
-
-public class SerializedObserverViaQueueAndCounterTest {
-
-    @Mock
-    Subscriber<String> observer;
-
-    @Before
-    public void before() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void testSingleThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(observer);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        verify(observer, times(1)).onNext("one");
-        verify(observer, times(1)).onNext("two");
-        verify(observer, times(1)).onNext("three");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-    }
-
-    @Test
-    public void testMultiThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(busyObserver);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        assertEquals(3, busyObserver.onNextCount.get());
-        assertFalse(busyObserver.onError);
-        assertTrue(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    @Test(timeout=1000)
-    public void testMultiThreadedWithNPE() throws InterruptedException {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(busyObserver);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-        busyObserver.terminalEvent.await();
-
-        System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
-
-        // we can't know how many onNext calls will occur since they each run on a separate thread
-        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
-        // assertEquals(3, busyObserver.onNextCount.get());
-        assertTrue(busyObserver.onNextCount.get() < 4);
-        assertTrue(busyObserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPEinMiddle() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-        SerializedObserverViaQueueAndCounter<String> aw = new SerializedObserverViaQueueAndCounter<String>(busyObserver);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-
-        // this should not be the full number of items since the error should stop it before it completes all 9
-        System.out.println("onNext count: " + busyObserver.onNextCount.get());
-        assertTrue(busyObserver.onNextCount.get() < 9);
-        assertTrue(busyObserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        // verify(s, times(1)).unsubscribe();
-    }
-
-    /**
-     * A non-realistic use case that tries to expose thread-safety issues by throwing lots of out-of-order
-     * events on many threads.
-     * 
-     * @param w
-     * @param tw
-     */
-    @Test
-    public void runOutOfOrderConcurrencyTest() {
-        ExecutorService tp = Executors.newFixedThreadPool(20);
-        try {
-            TestConcurrencyObserver tw = new TestConcurrencyObserver();
-            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
-            SerializedObserverViaQueueAndCounter<String> w = new SerializedObserverViaQueueAndCounter<String>(new SafeSubscriber<String>(tw));
-
-            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
-            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
-            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
-            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
-            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
-            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
-            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
-            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
-
-            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4));
-            try {
-                Thread.sleep(1);
-            } catch (InterruptedException e) {
-                // ignore
-            }
-            Future<?> f11 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            Future<?> f12 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            Future<?> f13 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            Future<?> f14 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            // // the next 4 onError events should wait on same as f10
-            Future<?> f15 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-            Future<?> f16 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-            Future<?> f17 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-            Future<?> f18 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-
-            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10, f11, f12, f13, f14, f15, f16, f17, f18);
-            @SuppressWarnings("unused")
-            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
-            //            System.out.println("Number of events executed: " + numNextEvents);
-        } catch (Throwable e) {
-            fail("Concurrency test failed: " + e.getMessage());
-            e.printStackTrace();
-        } finally {
-            tp.shutdown();
-            try {
-                tp.awaitTermination(5000, TimeUnit.MILLISECONDS);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    /**
-     * 
-     * @param w
-     * @param tw
-     */
-    @Test
-    public void runConcurrencyTest() {
-        ExecutorService tp = Executors.newFixedThreadPool(20);
-        try {
-            TestConcurrencyObserver tw = new TestConcurrencyObserver();
-            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
-            SerializedObserverViaQueueAndCounter<String> w = new SerializedObserverViaQueueAndCounter<String>(new SafeSubscriber<String>(tw));
-
-            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
-            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
-            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
-            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
-            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
-            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
-            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
-            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
-
-            // 12000 + 5000 + 75000 + 13500 + 22000 + 15000 + 7500 + 23500 = 173500
-
-            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4, f5, f6, f7, f8));
-            try {
-                Thread.sleep(1);
-            } catch (InterruptedException e) {
-                // ignore
-            }
-
-            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10);
-            @SuppressWarnings("unused")
-            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
-            assertEquals(173500, numNextEvents);
-            // System.out.println("Number of events executed: " + numNextEvents);
-        } catch (Throwable e) {
-            fail("Concurrency test failed: " + e.getMessage());
-            e.printStackTrace();
-        } finally {
-            tp.shutdown();
-            try {
-                tp.awaitTermination(25000, TimeUnit.MILLISECONDS);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private static void waitOnThreads(Future<?>... futures) {
-        for (Future<?> f : futures) {
-            try {
-                f.get(20, TimeUnit.SECONDS);
-            } catch (Throwable e) {
-                System.err.println("Failed while waiting on future.");
-                e.printStackTrace();
-            }
-        }
-    }
-
-    /**
-     * A thread that will pass data to onNext
-     */
-    public static class OnNextThread implements Runnable {
-
-        private final Observer<String> Observer;
-        private final int numStringsToSend;
-
-        OnNextThread(Observer<String> Observer, int numStringsToSend) {
-            this.Observer = Observer;
-            this.numStringsToSend = numStringsToSend;
-        }
-
-        @Override
-        public void run() {
-            for (int i = 0; i < numStringsToSend; i++) {
-                Observer.onNext(Thread.currentThread().getId() + "-" + i);
-            }
-        }
-    }
-
-    /**
-     * A thread that will call onError or onNext
-     */
-    public static class CompletionThread implements Runnable {
-
-        private final Observer<String> observer;
-        private final TestConcurrencyObserverEvent event;
-        private final Future<?>[] waitOnThese;
-
-        CompletionThread(Observer<String> Observer, TestConcurrencyObserverEvent event, Future<?>... waitOnThese) {
-            this.observer = Observer;
-            this.event = event;
-            this.waitOnThese = waitOnThese;
-        }
-
-        @Override
-        public void run() {
-            /* if we have 'waitOnThese' futures, we'll wait on them before proceeding */
-            if (waitOnThese != null) {
-                for (Future<?> f : waitOnThese) {
-                    try {
-                        f.get();
-                    } catch (Throwable e) {
-                        System.err.println("Error while waiting on future in CompletionThread");
-                    }
-                }
-            }
-
-            /* send the event */
-            if (event == TestConcurrencyObserverEvent.onError) {
-                observer.onError(new RuntimeException("mocked exception"));
-            } else if (event == TestConcurrencyObserverEvent.onCompleted) {
-                observer.onCompleted();
-
-            } else {
-                throw new IllegalArgumentException("Expecting either onError or onCompleted");
-            }
-        }
-    }
-
-    private static enum TestConcurrencyObserverEvent {
-        onCompleted, onError, onNext
-    }
-
-    private static class TestConcurrencyObserver extends Subscriber<String> {
-
-        /**
-         * used to store the order and number of events received
-         */
-        private final LinkedBlockingQueue<TestConcurrencyObserverEvent> events = new LinkedBlockingQueue<TestConcurrencyObserverEvent>();
-        private final int waitTime;
-
-        @SuppressWarnings("unused")
-        public TestConcurrencyObserver(int waitTimeInNext) {
-            this.waitTime = waitTimeInNext;
-        }
-
-        public TestConcurrencyObserver() {
-            this.waitTime = 0;
-        }
-
-        @Override
-        public void onCompleted() {
-            events.add(TestConcurrencyObserverEvent.onCompleted);
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            events.add(TestConcurrencyObserverEvent.onError);
-        }
-
-        @Override
-        public void onNext(String args) {
-            events.add(TestConcurrencyObserverEvent.onNext);
-            // do some artificial work to make the thread scheduling/timing vary
-            int s = 0;
-            for (int i = 0; i < 20; i++) {
-                s += s * i;
-            }
-
-            if (waitTime > 0) {
-                try {
-                    Thread.sleep(waitTime);
-                } catch (InterruptedException e) {
-                    // ignore
-                }
-            }
-        }
-
-        /**
-         * Assert the order of events is correct and return the number of onNext executions.
-         * 
-         * @param expectedEndingEvent
-         * @return int count of onNext calls
-         * @throws IllegalStateException
-         *             If order of events was invalid.
-         */
-        public int assertEvents(TestConcurrencyObserverEvent expectedEndingEvent) throws IllegalStateException {
-            int nextCount = 0;
-            boolean finished = false;
-            for (TestConcurrencyObserverEvent e : events) {
-                if (e == TestConcurrencyObserverEvent.onNext) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onNext but we're already finished.");
-                    }
-                    nextCount++;
-                } else if (e == TestConcurrencyObserverEvent.onError) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onError but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onError != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                } else if (e == TestConcurrencyObserverEvent.onCompleted) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onCompleted but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onCompleted != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                }
-            }
-
-            return nextCount;
-        }
-
-    }
-
-    /**
-     * This spawns a single thread for the subscribe execution
-     */
-    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
-
-        final Subscription s;
-        final String[] values;
-        private Thread t = null;
-
-        public TestSingleThreadedObservable(final Subscription s, final String... values) {
-            this.s = s;
-            this.values = values;
-
-        }
-
-        public Subscription onSubscribe(final Observer<? super String> observer) {
-            System.out.println("TestSingleThreadedObservable subscribed to ...");
-            t = new Thread(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        System.out.println("running TestSingleThreadedObservable thread");
-                        for (String s : values) {
-                            System.out.println("TestSingleThreadedObservable onNext: " + s);
-                            observer.onNext(s);
-                        }
-                        observer.onCompleted();
-                    } catch (Throwable e) {
-                        throw new RuntimeException(e);
-                    }
-                }
-
-            });
-            System.out.println("starting TestSingleThreadedObservable thread");
-            t.start();
-            System.out.println("done starting TestSingleThreadedObservable thread");
-            return s;
-        }
-
-        public void waitToFinish() {
-            try {
-                t.join();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-    }
-
-    /**
-     * This spawns a thread for the subscription, then a separate thread for each onNext call.
-     */
-    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
-
-        final Subscription s;
-        final String[] values;
-        Thread t = null;
-        AtomicInteger threadsRunning = new AtomicInteger();
-        AtomicInteger maxConcurrentThreads = new AtomicInteger();
-        ExecutorService threadPool;
-
-        public TestMultiThreadedObservable(Subscription s, String... values) {
-            this.s = s;
-            this.values = values;
-            this.threadPool = Executors.newCachedThreadPool();
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
-            System.out.println("TestMultiThreadedObservable subscribed to ...");
-            t = new Thread(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        System.out.println("running TestMultiThreadedObservable thread");
-                        for (final String s : values) {
-                            threadPool.execute(new Runnable() {
-
-                                @Override
-                                public void run() {
-                                    threadsRunning.incrementAndGet();
-                                    try {
-                                        // perform onNext call
-                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
-                                        if (s == null) {
-                                            // force an error
-                                            throw new NullPointerException();
-                                        }
-                                        observer.onNext(s);
-                                        // capture 'maxThreads'
-                                        int concurrentThreads = threadsRunning.get();
-                                        int maxThreads = maxConcurrentThreads.get();
-                                        if (concurrentThreads > maxThreads) {
-                                            maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-                                        }
-                                    } catch (Throwable e) {
-                                        observer.onError(e);
-                                    } finally {
-                                        threadsRunning.decrementAndGet();
-                                    }
-                                }
-                            });
-                        }
-                        // we are done spawning threads
-                        threadPool.shutdown();
-                    } catch (Throwable e) {
-                        throw new RuntimeException(e);
-                    }
-
-                    // wait until all threads are done, then mark it as COMPLETED
-                    try {
-                        // wait for all the threads to finish
-                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
-                    } catch (InterruptedException e) {
-                        throw new RuntimeException(e);
-                    }
-                    observer.onCompleted();
-                }
-            });
-            System.out.println("starting TestMultiThreadedObservable thread");
-            t.start();
-            System.out.println("done starting TestMultiThreadedObservable thread");
-            return s;
-        }
-
-        public void waitToFinish() {
-            try {
-                t.join();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-
-    private static class BusyObserver extends Subscriber<String> {
-        volatile boolean onCompleted = false;
-        volatile boolean onError = false;
-        AtomicInteger onNextCount = new AtomicInteger();
-        AtomicInteger threadsRunning = new AtomicInteger();
-        AtomicInteger maxConcurrentThreads = new AtomicInteger();
-        final CountDownLatch terminalEvent = new CountDownLatch(1);
-
-        @Override
-        public void onCompleted() {
-            threadsRunning.incrementAndGet();
-            try {
-                onCompleted = true;
-            } finally {
-                captureMaxThreads();
-                threadsRunning.decrementAndGet();
-                terminalEvent.countDown();
-            }
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            System.out.println(">>>>>>>>>>>>>>>>>>>> onError received: " + e);
-            threadsRunning.incrementAndGet();
-            try {
-                onError = true;
-            } finally {
-                captureMaxThreads();
-                threadsRunning.decrementAndGet();
-                terminalEvent.countDown();
-            }
-        }
-
-        @Override
-        public void onNext(String args) {
-            threadsRunning.incrementAndGet();
-            try {
-                onNextCount.incrementAndGet();
-                try {
-                    // simulate doing something computational
-                    Thread.sleep(200);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-            } finally {
-                // capture 'maxThreads'
-                captureMaxThreads();
-                threadsRunning.decrementAndGet();
-            }
-        }
-
-        protected void captureMaxThreads() {
-            int concurrentThreads = threadsRunning.get();
-            int maxThreads = maxConcurrentThreads.get();
-            if (concurrentThreads > maxThreads) {
-                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-                if (concurrentThreads > 1) {
-                    new RuntimeException("should not be greater than 1").printStackTrace();
-                }
-            }
-        }
 
+public class SerializedObserverViaQueueAndCounterTest extends SerializedObserverTest {
+    @Override
+    protected Observer<String> serializedObserver(Observer<String> o) {
+        return new SerializedObserverViaQueueAndCounter<String>(o);
     }
 }
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
index 18fb4ce4aa..76582d06e0 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
@@ -1,5 +1,10 @@
 package rx.observers;
 
-public class SerializedObserverViaStateMachineTest extends SerializedObserverViaQueueAndCounterTest {
+import rx.Observer;
 
+public class SerializedObserverViaStateMachineTest extends SerializedObserverTest {
+    @Override
+    protected Observer<String> serializedObserver(Observer<String> o) {
+        return new SerializedObserverViaStateMachine<String>(o);
+    }
 }

From b6096079c17488b1232f7db942c529c7eb5f9843 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 12 Mar 2014 11:43:37 -0700
Subject: [PATCH 123/422] Unlock in finally block

---
 .../SerializedObserverViaStateMachine.java    | 29 +++++++++----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
index fdd6e844ad..14c9612e07 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
@@ -63,25 +63,24 @@ public void onNext(T t) {
         } while (!state.compareAndSet(current, newState));
 
         if (newState.shouldProcess()) {
-            if (newState == State.PROCESS_SELF) {
-                s.onNext(t);
-
-                // finish processing to let this thread move on
-                do {
-                    current = state.get();
-                    newState = current.finishProcessing(1);
-                } while (!state.compareAndSet(current, newState));
-            } else {
-                // drain queue 
-                Object[] items = newState.queue;
-                for (int i = 0; i < items.length; i++) {
-                    s.onNext((T) items[i]);
+            int numItemsProcessed = 0;
+            try {
+                if (newState == State.PROCESS_SELF) {
+                    s.onNext(t);
+                    numItemsProcessed++;
+                } else {
+                    // drain queue 
+                    Object[] items = newState.queue;
+                    for (int i = 0; i < items.length; i++) {
+                        s.onNext((T) items[i]);
+                        numItemsProcessed++;
+                    }
                 }
-
+            } finally {
                 // finish processing to let this thread move on
                 do {
                     current = state.get();
-                    newState = current.finishProcessing(items.length);
+                    newState = current.finishProcessing(numItemsProcessed);
                 } while (!state.compareAndSet(current, newState));
             }
         }

From c1037968b91ee4b90c5846d3c8c9b68e42fb7442 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 12 Mar 2014 14:06:55 -0700
Subject: [PATCH 124/422] queue and lock implementation

---
 .../SerializedObserverViaQueueAndLock.java    | 174 ++++++++++++++++++
 .../rx/observers/SerializedSubscriber.java    |   2 +-
 .../OperatorSerializePerformance.java         |  26 ++-
 ...SerializedObserverViaQueueAndLockTest.java |  11 ++
 4 files changed, 207 insertions(+), 6 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
 create mode 100644 rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
new file mode 100644
index 0000000000..5e999d38fd
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
@@ -0,0 +1,174 @@
+package rx.observers;
+
+import java.util.ArrayList;
+
+import rx.Observer;
+
+public class SerializedObserverViaQueueAndLock<T> implements Observer<T> {
+    private final Observer<? super T> actual;
+
+    private boolean emitting = false;
+    private boolean terminated = false;
+    private ArrayList<Object> queue = new ArrayList<Object>();
+
+    private static Sentinel NULL_SENTINEL = new Sentinel();
+    private static Sentinel COMPLETE_SENTINEL = new Sentinel();
+
+    private static class Sentinel {
+
+    }
+
+    private static class ErrorSentinel extends Sentinel {
+        final Throwable e;
+
+        ErrorSentinel(Throwable e) {
+            this.e = e;
+        }
+    }
+
+    public SerializedObserverViaQueueAndLock(Observer<? super T> s) {
+        this.actual = s;
+    }
+
+    @Override
+    public void onCompleted() {
+        boolean canEmit = false;
+        ArrayList<Object> list = null;
+        synchronized (this) {
+            if (terminated) {
+                return;
+            }
+            terminated = true;
+            if (!emitting) {
+                // emit immediately
+                emitting = true;
+                canEmit = true;
+                if (queue.size() > 0) {
+                    list = queue; // copy reference
+                    queue = new ArrayList<Object>(); // new version;
+                }
+            } else {
+                // someone else is already emitting so just queue it
+                queue.add(COMPLETE_SENTINEL);
+            }
+        }
+        if (canEmit) {
+            // we won the right to emit
+            try {
+                drainQueue(list);
+                actual.onCompleted();
+            } finally {
+                synchronized (this) {
+                    emitting = false;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onError(final Throwable e) {
+        boolean canEmit = false;
+        ArrayList<Object> list = null;
+        synchronized (this) {
+            if (terminated) {
+                return;
+            }
+            terminated = true;
+            if (!emitting) {
+                // emit immediately
+                emitting = true;
+                canEmit = true;
+                if (queue.size() > 0) {
+                    list = queue; // copy reference
+                    queue = new ArrayList<Object>(); // new version;
+                }
+            } else {
+                // someone else is already emitting so just queue it ... after eliminating the queue to shortcut
+                queue.clear();
+                queue.add(new ErrorSentinel(e));
+            }
+        }
+        if (canEmit) {
+            // we won the right to emit
+            try {
+                drainQueue(list);
+                actual.onError(e);
+            } finally {
+                synchronized (this) {
+                    emitting = false;
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onNext(T t) {
+        boolean canEmit = false;
+        ArrayList<Object> list = null;
+        synchronized (this) {
+            if (terminated) {
+                return;
+            }
+            if (!emitting) {
+                // emit immediately
+                emitting = true;
+                canEmit = true;
+                if (queue.size() > 0) {
+                    list = queue; // copy reference
+                    queue = new ArrayList<Object>(); // new version;
+                }
+            } else {
+                // someone else is already emitting so just queue it
+                if (t == null) {
+                    queue.add(NULL_SENTINEL);
+                } else {
+                    queue.add(t);
+                }
+            }
+        }
+        if (canEmit) {
+            // we won the right to emit
+            try {
+                drainQueue(list);
+                actual.onNext(t);
+            } finally {
+                synchronized (this) {
+                    if (terminated) {
+                        list = queue; // copy reference
+                        queue = new ArrayList<Object>(); // new version;
+                    } else {
+                        // release this thread
+                        emitting = false;
+                        canEmit = false;
+                    }
+                }
+            }
+        }
+
+        // if terminated this will still be true so let's drain the rest of the queue
+        if (canEmit) {
+            drainQueue(list);
+        }
+    }
+
+    public void drainQueue(ArrayList<Object> list) {
+        if (list == null || list.size() == 0) {
+            return;
+        }
+        for (Object v : list) {
+            if (v != null) {
+                if (v instanceof Sentinel) {
+                    if (v == NULL_SENTINEL) {
+                        actual.onNext(null);
+                    } else if (v == COMPLETE_SENTINEL) {
+                        actual.onCompleted();
+                    } else if (v instanceof ErrorSentinel) {
+                        actual.onError(((ErrorSentinel) v).e);
+                    }
+                } else {
+                    actual.onNext((T) v);
+                }
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
index 0eecc1e24e..5c5335a934 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
@@ -8,7 +8,7 @@ public class SerializedSubscriber<T> extends Subscriber<T> {
     private final Observer<T> s;
 
     public SerializedSubscriber(Subscriber<? super T> s) {
-        this.s = new SerializedObserverViaStateMachine<T>(s);
+        this.s = new SerializedObserverViaQueueAndLock<T>(s);
     }
 
     @Override
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
index 3bebb580c0..f6368c9499 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
@@ -14,9 +14,9 @@
 import rx.schedulers.Schedulers;
 
 public class OperatorSerializePerformance extends AbstractPerformanceTester {
-    static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
+    //    static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
 
-    //    static int reps = Integer.MAX_VALUE / 1024; // timeSingleStream
+    static int reps = Integer.MAX_VALUE / 1024; // timeSingleStream
 
     //    static int reps = 1000; // interval streams
 
@@ -32,8 +32,8 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    spt.timeTwoStreams();
-                    //                    spt.timeSingleStream();
+                    //                    spt.timeTwoStreams();
+                    spt.timeSingleStream();
                 }
             });
         } catch (Exception e) {
@@ -52,13 +52,21 @@ public void call() {
      * Run: 13 - 35,269,946 ops/sec
      * Run: 14 - 34,165,013 ops/sec
      * 
-     * -> using "observeOn" technique
+     * -> using queue and counter technique
      * 
      * Run: 10 - 19,548,387 ops/sec
      * Run: 11 - 19,471,069 ops/sec
      * Run: 12 - 19,480,112 ops/sec
      * Run: 13 - 18,720,550 ops/sec
      * Run: 14 - 19,070,383 ops/sec
+     * 
+     * -> using queue and lock technique
+     * 
+     * Run: 10 - 51,295,152 ops/sec
+     * Run: 11 - 50,317,937 ops/sec
+     * Run: 12 - 51,126,331 ops/sec
+     * Run: 13 - 52,418,291 ops/sec
+     * Run: 14 - 51,694,710 ops/sec
      */
     public long timeSingleStream() {
 
@@ -119,6 +127,14 @@ public void call(Integer t1) {
      * Run: 12 - 4,510,978 ops/sec
      * Run: 13 - 3,218,915 ops/sec
      * Run: 14 - 3,938,549 ops/sec
+     * 
+     * -> using queue and lock technique
+     * 
+     * Run: 10 - 5,348,090 ops/sec
+     * Run: 11 - 6,458,608 ops/sec
+     * Run: 12 - 5,430,743 ops/sec
+     * Run: 13 - 5,159,666 ops/sec
+     * Run: 14 - 6,129,682 ops/sec
      */
     public long timeTwoStreams() {
 
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java
new file mode 100644
index 0000000000..45cdfa1fe5
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java
@@ -0,0 +1,11 @@
+package rx.observers;
+
+import rx.Observer;
+
+public class SerializedObserverViaQueueAndLockTest extends SerializedObserverTest {
+    @Override
+    protected Observer<String> serializedObserver(Observer<String> o) {
+        return new SerializedObserverViaQueueAndLock<String>(o);
+    }
+
+}

From 76bbefcd2b0a94f1f010aad1d6a9095c6ccfd248 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 13 Mar 2014 10:12:16 -0700
Subject: [PATCH 125/422] SerializedObserver and SerializedSubscriber

Using the "queue and lock" implementation which won our performance and production testing.
---
 rxjava-core/src/main/java/rx/Observable.java  |   2 +
 .../java/rx/observers/SerializedObserver.java |  42 ++++++++
 .../SerializedObserverViaQueueAndCounter.java |   2 +-
 .../SerializedObserverViaQueueAndLock.java    |   2 +-
 .../SerializedObserverViaStateMachine.java    |   2 +-
 .../rx/observers/SerializedSubscriber.java    |  14 ++-
 .../rx/observers/SynchronizedObserver.java    |   2 +
 .../rx/observers/SynchronizedSubscriber.java  |   2 +
 .../OperatorSerializePerformance.java         | 101 +++++++++++++-----
 9 files changed, 139 insertions(+), 30 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/observers/SerializedObserver.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7874ff8f3f..235e1e62e4 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7264,6 +7264,7 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      * @return an Observable that is a chronologically well-behaved version of the source Observable, and that
      *         synchronously notifies its {@link Observer}s
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-synchronize">RxJava Wiki: synchronize()</a>
+     * @deprecated Use {@link #serialize()} instead as it doesn't block threads while emitting notification.
      */
     public final Observable<T> synchronize() {
         return lift(new OperatorSynchronize<T>());
@@ -7288,6 +7289,7 @@ public final Observable<T> synchronize() {
      * @return an Observable that is a chronologically well-behaved version of the source Observable, and that
      *         synchronously notifies its {@link Observer}s
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-synchronize">RxJava Wiki: synchronize()</a>
+     * @deprecated Use {@link #serialize()} instead as it doesn't block threads while emitting notification.
      */
     public final Observable<T> synchronize(Object lock) {
         return lift(new OperatorSynchronize<T>(lock));
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
new file mode 100644
index 0000000000..12e46fac06
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -0,0 +1,42 @@
+package rx.observers;
+
+import rx.Observer;
+
+/**
+ * Enforce single-threaded, serialized, ordered execution of onNext, onCompleted, onError.
+ * <p>
+ * When multiple threads are notifying they will be serialized by:
+ * <p>
+ * <li>Allowing only one thread at a time to emit</li>
+ * <li>Adding notifications to a queue if another thread is already emitting</li>
+ * <li>Not holding any locks or blocking any threads while emitting</li>
+ * <p>
+ * 
+ * @param <T>
+ */
+public class SerializedObserver<T> implements Observer<T> {
+    /*
+     * Facade to actual implementation until final decision is made
+     * on the implementation.
+     */
+    private final SerializedObserverViaQueueAndLock<T> actual;
+
+    public SerializedObserver(Observer<? super T> observer) {
+        this.actual = new SerializedObserverViaQueueAndLock<T>(observer);
+    }
+
+    @Override
+    public void onCompleted() {
+        actual.onCompleted();
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        actual.onError(e);
+    }
+
+    @Override
+    public void onNext(T t) {
+        actual.onNext(t);
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
index 60e62d429d..2a9ac3c473 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
@@ -5,7 +5,7 @@
 
 import rx.Observer;
 
-public class SerializedObserverViaQueueAndCounter<T> implements Observer<T> {
+/* package */class SerializedObserverViaQueueAndCounter<T> implements Observer<T> {
     private final Observer<? super T> actual;
     private final AtomicInteger count = new AtomicInteger();
     private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
index 5e999d38fd..48f3c94f4b 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
@@ -4,7 +4,7 @@
 
 import rx.Observer;
 
-public class SerializedObserverViaQueueAndLock<T> implements Observer<T> {
+/* package */ class SerializedObserverViaQueueAndLock<T> implements Observer<T> {
     private final Observer<? super T> actual;
 
     private boolean emitting = false;
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
index 14c9612e07..71756bb98d 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
@@ -4,7 +4,7 @@
 
 import rx.Observer;
 
-public class SerializedObserverViaStateMachine<T> implements Observer<T> {
+/* package */class SerializedObserverViaStateMachine<T> implements Observer<T> {
 
     private final AtomicReference<State> state = new AtomicReference<State>(State.createNew());
     private final Observer<? super T> s;
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
index 5c5335a934..db545ff430 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
@@ -3,12 +3,24 @@
 import rx.Observer;
 import rx.Subscriber;
 
+/**
+ * Enforce single-threaded, serialized, ordered execution of onNext, onCompleted, onError.
+ * <p>
+ * When multiple threads are notifying they will be serialized by:
+ * <p>
+ * <li>Allowing only one thread at a time to emit</li>
+ * <li>Adding notifications to a queue if another thread is already emitting</li>
+ * <li>Not holding any locks or blocking any threads while emitting</li>
+ * <p>
+ * 
+ * @param <T>
+ */
 public class SerializedSubscriber<T> extends Subscriber<T> {
 
     private final Observer<T> s;
 
     public SerializedSubscriber(Subscriber<? super T> s) {
-        this.s = new SerializedObserverViaQueueAndLock<T>(s);
+        this.s = new SerializedObserver<T>(s);
     }
 
     @Override
diff --git a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java b/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
index 25ea8c3403..dbcbb9bc35 100644
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
@@ -23,7 +23,9 @@
  * This ONLY does synchronization. It does not involve itself in safety or subscriptions. See SafeSubscriber for that.
  * 
  * @param <T>
+ * @deprecated Use SerializedObserver instead as it doesn't block threads during event notification.
  */
+@Deprecated
 public final class SynchronizedObserver<T> implements Observer<T> {
 
     /**
diff --git a/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
index 8dbf1b20f5..9f1b3dec90 100644
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
@@ -29,7 +29,9 @@
  * </ul>
  * 
  * @param <T>
+ * @deprecated Use SerializedSubscriber instead as it doesn't block threads during event notification.
  */
+@Deprecated
 public final class SynchronizedSubscriber<T> extends Subscriber<T> {
 
     private final Observer<? super T> observer;
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
index f6368c9499..cfe70889cf 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
@@ -14,10 +14,9 @@
 import rx.schedulers.Schedulers;
 
 public class OperatorSerializePerformance extends AbstractPerformanceTester {
-    //    static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
-
-    static int reps = Integer.MAX_VALUE / 1024; // timeSingleStream
+    static int reps = Integer.MAX_VALUE / 16384; // timeTwoStreams
 
+    //    static int reps = Integer.MAX_VALUE / 1024; // timeSingleStream
     //    static int reps = 1000; // interval streams
 
     OperatorSerializePerformance() {
@@ -32,8 +31,9 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    //                    spt.timeTwoStreams();
-                    spt.timeSingleStream();
+                    spt.timeTwoStreams();
+                    //                    spt.timeSingleStream();
+                    //                    spt.timeTwoStreamsIntervals();
                 }
             });
         } catch (Exception e) {
@@ -43,8 +43,17 @@ public void call() {
     }
 
     /**
+     * 1 streams emitting in a tight loop. Testing for single-threaded overhead.
+     * 
+     * -> blocking synchronization (SynchronizedObserver)
      * 
-     * -> state machine technique
+     * Run: 10 - 58,186,310 ops/sec
+     * Run: 11 - 60,592,037 ops/sec
+     * Run: 12 - 58,099,263 ops/sec
+     * Run: 13 - 59,034,765 ops/sec
+     * Run: 14 - 58,231,548 ops/sec
+     * 
+     * -> state machine technique (SerializedObserverViaStateMachine)
      * 
      * Run: 10 - 34,668,810 ops/sec
      * Run: 11 - 32,874,312 ops/sec
@@ -52,7 +61,7 @@ public void call() {
      * Run: 13 - 35,269,946 ops/sec
      * Run: 14 - 34,165,013 ops/sec
      * 
-     * -> using queue and counter technique
+     * -> using queue and counter technique (SerializedObserverViaQueueAndCounter)
      * 
      * Run: 10 - 19,548,387 ops/sec
      * Run: 11 - 19,471,069 ops/sec
@@ -60,7 +69,7 @@ public void call() {
      * Run: 13 - 18,720,550 ops/sec
      * Run: 14 - 19,070,383 ops/sec
      * 
-     * -> using queue and lock technique
+     * -> using queue and lock technique (SerializedObserverViaQueueAndLock)
      * 
      * Run: 10 - 51,295,152 ops/sec
      * Run: 11 - 50,317,937 ops/sec
@@ -112,29 +121,41 @@ public void call(Integer t1) {
     }
 
     /**
-     * -> state machine technique
+     * 2 streams emitting in tight loops so very high contention.
+     * 
+     * -> blocking synchronization (SynchronizedObserver)
+     * 
+     * Run: 10 - 8,361,252 ops/sec
+     * Run: 11 - 7,184,728 ops/sec
+     * Run: 12 - 8,249,685 ops/sec
+     * Run: 13 - 6,831,595 ops/sec
+     * Run: 14 - 8,003,358 ops/sec
+     * 
+     * (faster because it allows each thread to be "single threaded" while blocking the other)
+     * 
+     * -> state machine technique (SerializedObserverViaStateMachine)
      * 
-     * Run: 10 - 3,432,256 ops/sec
-     * Run: 11 - 3,570,444 ops/sec
-     * Run: 12 - 3,791,137 ops/sec
-     * Run: 13 - 3,664,579 ops/sec
-     * Run: 14 - 5,211,156 ops/sec
+     * Run: 10 - 4,060,062 ops/sec
+     * Run: 11 - 3,561,131 ops/sec
+     * Run: 12 - 3,721,387 ops/sec
+     * Run: 13 - 3,693,909 ops/sec
+     * Run: 14 - 3,516,324 ops/sec
      * 
-     * -> using "observeOn" technique
+     * -> using queue and counter technique (SerializedObserverViaQueueAndCounter)
      * 
-     * Run: 10 - 3,995,336 ops/sec
-     * Run: 11 - 4,033,077 ops/sec
-     * Run: 12 - 4,510,978 ops/sec
-     * Run: 13 - 3,218,915 ops/sec
-     * Run: 14 - 3,938,549 ops/sec
+     * Run: 10 - 4,300,229 ops/sec
+     * Run: 11 - 4,395,995 ops/sec
+     * Run: 12 - 4,551,550 ops/sec
+     * Run: 13 - 4,443,235 ops/sec
+     * Run: 14 - 4,158,475 ops/sec
      * 
-     * -> using queue and lock technique
+     * -> using queue and lock technique (SerializedObserverViaQueueAndLock)
      * 
-     * Run: 10 - 5,348,090 ops/sec
-     * Run: 11 - 6,458,608 ops/sec
-     * Run: 12 - 5,430,743 ops/sec
-     * Run: 13 - 5,159,666 ops/sec
-     * Run: 14 - 6,129,682 ops/sec
+     * Run: 10 - 6,369,781 ops/sec
+     * Run: 11 - 6,933,872 ops/sec
+     * Run: 12 - 5,652,535 ops/sec
+     * Run: 13 - 5,503,716 ops/sec
+     * Run: 14 - 6,219,264 ops/sec
      */
     public long timeTwoStreams() {
 
@@ -198,11 +219,39 @@ public void call(Integer t1) {
     }
 
     /**
+     * 2 streams emitting once a millisecond. Slow emission so little to no contention.
+     * 
+     * -> blocking synchronization (SynchronizedObserver)
+     * 
+     * Run: 10 - 1,996 ops/sec
+     * Run: 11 - 1,996 ops/sec
+     * Run: 12 - 1,995 ops/sec
+     * Run: 13 - 1,997 ops/sec
+     * Run: 14 - 1,996 ops/sec
+     * 
+     * -> state machine technique (SerializedObserverViaStateMachine)
+     * 
      * Run: 10 - 1,996 ops/sec
      * Run: 11 - 1,996 ops/sec
      * Run: 12 - 1,996 ops/sec
      * Run: 13 - 1,996 ops/sec
      * Run: 14 - 1,996 ops/sec
+     * 
+     * -> using queue and counter technique (SerializedObserverViaQueueAndCounter)
+     * 
+     * Run: 10 - 1,996 ops/sec
+     * Run: 11 - 1,996 ops/sec
+     * Run: 12 - 1,996 ops/sec
+     * Run: 13 - 1,996 ops/sec
+     * Run: 14 - 1,995 ops/sec
+     * 
+     * -> using queue and lock technique (SerializedObserverViaQueueAndLock)
+     * 
+     * Run: 10 - 1,996 ops/sec
+     * Run: 11 - 1,996 ops/sec
+     * Run: 12 - 1,997 ops/sec
+     * Run: 13 - 1,996 ops/sec
+     * Run: 14 - 1,995 ops/sec
      */
     public long timeTwoStreamsIntervals() {
 

From 6926fa6d150a2ed221df051deb72a4d503de50f8 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 13 Mar 2014 10:38:44 -0700
Subject: [PATCH 126/422] Synchronize -> Serialize

- migrate all usage to Serialized instead of Synchronized
- remove implementations of SerializedObserver that lost the competition (performance and testing in production)
---
 .../java/rx/observers/SafeSubscriber.java     |   2 +-
 .../java/rx/observers/SerializedObserver.java | 168 +++++++++++++-
 .../SerializedObserverViaQueueAndCounter.java |  70 ------
 .../SerializedObserverViaQueueAndLock.java    | 174 --------------
 .../SerializedObserverViaStateMachine.java    | 214 ------------------
 .../java/rx/operators/OperationDebounce.java  |   3 +-
 .../operators/OperationMergeDelayError.java   |  12 +-
 .../OperationMergeMaxConcurrent.java          |  31 ++-
 .../rx/operators/OperatorTimeoutBase.java     |  21 +-
 .../main/java/rx/operators/SafeObserver.java  |   4 +-
 .../rx/observers/SerializedObserverTest.java  |   6 +-
 ...ializedObserverViaQueueAndCounterTest.java |  25 --
 ...SerializedObserverViaQueueAndLockTest.java |  11 -
 ...SerializedObserverViaStateMachineTest.java |  10 -
 14 files changed, 192 insertions(+), 559 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
 delete mode 100644 rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
 delete mode 100644 rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
 delete mode 100644 rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java

diff --git a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
index 922b61de95..ff121eeb77 100644
--- a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
@@ -52,7 +52,7 @@
  * <li>When onError or onComplete occur it will unsubscribe from the Observable (if executing asynchronously).</li>
  * </ul>
  * <p>
- * It will not synchronize onNext execution. Use the {@link SynchronizedObserver} to do that.
+ * It will not synchronize onNext execution. Use the {@link SerializedSubscriber} to do that.
  * 
  * @param <T>
  */
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 12e46fac06..93f1632973 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -1,5 +1,7 @@
 package rx.observers;
 
+import java.util.ArrayList;
+
 import rx.Observer;
 
 /**
@@ -15,28 +17,170 @@
  * @param <T>
  */
 public class SerializedObserver<T> implements Observer<T> {
-    /*
-     * Facade to actual implementation until final decision is made
-     * on the implementation.
-     */
-    private final SerializedObserverViaQueueAndLock<T> actual;
-
-    public SerializedObserver(Observer<? super T> observer) {
-        this.actual = new SerializedObserverViaQueueAndLock<T>(observer);
+    private final Observer<? super T> actual;
+
+    private boolean emitting = false;
+    private boolean terminated = false;
+    private ArrayList<Object> queue = new ArrayList<Object>();
+
+    private static Sentinel NULL_SENTINEL = new Sentinel();
+    private static Sentinel COMPLETE_SENTINEL = new Sentinel();
+
+    private static class Sentinel {
+
+    }
+
+    private static class ErrorSentinel extends Sentinel {
+        final Throwable e;
+
+        ErrorSentinel(Throwable e) {
+            this.e = e;
+        }
+    }
+
+    public SerializedObserver(Observer<? super T> s) {
+        this.actual = s;
     }
 
     @Override
     public void onCompleted() {
-        actual.onCompleted();
+        boolean canEmit = false;
+        ArrayList<Object> list = null;
+        synchronized (this) {
+            if (terminated) {
+                return;
+            }
+            terminated = true;
+            if (!emitting) {
+                // emit immediately
+                emitting = true;
+                canEmit = true;
+                if (queue.size() > 0) {
+                    list = queue; // copy reference
+                    queue = new ArrayList<Object>(); // new version;
+                }
+            } else {
+                // someone else is already emitting so just queue it
+                queue.add(COMPLETE_SENTINEL);
+            }
+        }
+        if (canEmit) {
+            // we won the right to emit
+            try {
+                drainQueue(list);
+                actual.onCompleted();
+            } finally {
+                synchronized (this) {
+                    emitting = false;
+                }
+            }
+        }
     }
 
     @Override
-    public void onError(Throwable e) {
-        actual.onError(e);
+    public void onError(final Throwable e) {
+        boolean canEmit = false;
+        ArrayList<Object> list = null;
+        synchronized (this) {
+            if (terminated) {
+                return;
+            }
+            terminated = true;
+            if (!emitting) {
+                // emit immediately
+                emitting = true;
+                canEmit = true;
+                if (queue.size() > 0) {
+                    list = queue; // copy reference
+                    queue = new ArrayList<Object>(); // new version;
+                }
+            } else {
+                // someone else is already emitting so just queue it ... after eliminating the queue to shortcut
+                queue.clear();
+                queue.add(new ErrorSentinel(e));
+            }
+        }
+        if (canEmit) {
+            // we won the right to emit
+            try {
+                drainQueue(list);
+                actual.onError(e);
+            } finally {
+                synchronized (this) {
+                    emitting = false;
+                }
+            }
+        }
     }
 
     @Override
     public void onNext(T t) {
-        actual.onNext(t);
+        boolean canEmit = false;
+        ArrayList<Object> list = null;
+        synchronized (this) {
+            if (terminated) {
+                return;
+            }
+            if (!emitting) {
+                // emit immediately
+                emitting = true;
+                canEmit = true;
+                if (queue.size() > 0) {
+                    list = queue; // copy reference
+                    queue = new ArrayList<Object>(); // new version;
+                }
+            } else {
+                // someone else is already emitting so just queue it
+                if (t == null) {
+                    queue.add(NULL_SENTINEL);
+                } else {
+                    queue.add(t);
+                }
+            }
+        }
+        if (canEmit) {
+            // we won the right to emit
+            try {
+                drainQueue(list);
+                actual.onNext(t);
+            } finally {
+                synchronized (this) {
+                    if (terminated) {
+                        list = queue; // copy reference
+                        queue = new ArrayList<Object>(); // new version;
+                    } else {
+                        // release this thread
+                        emitting = false;
+                        canEmit = false;
+                    }
+                }
+            }
+        }
+
+        // if terminated this will still be true so let's drain the rest of the queue
+        if (canEmit) {
+            drainQueue(list);
+        }
+    }
+
+    public void drainQueue(ArrayList<Object> list) {
+        if (list == null || list.size() == 0) {
+            return;
+        }
+        for (Object v : list) {
+            if (v != null) {
+                if (v instanceof Sentinel) {
+                    if (v == NULL_SENTINEL) {
+                        actual.onNext(null);
+                    } else if (v == COMPLETE_SENTINEL) {
+                        actual.onCompleted();
+                    } else if (v instanceof ErrorSentinel) {
+                        actual.onError(((ErrorSentinel) v).e);
+                    }
+                } else {
+                    actual.onNext((T) v);
+                }
+            }
+        }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
deleted file mode 100644
index 2a9ac3c473..0000000000
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndCounter.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package rx.observers;
-
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import rx.Observer;
-
-/* package */class SerializedObserverViaQueueAndCounter<T> implements Observer<T> {
-    private final Observer<? super T> actual;
-    private final AtomicInteger count = new AtomicInteger();
-    private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
-
-    private static Sentinel NULL_SENTINEL = new Sentinel();
-    private static Sentinel COMPLETE_SENTINEL = new Sentinel();
-
-    private static class Sentinel {
-
-    }
-
-    private static class ErrorSentinel extends Sentinel {
-        final Throwable e;
-
-        ErrorSentinel(Throwable e) {
-            this.e = e;
-        }
-    }
-
-    public SerializedObserverViaQueueAndCounter(Observer<? super T> s) {
-        this.actual = s;
-    }
-
-    @Override
-    public void onCompleted() {
-        queue.add(COMPLETE_SENTINEL);
-        doIt();
-    }
-
-    @Override
-    public void onError(final Throwable e) {
-        queue.add(new ErrorSentinel(e));
-        doIt();
-    }
-
-    @Override
-    public void onNext(T t) {
-        queue.add(t);
-        doIt();
-    }
-
-    public void doIt() {
-        if (count.getAndIncrement() == 0) {
-            do {
-                Object v = queue.poll();
-                if (v != null) {
-                    if (v instanceof Sentinel) {
-                        if (v == NULL_SENTINEL) {
-                            actual.onNext(null);
-                        } else if (v == COMPLETE_SENTINEL) {
-                            actual.onCompleted();
-                        } else if (v instanceof ErrorSentinel) {
-                            actual.onError(((ErrorSentinel) v).e);
-                        }
-                    } else {
-                        actual.onNext((T) v);
-                    }
-                }
-            } while (count.decrementAndGet() > 0);
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
deleted file mode 100644
index 48f3c94f4b..0000000000
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaQueueAndLock.java
+++ /dev/null
@@ -1,174 +0,0 @@
-package rx.observers;
-
-import java.util.ArrayList;
-
-import rx.Observer;
-
-/* package */ class SerializedObserverViaQueueAndLock<T> implements Observer<T> {
-    private final Observer<? super T> actual;
-
-    private boolean emitting = false;
-    private boolean terminated = false;
-    private ArrayList<Object> queue = new ArrayList<Object>();
-
-    private static Sentinel NULL_SENTINEL = new Sentinel();
-    private static Sentinel COMPLETE_SENTINEL = new Sentinel();
-
-    private static class Sentinel {
-
-    }
-
-    private static class ErrorSentinel extends Sentinel {
-        final Throwable e;
-
-        ErrorSentinel(Throwable e) {
-            this.e = e;
-        }
-    }
-
-    public SerializedObserverViaQueueAndLock(Observer<? super T> s) {
-        this.actual = s;
-    }
-
-    @Override
-    public void onCompleted() {
-        boolean canEmit = false;
-        ArrayList<Object> list = null;
-        synchronized (this) {
-            if (terminated) {
-                return;
-            }
-            terminated = true;
-            if (!emitting) {
-                // emit immediately
-                emitting = true;
-                canEmit = true;
-                if (queue.size() > 0) {
-                    list = queue; // copy reference
-                    queue = new ArrayList<Object>(); // new version;
-                }
-            } else {
-                // someone else is already emitting so just queue it
-                queue.add(COMPLETE_SENTINEL);
-            }
-        }
-        if (canEmit) {
-            // we won the right to emit
-            try {
-                drainQueue(list);
-                actual.onCompleted();
-            } finally {
-                synchronized (this) {
-                    emitting = false;
-                }
-            }
-        }
-    }
-
-    @Override
-    public void onError(final Throwable e) {
-        boolean canEmit = false;
-        ArrayList<Object> list = null;
-        synchronized (this) {
-            if (terminated) {
-                return;
-            }
-            terminated = true;
-            if (!emitting) {
-                // emit immediately
-                emitting = true;
-                canEmit = true;
-                if (queue.size() > 0) {
-                    list = queue; // copy reference
-                    queue = new ArrayList<Object>(); // new version;
-                }
-            } else {
-                // someone else is already emitting so just queue it ... after eliminating the queue to shortcut
-                queue.clear();
-                queue.add(new ErrorSentinel(e));
-            }
-        }
-        if (canEmit) {
-            // we won the right to emit
-            try {
-                drainQueue(list);
-                actual.onError(e);
-            } finally {
-                synchronized (this) {
-                    emitting = false;
-                }
-            }
-        }
-    }
-
-    @Override
-    public void onNext(T t) {
-        boolean canEmit = false;
-        ArrayList<Object> list = null;
-        synchronized (this) {
-            if (terminated) {
-                return;
-            }
-            if (!emitting) {
-                // emit immediately
-                emitting = true;
-                canEmit = true;
-                if (queue.size() > 0) {
-                    list = queue; // copy reference
-                    queue = new ArrayList<Object>(); // new version;
-                }
-            } else {
-                // someone else is already emitting so just queue it
-                if (t == null) {
-                    queue.add(NULL_SENTINEL);
-                } else {
-                    queue.add(t);
-                }
-            }
-        }
-        if (canEmit) {
-            // we won the right to emit
-            try {
-                drainQueue(list);
-                actual.onNext(t);
-            } finally {
-                synchronized (this) {
-                    if (terminated) {
-                        list = queue; // copy reference
-                        queue = new ArrayList<Object>(); // new version;
-                    } else {
-                        // release this thread
-                        emitting = false;
-                        canEmit = false;
-                    }
-                }
-            }
-        }
-
-        // if terminated this will still be true so let's drain the rest of the queue
-        if (canEmit) {
-            drainQueue(list);
-        }
-    }
-
-    public void drainQueue(ArrayList<Object> list) {
-        if (list == null || list.size() == 0) {
-            return;
-        }
-        for (Object v : list) {
-            if (v != null) {
-                if (v instanceof Sentinel) {
-                    if (v == NULL_SENTINEL) {
-                        actual.onNext(null);
-                    } else if (v == COMPLETE_SENTINEL) {
-                        actual.onCompleted();
-                    } else if (v instanceof ErrorSentinel) {
-                        actual.onError(((ErrorSentinel) v).e);
-                    }
-                } else {
-                    actual.onNext((T) v);
-                }
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java b/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
deleted file mode 100644
index 71756bb98d..0000000000
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserverViaStateMachine.java
+++ /dev/null
@@ -1,214 +0,0 @@
-package rx.observers;
-
-import java.util.concurrent.atomic.AtomicReference;
-
-import rx.Observer;
-
-/* package */class SerializedObserverViaStateMachine<T> implements Observer<T> {
-
-    private final AtomicReference<State> state = new AtomicReference<State>(State.createNew());
-    private final Observer<? super T> s;
-
-    public SerializedObserverViaStateMachine(Observer<? super T> s) {
-        this.s = s;
-    }
-
-    @Override
-    public void onCompleted() {
-        State current = null;
-        State newState = null;
-        do {
-            current = state.get();
-            if (current.isTerminated()) {
-                // already received terminal state
-                return;
-            }
-            newState = current.complete();
-        } while (!state.compareAndSet(current, newState));
-        terminateIfNecessary(newState);
-    }
-
-    @Override
-    public void onError(Throwable e) {
-        State current = null;
-        State newState = null;
-        do {
-            current = state.get();
-            if (current.isTerminated()) {
-                // already received terminal state
-                return;
-            }
-            newState = current.error(e);
-        } while (!state.compareAndSet(current, newState));
-        terminateIfNecessary(newState);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public void onNext(T t) {
-        State current = null;
-        State newState = null;
-
-        State orig = null;
-        do {
-            current = state.get();
-            if (orig == null) {
-                orig = current;
-            }
-            if (current.isTerminated()) {
-                // already received terminal state
-                return;
-            }
-            newState = current.offerItem(t);
-        } while (!state.compareAndSet(current, newState));
-
-        if (newState.shouldProcess()) {
-            int numItemsProcessed = 0;
-            try {
-                if (newState == State.PROCESS_SELF) {
-                    s.onNext(t);
-                    numItemsProcessed++;
-                } else {
-                    // drain queue 
-                    Object[] items = newState.queue;
-                    for (int i = 0; i < items.length; i++) {
-                        s.onNext((T) items[i]);
-                        numItemsProcessed++;
-                    }
-                }
-            } finally {
-                // finish processing to let this thread move on
-                do {
-                    current = state.get();
-                    newState = current.finishProcessing(numItemsProcessed);
-                } while (!state.compareAndSet(current, newState));
-            }
-        }
-        terminateIfNecessary(newState);
-    }
-
-    @SuppressWarnings("unchecked")
-    private void terminateIfNecessary(State current) {
-        if (current.isTerminated()) {
-            State newState = null;
-            do {
-                current = state.get();
-                newState = current.startTermination();
-            } while (!state.compareAndSet(current, newState));
-
-            if (newState.shouldProcess()) {
-                // drain any items left
-                for (int i = 0; i < newState.queue.length; i++) {
-                    s.onNext((T) newState.queue[i]);
-                }
-
-                // now terminate
-                if (newState.onComplete) {
-                    s.onCompleted();
-                } else {
-                    s.onError(newState.onError);
-                }
-            }
-        }
-    }
-
-    public static class State {
-        final boolean shouldProcess;
-        final boolean isSomeoneProcessing;
-        final int queueSize;
-        final Object[] queue;
-        final boolean onComplete;
-        final Throwable onError;
-
-        private final static Object[] EMPTY = new Object[0];
-        private final static Object[] PROCESS_SELF_QUEUE = new Object[1];
-
-        private final static State NON_TERMINATED_EMPTY = new State(false, false, 0, false, null, EMPTY);
-        private final static State PROCESS_SELF = new State(true, true, 1, false, null, PROCESS_SELF_QUEUE);
-
-        public State(boolean shouldProcess, boolean isSomeoneProcessing, int queueSize, boolean onComplete, Throwable onError, Object[] queue) {
-            this.shouldProcess = shouldProcess;
-            this.isSomeoneProcessing = isSomeoneProcessing;
-            this.queueSize = queueSize;
-            this.queue = queue;
-            this.onComplete = onComplete;
-            this.onError = onError;
-        }
-
-        public static State createNew() {
-            return new State(false, false, 0, false, null, EMPTY);
-        }
-
-        public boolean shouldProcess() {
-            return shouldProcess;
-        }
-
-        public boolean isTerminated() {
-            return onComplete || onError != null;
-        }
-
-        public State complete() {
-            return new State(false, isSomeoneProcessing, queueSize, true, onError, queue);
-        }
-
-        public State error(Throwable e) {
-            // immediately empty the queue and emit error as soon as possible
-            return new State(false, isSomeoneProcessing, 0, onComplete, e, EMPTY);
-        }
-
-        public State startTermination() {
-            if (isSomeoneProcessing) {
-                return new State(false, isSomeoneProcessing, queueSize, onComplete, onError, queue);
-            } else {
-                return new State(true, true, queueSize, onComplete, onError, queue);
-            }
-        }
-
-        public State offerItem(Object item) {
-            if (queueSize == 0) {
-                if (isTerminated()) {
-                    // return count of 0 meaning don't emit as we are terminated
-                    return new State(false, isSomeoneProcessing, 0, onComplete, onError, EMPTY);
-                } else {
-                    // no concurrent requests so don't queue, we'll process immediately
-                    return PROCESS_SELF;
-                }
-            } else {
-                // there are items queued so we need to queue
-                int idx = queue.length;
-                Object[] newQueue = new Object[idx + 1];
-                System.arraycopy(queue, 0, newQueue, 0, idx);
-                newQueue[idx] = item;
-
-                if (isSomeoneProcessing) {
-                    // we just add to queue
-                    return new State(false, true, queueSize + 1, onComplete, onError, newQueue);
-                } else {
-                    // we add to queue and claim work
-                    return new State(true, true, queueSize + 1, onComplete, onError, newQueue);
-                }
-            }
-        }
-
-        public State finishProcessing(int numOnNextSent) {
-            int size = queueSize - numOnNextSent;
-            if (size > 0 || isTerminated()) {
-                // if size == 0 but we are terminated then it's an empty queue
-                Object[] newQueue = EMPTY;
-                if (size > 0) {
-                    newQueue = new Object[queue.length - numOnNextSent];
-                    System.arraycopy(queue, numOnNextSent, newQueue, 0, newQueue.length);
-                }
-                return new State(false, false, size, onComplete, onError, newQueue);
-            } else {
-                return NON_TERMINATED_EMPTY;
-            }
-        }
-
-        @Override
-        public String toString() {
-            return "State => shouldProcess: " + shouldProcess + " processing: " + isSomeoneProcessing + " queueSize: " + queueSize + " queue: " + queue.length + " terminated: " + isTerminated();
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 5a7da4a1bb..e970176c8b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -26,6 +26,7 @@
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.functions.Func1;
+import rx.observers.SerializedObserver;
 import rx.observers.SynchronizedObserver;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.CompositeSubscription;
@@ -111,7 +112,7 @@ private static class DebounceObserver<T> implements Observer<T> {
         public DebounceObserver(Observer<? super T> observer, long timeout, TimeUnit unit, Scheduler scheduler) {
             // we need to synchronize the observer since the on* events can be coming from different
             // threads and are thus non-deterministic and could be interleaved
-            this.observer = new SynchronizedObserver<T>(observer);
+            this.observer = new SerializedObserver<T>(observer);
             this.timeout = timeout;
             this.unit = unit;
             this.scheduler = scheduler;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
index b2498df6c2..4c97223a87 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
@@ -25,7 +25,7 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
-import rx.observers.SynchronizedObserver;
+import rx.observers.SerializedObserver;
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.CompositeSubscription;
 
@@ -141,15 +141,7 @@ private MergeDelayErrorObservable(Observable<? extends Observable<? extends T>>
 
         public Subscription onSubscribe(Observer<? super T> actualObserver) {
             CompositeSubscription completeSubscription = new CompositeSubscription();
-
-            /**
-             * We must synchronize a merge because we subscribe to multiple sequences in parallel that will each be emitting.
-             * <p>
-             * The calls from each sequence must be serialized.
-             * <p>
-             * Bug report: https://github.com/Netflix/RxJava/issues/614
-             */
-            SynchronizedObserver<T> synchronizedObserver = new SynchronizedObserver<T>(actualObserver);
+            SerializedObserver<T> synchronizedObserver = new SerializedObserver<T>(actualObserver);
 
             /**
              * Subscribe to the parent Observable to get to the children Observables
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java b/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
index ec27002d4a..d0c296b06d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
@@ -21,7 +21,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
-import rx.observers.SynchronizedObserver;
+import rx.observers.SerializedObserver;
 import rx.subscriptions.CompositeSubscription;
 
 /**
@@ -85,9 +85,8 @@ public Subscription onSubscribe(Observer<? super T> actualObserver) {
              * Bug report: https://github.com/Netflix/RxJava/issues/200
              */
             SafeObservableSubscription subscription = new SafeObservableSubscription(ourSubscription);
-            SynchronizedObserver<T> synchronizedObserver = new SynchronizedObserver<T>(
-                    new SafeObserver<T>(subscription, actualObserver), // Create a SafeObserver as SynchronizedObserver does not automatically unsubscribe
-                    subscription);
+            SerializedObserver<T> synchronizedObserver = new SerializedObserver<T>(
+                    new SafeObserver<T>(subscription, actualObserver)); // Create a SafeObserver as SynchronizedObserver does not automatically unsubscribe
 
             /**
              * Subscribe to the parent Observable to get to the children Observables
@@ -103,10 +102,10 @@ public Subscription onSubscribe(Observer<? super T> actualObserver) {
          * @param <T>
          */
         private class ParentObserver implements Observer<Observable<? extends T>> {
-            private final SynchronizedObserver<T> synchronizedObserver;
+            private final SerializedObserver<T> serializedObserver;
 
-            public ParentObserver(SynchronizedObserver<T> synchronizedObserver) {
-                this.synchronizedObserver = synchronizedObserver;
+            public ParentObserver(SerializedObserver<T> serializedObserver) {
+                this.serializedObserver = serializedObserver;
             }
 
             @Override
@@ -119,13 +118,13 @@ public void 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();
+                    serializedObserver.onCompleted();
                 }
             }
 
             @Override
             public void onError(Throwable e) {
-                synchronizedObserver.onError(e);
+                serializedObserver.onError(e);
             }
 
             @Override
@@ -151,7 +150,7 @@ public void onNext(Observable<? extends T> childObservable) {
                 }
                 if (observable != null) {
                     ourSubscription.add(observable.subscribe(new ChildObserver(
-                            synchronizedObserver)));
+                            serializedObserver)));
                 }
             }
         }
@@ -162,10 +161,10 @@ public void onNext(Observable<? extends T> childObservable) {
          */
         private class ChildObserver implements Observer<T> {
 
-            private final SynchronizedObserver<T> synchronizedObserver;
+            private final SerializedObserver<T> serializedObserver;
 
-            public ChildObserver(SynchronizedObserver<T> synchronizedObserver) {
-                this.synchronizedObserver = synchronizedObserver;
+            public ChildObserver(SerializedObserver<T> serializedObserver) {
+                this.serializedObserver = serializedObserver;
             }
 
             @Override
@@ -192,19 +191,19 @@ public void onCompleted() {
                 } else {
                     // No pending observable. Need to check if it's necessary to emit an onCompleted
                     if (isStopped()) {
-                        synchronizedObserver.onCompleted();
+                        serializedObserver.onCompleted();
                     }
                 }
             }
 
             @Override
             public void onError(Throwable e) {
-                synchronizedObserver.onError(e);
+                serializedObserver.onError(e);
             }
 
             @Override
             public void onNext(T args) {
-                synchronizedObserver.onNext(args);
+                serializedObserver.onNext(args);
             }
 
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index 3d6dc97998..7a6ea8e8d8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -25,7 +25,7 @@
 import rx.Subscription;
 import rx.functions.Func2;
 import rx.functions.Func3;
-import rx.observers.SynchronizedSubscriber;
+import rx.observers.SerializedSubscriber;
 import rx.subscriptions.SerialSubscription;
 
 class OperatorTimeoutBase<T> implements Operator<T, T> {
@@ -67,8 +67,7 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         // Use SynchronizedSubscriber for safe memory access
         // as the subscriber will be accessed in the current thread or the
         // scheduler or other Observables.
-        final SynchronizedSubscriber<T> synchronizedSubscriber = new SynchronizedSubscriber<T>(
-                subscriber);
+        final SerializedSubscriber<T> synchronizedSubscriber = new SerializedSubscriber<T>(subscriber);
 
         TimeoutSubscriber<T> timeoutSubscriber = new TimeoutSubscriber<T>(
                 synchronizedSubscriber, timeoutStub, serial, other);
@@ -84,17 +83,17 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         private final SerialSubscription serial;
         private final Object gate = new Object();
 
-        private final SynchronizedSubscriber<T> synchronizedSubscriber;
+        private final SerializedSubscriber<T> serializedSubscriber;
 
         private final TimeoutStub<T> timeoutStub;
 
         private final Observable<? extends T> other;
 
         private TimeoutSubscriber(
-                SynchronizedSubscriber<T> synchronizedSubscriber,
+                SerializedSubscriber<T> serializedSubscriber,
                 TimeoutStub<T> timeoutStub, SerialSubscription serial,
                 Observable<? extends T> other) {
-            this.synchronizedSubscriber = synchronizedSubscriber;
+            this.serializedSubscriber = serializedSubscriber;
             this.timeoutStub = timeoutStub;
             this.serial = serial;
             this.other = other;
@@ -110,7 +109,7 @@ public void onNext(T value) {
                 }
             }
             if (onNextWins) {
-                synchronizedSubscriber.onNext(value);
+                serializedSubscriber.onNext(value);
                 serial.set(timeoutStub.call(this, actual.get(), value));
             }
         }
@@ -125,7 +124,7 @@ public void onError(Throwable error) {
             }
             if (onErrorWins) {
                 serial.unsubscribe();
-                synchronizedSubscriber.onError(error);
+                serializedSubscriber.onError(error);
             }
         }
 
@@ -139,7 +138,7 @@ public void onCompleted() {
             }
             if (onCompletedWins) {
                 serial.unsubscribe();
-                synchronizedSubscriber.onCompleted();
+                serializedSubscriber.onCompleted();
             }
         }
 
@@ -153,9 +152,9 @@ public void onTimeout(long seqId) {
             }
             if (timeoutWins) {
                 if (other == null) {
-                    synchronizedSubscriber.onError(new TimeoutException());
+                    serializedSubscriber.onError(new TimeoutException());
                 } else {
-                    serial.set(other.subscribe(synchronizedSubscriber));
+                    serial.set(other.subscribe(serializedSubscriber));
                 }
             }
         }
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index cf632b4dc5..08984deae3 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -22,7 +22,7 @@
 import rx.Subscription;
 import rx.exceptions.CompositeException;
 import rx.exceptions.OnErrorNotImplementedException;
-import rx.observers.SynchronizedObserver;
+import rx.observers.SerializedObserver;
 import rx.plugins.RxJavaPlugins;
 import rx.subscriptions.Subscriptions;
 
@@ -55,7 +55,7 @@
  * <li>When onError or onComplete occur it will unsubscribe from the Observable (if executing asynchronously).</li>
  * </ul>
  * <p>
- * It will not synchronize onNext execution. Use the {@link SynchronizedObserver} to do that.
+ * It will not synchronize onNext execution. Use the {@link SerializedObserver} to do that.
  * 
  * @param <T>
  * @deprecated replaced by SafeSubscriber
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index 9b7656be29..e6043edd39 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -37,7 +37,7 @@
 import rx.Subscriber;
 import rx.Subscription;
 
-public abstract class SerializedObserverTest {
+public class SerializedObserverTest {
 
     @Mock
     Subscriber<String> observer;
@@ -47,7 +47,9 @@ public void before() {
         MockitoAnnotations.initMocks(this);
     }
 
-    protected abstract Observer<String> serializedObserver(Observer<String> o);
+    private Observer<String> serializedObserver(Observer<String> o) {
+        return new SerializedObserver<String>(o);
+    }
 
     @Test
     public void testSingleThreadedBasic() {
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
deleted file mode 100644
index 2e3f49ec7a..0000000000
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndCounterTest.java
+++ /dev/null
@@ -1,25 +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.observers;
-
-import rx.Observer;
-
-public class SerializedObserverViaQueueAndCounterTest extends SerializedObserverTest {
-    @Override
-    protected Observer<String> serializedObserver(Observer<String> o) {
-        return new SerializedObserverViaQueueAndCounter<String>(o);
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java
deleted file mode 100644
index 45cdfa1fe5..0000000000
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaQueueAndLockTest.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package rx.observers;
-
-import rx.Observer;
-
-public class SerializedObserverViaQueueAndLockTest extends SerializedObserverTest {
-    @Override
-    protected Observer<String> serializedObserver(Observer<String> o) {
-        return new SerializedObserverViaQueueAndLock<String>(o);
-    }
-
-}
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
deleted file mode 100644
index 76582d06e0..0000000000
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverViaStateMachineTest.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package rx.observers;
-
-import rx.Observer;
-
-public class SerializedObserverViaStateMachineTest extends SerializedObserverTest {
-    @Override
-    protected Observer<String> serializedObserver(Observer<String> o) {
-        return new SerializedObserverViaStateMachine<String>(o);
-    }
-}

From c9a983ae3da03b52031d637af5d97fab50b83a84 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Thu, 13 Mar 2014 18:45:09 +0000
Subject: [PATCH 127/422] [Gradle Release Plugin] - pre tag commit:  '0.17.1'.

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

diff --git a/gradle.properties b/gradle.properties
index 641a9d1d9b..beefc2ce98 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.1-SNAPSHOT
+version=0.17.1

From 27bf21cb27cfc6b2dece44fae5bc807eeeb8acd0 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Thu, 13 Mar 2014 18:45:13 +0000
Subject: [PATCH 128/422] [Gradle Release Plugin] - new version commit: 
 '0.17.2-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index beefc2ce98..bc0a89d83b 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.1
+version=0.17.2-SNAPSHOT

From 2052da32e8596431da58eb6d70113c2fadfb5c75 Mon Sep 17 00:00:00 2001
From: Gleb Smirnov <me@gvsmirnov.ru>
Date: Thu, 13 Mar 2014 23:44:35 +0400
Subject: [PATCH 129/422] Updated gradle build scripts so there is a separate
 benchmarks task

---
 build.gradle             | 80 +++++++++++++++++++++++++---------------
 rxjava-core/build.gradle | 10 +----
 2 files changed, 52 insertions(+), 38 deletions(-)

diff --git a/build.gradle b/build.gradle
index 304a26643c..366a6f94dc 100644
--- a/build.gradle
+++ b/build.gradle
@@ -9,8 +9,20 @@ apply from: file('gradle/release.gradle')
 buildscript {
     repositories {
         mavenLocal()
-        mavenCentral() // maven { url 'http://jcenter.bintray.com' }
+        mavenCentral()
+        maven {
+            //FIXME: waiting for https://github.com/johnrengelman/shadow/pull/38 to merge
+            name 'Shadow'
+            url 'http://dl.bintray.com/content/gvsmirnov/gradle-plugins'
+        }
+        jcenter()
+    }
+
+    dependencies {
+        // Required for benchmarks
+        classpath 'com.github.jengelman.gradle.plugins:shadow:0.8.1'
     }
+
     apply from: file('gradle/buildscript.gradle'), to: buildscript 
 }
 
@@ -19,7 +31,7 @@ allprojects {
     apply plugin: 'idea'
     repositories { 
         mavenLocal()
-        mavenCentral() // maven { url: 'http://jcenter.bintray.com' }
+        mavenCentral()
     }
 }
 
@@ -31,8 +43,6 @@ subprojects {
     configurations { 
         examplesCompile.extendsFrom compile
         examplesRuntime.extendsFrom runtime
-	    perfCompile.extendsFrom compile
-	    perfRuntime.extendsFrom runtime
     }
 
 
@@ -40,48 +50,60 @@ subprojects {
         it.classpath = sourceSets.main.compileClasspath
     }
 
-    sourceSets { 
-		//include /src/examples folder
+    sourceSets {
         examples
-		//include /src/perf folder
-        perf {
-            java {
-                srcDir 'src/perf/java'
-                compileClasspath += main.output
-                runtimeClasspath += main.output
-            }
-        }
-    }
-
-    dependencies {
-        perfCompile 'org.openjdk.jmh:jmh-core:0.2'
+        perf
     }
 
     tasks.build { 
-		//include 'examples' in build task
+        //include 'examples' in build task
         dependsOn(examplesClasses)
-		//include 'perf' in build task
-        // dependsOn(perfClasses)  //-> Not working so commented out
+    }
+
+    dependencies {
+        perfCompile 'org.openjdk.jmh:jmh-core:0.5.3'
+        perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:0.5.3'
+
+        perfCompile project
     }
     
     eclipse {  
-        classpath {  
-            // include 'provided' dependencies on the classpath
-            plusConfigurations += configurations.provided
+        classpath {
             plusConfigurations += configurations.perfCompile
             
             downloadSources = true
             downloadJavadoc = true
         }
     }
-    
+
     idea {
         module {
-            // include 'provided' dependencies on the classpath
-            scopes.PROVIDED.plus += configurations.provided
-            // TODO not sure what to add it to
-            //scopes.PROVIDED.plus += configurations.perfCompile
+            scopes.PROVIDED.plus  += configurations.perfCompile
+            scopes.PROVIDED.minus += configurations.compile
+        }
+    }
+
+    task perfJar(type: Jar, dependsOn: perfClasses) {
+        from sourceSets.perf.output + sourceSets.main.output
+    }
+
+    task benchmarks(dependsOn: perfJar) {
+
+        apply plugin: "shadow"
+
+        shadow {
+            classifier = "benchmarks"
+            includeDependenciesFor = ["runtime", "perfRuntime"]
+
+            transformer(com.github.jengelman.gradle.plugins.shadow.transformers.ManifestResourceTransformer) {
+                mainClass = "org.openjdk.jmh.Main"
+            }
         }
+
+        doLast {
+            shadowJar.execute()
+        }
+
     }
 }
 
diff --git a/rxjava-core/build.gradle b/rxjava-core/build.gradle
index 00420d0f74..d03c5653a4 100644
--- a/rxjava-core/build.gradle
+++ b/rxjava-core/build.gradle
@@ -1,6 +1,5 @@
 apply plugin: 'maven'
 apply plugin: 'osgi'
-apply plugin:'application'
 
 sourceCompatibility = JavaVersion.VERSION_1_6
 targetCompatibility = JavaVersion.VERSION_1_6
@@ -13,7 +12,7 @@ dependencies {
 javadoc {
     // we do not want the org.rx.operations package include
     exclude '**/operations/**'
-	
+
     options {
         doclet = "org.benjchristensen.doclet.DocletExclude"
         docletpath = [rootProject.file('./gradle/doclet-exclude.jar')]
@@ -31,11 +30,4 @@ jar {
         instruction 'Import-Package', '!org.junit,!junit.framework,!org.mockito.*,*'
         instruction 'Eclipse-ExtensibleAPI', 'true'
     }
-}
-
-task time(type:JavaExec) {
-    classpath = sourceSets.perf.runtimeClasspath
-    group 'Application'
-    description 'Execute the calipser benchmark timing of Rx'
-    main 'rx.operators.ObservableBenchmark'
 }
\ No newline at end of file

From 2fa35e5569d0919c98178dbf4d26f1fb07b8d7d7 Mon Sep 17 00:00:00 2001
From: Gleb Smirnov <me@gvsmirnov.ru>
Date: Fri, 14 Mar 2014 00:26:05 +0400
Subject: [PATCH 130/422] Updated ObservableBenchmark to follow better
 benchmarking practices

---
 .../rx/operators/ObservableBenchmark.java     | 149 ++++++++----------
 1 file changed, 62 insertions(+), 87 deletions(-)

diff --git a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
index 9602cb797d..5de2a022d7 100644
--- a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
+++ b/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
@@ -1,14 +1,12 @@
 package rx.operators;
 
+import java.util.ArrayList;
+import java.util.Collection;
 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 org.openjdk.jmh.annotations.*;
 
+import org.openjdk.jmh.logic.BlackHole;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
@@ -19,107 +17,84 @@
 public class ObservableBenchmark {
 
     @GenerateMicroBenchmark
-    public void timeBaseline() {
-        observableOfInts.subscribe(newObserver());
-        awaitAllObservers();
-    }
-
-    @GenerateMicroBenchmark
-    public int timeMapIterate() {
-        int x = 0;
-        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();
+    public void measureBaseline(BlackHole bh, Input input) {
+        for (Integer value : input.values) {
+            bh.consume(IDENTITY_FUNCTION.call(value));
         }
-        return x;
     }
 
     @GenerateMicroBenchmark
-    public void timeMap() {
-        timeOperator(new OperatorMap<Integer, Object>(ident));
+    public void measureMap(Input input) throws InterruptedException {
+        input.observable.lift(MAP_OPERATOR).subscribe(input.observer);
+
+        input.awaitCompletion();
     }
 
-    /**************************************************************************
-     * Below is internal stuff to avoid object allocation and time overhead of anything that isn't
-     * being tested.
-     * 
-     * @throws RunnerException
-     **************************************************************************/
+    private static final Func1<Integer, Integer> IDENTITY_FUNCTION = new Func1<Integer, Integer>() {
+        @Override
+        public Integer call(Integer value) {
+            return value;
+        }
+    };
 
-    public static void main(String[] args) throws RunnerException {
-        Options opt = new OptionsBuilder()
-                .include(ObservableBenchmark.class.getName()+".*")
-                .forks(1)
-                .build();
+    private static final Operator<Integer, Integer> MAP_OPERATOR = new OperatorMap<Integer, Integer>(IDENTITY_FUNCTION);
 
-        new Runner(opt).run();
-    }
+    @State(Scope.Thread)
+    public static class Input {
 
-    private void timeOperator(Operator<Object, Integer> op) {
-        observableOfInts.lift(op).subscribe(newObserver());
-        awaitAllObservers();
-    }
+        @Param({"1", "1024", "1048576"})
+        public int size;
 
-    private final static AtomicInteger outstanding = new AtomicInteger(0);
-    private final static CountDownLatch latch = new CountDownLatch(1);
+        public Collection<Integer> values;
+        public Observable<Integer> observable;
+        public Observer<Integer> observer;
 
-    private static <T> Observer<T> newObserver() {
-        outstanding.incrementAndGet();
-        return new Observer<T>() {
-            @Override
-            public void onCompleted() {
-                int left = outstanding.decrementAndGet();
-                if (left == 0) {
-                    latch.countDown();
-                }
+        private CountDownLatch latch;
+
+        @Setup
+        public void setup() {
+            values = new ArrayList<Integer>();
+            for(int i = 0; i < size; i ++) {
+                values.add(i);
             }
 
-            @Override
-            public void onError(Throwable e) {
-                int left = outstanding.decrementAndGet();
-                if (left == 0) {
+            observable = Observable.create(new OnSubscribe<Integer>() {
+                @Override
+                public void call(Subscriber<? super Integer> o) {
+                    for (Integer value : values) {
+                        if (o.isUnsubscribed())
+                            return;
+                        o.onNext(value);
+                    }
+                    o.onCompleted();
+                }
+            });
+
+            final BlackHole bh = new BlackHole();
+            latch = new CountDownLatch(1);
+
+            observer = new Observer<Integer>() {
+                @Override
+                public void onCompleted() {
                     latch.countDown();
                 }
-            }
 
-            @Override
-            public void onNext(T t) {
-                // do nothing
-            }
-        };
-    }
+                @Override
+                public void onError(Throwable e) {
+                    throw new RuntimeException(e);
+                }
+
+                @Override
+                public void onNext(Integer value) {
+                    bh.consume(value);
+                }
+            };
 
-    private static void awaitAllObservers() {
-        try {
-            latch.await();
-        } catch (InterruptedException e) {
-            return;
         }
-    }
 
-    private static final Integer[] intValues = new Integer[1000];
-    static {
-        for (int i = 0; i < intValues.length; i++) {
-            intValues[i] = i;
+        public void awaitCompletion() throws InterruptedException {
+            latch.await();
         }
     }
 
-    private static final Observable<Integer> observableOfInts = Observable.create(new OnSubscribe<Integer>() {
-        @Override
-        public void call(Subscriber<? super Integer> o) {
-            for (int i = 0; i < intValues.length; i++) {
-                if (o.isUnsubscribed())
-                    return;
-                o.onNext(intValues[i]);
-            }
-            o.onCompleted();
-        }
-    });
-    private static final Func1<Integer, Object> ident = new Func1<Integer, Object>() {
-        @Override
-        public Object call(Integer t) {
-            return t;
-        }
-    };
 }

From 2c82d48d5f12ca890e33a41073dd6b3191ca84dd Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Thu, 13 Mar 2014 23:05:12 +0100
Subject: [PATCH 131/422] SubjectSubscriptionManager fix.

---
 .../subjects/SubjectSubscriptionManager.java  | 27 ++++++++---
 .../java/rx/subjects/BehaviorSubjectTest.java | 42 +++++++++++++++++
 .../java/rx/subjects/PublishSubjectTest.java  | 42 ++++++++++++++++-
 .../java/rx/subjects/ReplaySubjectTest.java   | 45 ++++++++++++++++++-
 4 files changed, 147 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 e6626d434d..6f049eb38a 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -92,7 +92,10 @@ public void call() {
                                 }
                             }
                         }));
-
+                        if (subscription.isUnsubscribed()) {
+                            addedObserver = false;
+                            break;
+                        }
                         // on subscribe add it to the map of outbound observers to notify
                         newState = current.addObserver(subscription, observer);
                     }
@@ -202,15 +205,21 @@ public State<T> removeObserver(Subscription s) {
             // we are empty, nothing to remove
             if (this.observers.length == 0) {
                 return this;
+            } else
+            if (this.observers.length == 1) {
+                if (this.subscriptions[0].equals(s)) {
+                    return createNewWith(EMPTY_S, EMPTY_O);
+                }
+                return this;
             }
-            int n = Math.max(this.observers.length - 1, 1);
+            int n = this.observers.length - 1;
             int copied = 0;
-            Subscription[] newsubscriptions = Arrays.copyOf(this.subscriptions, n);
-            SubjectObserver[] newobservers = Arrays.copyOf(this.observers, n);
+            Subscription[] newsubscriptions = new Subscription[n];
+            SubjectObserver[] newobservers = new SubjectObserver[n];
 
             for (int i = 0; i < this.subscriptions.length; i++) {
                 Subscription s0 = this.subscriptions[i];
-                if (s0 != s) {
+                if (!s0.equals(s)) {
                     if (copied == n) {
                         // if s was not found till the end of the iteration
                         // we return ourselves since no modification should
@@ -229,7 +238,13 @@ public State<T> removeObserver(Subscription s) {
             // 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));
+                Subscription[] newsubscriptions2 = new Subscription[copied];
+                System.arraycopy(newsubscriptions, 0, newsubscriptions2, 0, copied);
+                
+                SubjectObserver[] newobservers2 = new SubjectObserver[copied];
+                System.arraycopy(newobservers, 0, newobservers2, 0, copied);
+
+                return createNewWith(newsubscriptions2, newobservers2);
             }
             return createNewWith(newsubscriptions, newobservers);
         }
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index 646e1acc26..c3e6974f71 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -21,9 +21,11 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
+import rx.Observable;
 
 import rx.Observer;
 import rx.Subscription;
+import rx.util.functions.Func1;
 
 public class BehaviorSubjectTest {
 
@@ -237,4 +239,44 @@ public void testCompletedAfterErrorIsNotSent3() {
         verify(o2, never()).onNext(any());
         verify(observer, never()).onError(any(Throwable.class));
     }
+    @Test(timeout = 1000)
+    public void testUnsubscriptionCase() {
+        BehaviorSubject<String> src = BehaviorSubject.create((String)null);
+        
+        for (int i = 0; i < 10; i++) {
+            @SuppressWarnings("unchecked")
+            final Observer<Object> o = mock(Observer.class);
+            InOrder inOrder = inOrder(o);
+            String v = "" + i;
+            src.onNext(v);
+            System.out.printf("Turn: %d%n", i);
+            src.first()
+                .flatMap(new Func1<String, Observable<String>>() {
+
+                    @Override
+                    public Observable<String> call(String t1) {
+                        return Observable.from(t1 + ", " + t1);
+                    }
+                })
+                .subscribe(new Observer<String>() {
+                    @Override
+                    public void onNext(String t) {
+                        o.onNext(t);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        o.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        o.onCompleted();
+                    }
+                });
+            inOrder.verify(o).onNext(v + ", " + v);
+            inOrder.verify(o).onCompleted();
+            verify(o, never()).onError(any(Throwable.class));
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
index 9c71d4aa5c..a5bd5d7579 100644
--- a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -16,7 +16,6 @@
 package rx.subjects;
 
 import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
@@ -299,4 +298,45 @@ public void testReSubscribe() {
 
     private final Throwable testException = new Throwable();
 
+    @Test(timeout = 1000)
+    public void testUnsubscriptionCase() {
+        PublishSubject<String> src = PublishSubject.create();
+
+        for (int i = 0; i < 10; i++) {
+            @SuppressWarnings("unchecked")
+            final Observer<Object> o = mock(Observer.class);
+            InOrder inOrder = inOrder(o);
+            String v = "" + i;
+            System.out.printf("Turn: %d%n", i);
+            src.first()
+                .flatMap(new rx.util.functions.Func1<String, Observable<String>>() {
+
+                    @Override
+                    public Observable<String> call(String t1) {
+                        return Observable.from(t1 + ", " + t1);
+                    }
+                })
+                .subscribe(new Observer<String>() {
+                    @Override
+                    public void onNext(String t) {
+                        o.onNext(t);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        o.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        o.onCompleted();
+                    }
+                });
+            src.onNext(v);
+            
+            inOrder.verify(o).onNext(v + ", " + v);
+            inOrder.verify(o).onCompleted();
+            verify(o, never()).onError(any(Throwable.class));
+        }
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index 5a963eba02..9cb0e81cfd 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -16,7 +16,6 @@
 package rx.subjects;
 
 import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.util.concurrent.CountDownLatch;
@@ -25,10 +24,12 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
+import rx.Observable;
 
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Func1;
 import rx.schedulers.Schedulers;
 
 public class ReplaySubjectTest {
@@ -356,4 +357,44 @@ public void testSubscriptionLeak() {
         
         assertEquals(0, replaySubject.subscriberCount());
     }
-}
+    @Test(timeout = 1000)
+    public void testUnsubscriptionCase() {
+        ReplaySubject<String> src = ReplaySubject.create();
+        
+        for (int i = 0; i < 10; i++) {
+            @SuppressWarnings("unchecked")
+            final Observer<Object> o = mock(Observer.class);
+            InOrder inOrder = inOrder(o);
+            String v = "" + i;
+            src.onNext(v);
+            System.out.printf("Turn: %d%n", i);
+            src.first()
+                .flatMap(new Func1<String, Observable<String>>() {
+
+                    @Override
+                    public Observable<String> call(String t1) {
+                        return Observable.from(t1 + ", " + t1);
+                    }
+                })
+                .subscribe(new Observer<String>() {
+                    @Override
+                    public void onNext(String t) {
+                        System.out.println(t);
+                        o.onNext(t);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        o.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        o.onCompleted();
+                    }
+                });
+            inOrder.verify(o).onNext("0, 0");
+            inOrder.verify(o).onCompleted();
+            verify(o, never()).onError(any(Throwable.class));
+        }
+    }}

From d3ead3a7748fa8245b39725ba9534cbaa4d3ee36 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Thu, 13 Mar 2014 15:52:13 -0700
Subject: [PATCH 132/422] Version 0.17.1

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

diff --git a/CHANGES.md b/CHANGES.md
index 1c7481a9bb..881656798b 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,20 @@
 # RxJava Releases #
 
+### Version 0.17.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.1%22)) ###
+
+* [Pull 953](https://github.com/Netflix/RxJava/pull/953) Make ObserveOnTest.testNonBlockingOuterWhileBlockingOnNext deterministic
+* [Pull 930](https://github.com/Netflix/RxJava/pull/930) Initial commit of the Android samples module
+* [Pull 938](https://github.com/Netflix/RxJava/pull/938) OperatorWeakBinding (deprecates OperatorObserveFromAndroidComponent)
+* [Pull 952](https://github.com/Netflix/RxJava/pull/952) rxjava-scala improvements and reimplemented the `amb` operator
+* [Pull 955](https://github.com/Netflix/RxJava/pull/955) Fixed ReplaySubject leak
+* [Pull 956](https://github.com/Netflix/RxJava/pull/956) Fixed byLine test to use line.separator system property instead of \n.
+* [Pull 958](https://github.com/Netflix/RxJava/pull/958) OperatorSkipWhile
+* [Pull 959](https://github.com/Netflix/RxJava/pull/959) OperationToFuture must throw CancellationException on get() if cancelled
+* [Pull 928](https://github.com/Netflix/RxJava/pull/928) Fix deadlock in SubscribeOnBounded
+* [Pull 960](https://github.com/Netflix/RxJava/pull/960) Unit test for "Cannot subscribe to a Retry observable once all subscribers unsubscribed"
+* [Pull 962](https://github.com/Netflix/RxJava/pull/962) Migrate from SynchronizedObserver to SerializedObserver
+
+
 ### Version 0.17.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.0%22)) ###
 
 

From 7ce4c84f97c9cff52361fe5362cb5473a5226a1b Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 16 Mar 2014 21:13:19 +0800
Subject: [PATCH 133/422] Reimplement the 'single' operator

---
 rxjava-core/src/main/java/rx/Observable.java  |  6 +-
 .../java/rx/operators/OperationSingle.java    | 96 -------------------
 .../java/rx/operators/OperatorSingle.java     | 90 +++++++++++++++++
 ...ingleTest.java => OperatorSingleTest.java} |  2 +-
 4 files changed, 94 insertions(+), 100 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSingle.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSingle.java
 rename rxjava-core/src/test/java/rx/operators/{OperationSingleTest.java => OperatorSingleTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 235e1e62e4..5df7b3bba9 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -86,7 +86,7 @@
 import rx.operators.OperationReplay;
 import rx.operators.OperationSample;
 import rx.operators.OperationSequenceEqual;
-import rx.operators.OperationSingle;
+import rx.operators.OperatorSingle;
 import rx.operators.OperationSkip;
 import rx.operators.OperationSkipLast;
 import rx.operators.OperationSkipUntil;
@@ -6216,7 +6216,7 @@ public final Observable<T> serialize() {
      * @see "MSDN: Observable.singleAsync()"
      */
     public final Observable<T> single() {
-        return create(OperationSingle.<T> single(this));
+        return lift(new OperatorSingle<T>());
     }
 
     /**
@@ -6257,7 +6257,7 @@ public final Observable<T> single(Func1<? super T, Boolean> predicate) {
      * @see "MSDN: Observable.singleOrDefaultAsync()"
      */
     public final Observable<T> singleOrDefault(T defaultValue) {
-        return create(OperationSingle.<T> singleOrDefault(this, defaultValue));
+        return lift(new OperatorSingle<T>(defaultValue));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSingle.java b/rxjava-core/src/main/java/rx/operators/OperationSingle.java
deleted file mode 100644
index 871d565092..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSingle.java
+++ /dev/null
@@ -1,96 +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;
-
-/**
- * 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 <T> OnSubscribeFunc<T> single(
-            final Observable<? extends T> source) {
-        return single(source, false, null);
-    }
-
-    public static <T> OnSubscribeFunc<T> singleOrDefault(
-            final Observable<? extends T> source, final T defaultValue) {
-        return single(source, true, defaultValue);
-    }
-
-    private static <T> OnSubscribeFunc<T> single(
-            final Observable<? extends T> source,
-            final boolean hasDefaultValue, final T defaultValue) {
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(final Observer<? super T> observer) {
-                final SafeObservableSubscription subscription = new SafeObservableSubscription();
-                subscription.wrap(source.subscribe(new Observer<T>() {
-
-                    private T value;
-                    private boolean isEmpty = true;
-                    private 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/main/java/rx/operators/OperatorSingle.java b/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
new file mode 100644
index 0000000000..6a63b025ce
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
@@ -0,0 +1,90 @@
+/**
+ * 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;
+
+/**
+ * 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 final class OperatorSingle<T> implements Operator<T, T> {
+
+    private final boolean hasDefaultValue;
+    private final T defaultValue;
+
+    public OperatorSingle() {
+        this(false, null);
+    }
+
+    public OperatorSingle(T defaultValue) {
+        this(true, defaultValue);
+    }
+
+    private OperatorSingle(boolean hasDefaultValue, final T defaultValue) {
+        this.hasDefaultValue = hasDefaultValue;
+        this.defaultValue = defaultValue;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            private T value;
+            private boolean isNonEmpty = false;
+            private boolean hasTooManyElemenets = false;
+
+            @Override
+            public void onNext(T value) {
+                if (isNonEmpty) {
+                    hasTooManyElemenets = true;
+                    subscriber.onError(new IllegalArgumentException("Sequence contains too many elements"));
+                } else {
+                    this.value = value;
+                    isNonEmpty = true;
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                if (hasTooManyElemenets) {
+                    // We has already sent an onError message
+                } else {
+                    if (isNonEmpty) {
+                        subscriber.onNext(value);
+                        subscriber.onCompleted();
+                    } else {
+                        if (hasDefaultValue) {
+                            subscriber.onNext(defaultValue);
+                            subscriber.onCompleted();
+                        } else {
+                            subscriber.onError(new IllegalArgumentException("Sequence contains no elements"));
+                        }
+                    }
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+        };
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSingleTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSingleTest.java
index dee0f1eb88..baf83929ec 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSingleTest.java
@@ -25,7 +25,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 
-public class OperationSingleTest {
+public class OperatorSingleTest {
 
     @Test
     public void testSingle() {

From 531449e4050d1046034992dad2043374ae2e97a4 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 17 Mar 2014 15:45:40 +0800
Subject: [PATCH 134/422] Add first, last, single to rxjava-scala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 12 ++++
 .../main/scala/rx/lang/scala/Observable.scala | 70 +++++++++++++------
 .../observables/BlockingObservable.scala      | 43 ++++++++++++
 3 files changed, 104 insertions(+), 21 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 e09e6a7ec9..4ef20263a3 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
@@ -388,6 +388,18 @@ class RxScalaDemo extends JUnitSuite {
     assertEquals(10, List(-1, 0, 1).toObservable.filter(condition).firstOrElse(10).toBlockingObservable.single)
   }
 
+  @Test def firstLastSingleExample() {
+    assertEquals(1, List(1, 2, 3, 4).toObservable.head.toBlockingObservable.single)
+    assertEquals(1, List(1, 2, 3, 4).toObservable.first.toBlockingObservable.single)
+    assertEquals(4, List(1, 2, 3, 4).toObservable.last.toBlockingObservable.single)
+    assertEquals(1, List(1).toObservable.single.toBlockingObservable.single)
+
+    assertEquals(1, List(1, 2, 3, 4).toObservable.toBlockingObservable.head)
+    assertEquals(1, List(1, 2, 3, 4).toObservable.toBlockingObservable.first)
+    assertEquals(4, List(1, 2, 3, 4).toObservable.toBlockingObservable.last)
+    assertEquals(1, List(1).toObservable.toBlockingObservable.single)
+  }
+
   def square(x: Int): Int = {
     println(s"$x*$x is being calculated on thread ${Thread.currentThread().getId}")
     Thread.sleep(100) // calculating a square is heavy work :)
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 8dafa30e2b..73abed3d8a 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
@@ -1949,36 +1949,64 @@ trait Observable[+T]
   def headOrElse[U >: T](default: => U): Observable[U] = firstOrElse(default)
 
   /**
-   * Returns an Observable that emits only the very first item emitted by the source Observable.
-   * This is just a shorthand for `take(1)`.
-   *
+   * Returns an Observable that emits only the very first item emitted by the source Observable, or raises an
+   * `IllegalArgumentException` if the source Observable is empty.
+   * <p>
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
-   *
-   * @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 raises an
+   *         `IllegalArgumentException` if the source Observable is empty
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
+   * @see "MSDN: Observable.firstAsync()"
    */
-  def first: Observable[T] = take(1)
+  def first: Observable[T] = {
+    toScalaObservable[T](asJavaObservable.first)
+  }
 
-  /*
-  
-  TODO once https://github.com/Netflix/RxJava/issues/417 is fixed, we can add head and tail methods
+  /**
+   * Returns an Observable that emits only the very first item emitted by the source Observable, or raises an
+   * `IllegalArgumentException` if the source Observable is empty.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
+   * 
+   * @return an Observable that emits only the very first item emitted by the source Observable, or raises an
+   *         `IllegalArgumentException` if the source Observable is empty
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
+   * @see "MSDN: Observable.firstAsync()"
+   * @see [[Observable.first]]
+   */
+  def head: Observable[T] = first
   
   /**
-   * emits NoSuchElementException("head of empty Observable") if empty
+   * Returns an Observable that emits the last item emitted by the source Observable or notifies observers of
+   * an `IllegalArgumentException` if the source Observable is empty.
+   * 
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.png">
+   * 
+   * @return an Observable that emits the last item from the source Observable or notifies observers of an
+   *         error
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
+   * @see "MSDN: Observable.lastAsync()"
    */
-  def head: Observable[T] = {
-    this.take(1).fold[Option[T]](None)((v: Option[T], e: T) => Some(e)).map({
-      case Some(element) => element
-      case None => throw new NoSuchElementException("head of empty Observable")
-    })
+  def last: Observable[T] = {
+    toScalaObservable[T](asJavaObservable.last)
   }
-  
+
   /**
-   * emits an UnsupportedOperationException("tail of empty list") if empty
+   * 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`.
+   * 
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.png">
+   * 
+   * @return an Observable that emits the single item emitted by the source Observable
+   * @throws IllegalArgumentException
+   *             if the source emits more than one item or no items
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
+   * @see "MSDN: Observable.singleAsync()"
    */
-  def tail: Observable[T] = ???
-  
-  */
+  def single: Observable[T] = {
+    toScalaObservable[T](asJavaObservable.single)
+  }
 
   /**
    * Returns an Observable that forwards all sequentially distinct items emitted from the source Observable.
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 c1ce913095..fb2c2764f8 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
@@ -53,6 +53,49 @@ class BlockingObservable[+T] private[scala] (val asJava: rx.observables.Blocking
     new WithFilter[T](p, asJava)
   }
 
+  /**
+   * Returns the last item emitted by a specified [[Observable]], or
+   * throws `IllegalArgumentException` if it emits no items.
+   * 
+   * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.last.png">
+   * 
+   * @return the last item emitted by the source [[Observable]]
+   * @throws IllegalArgumentException
+   *             if source contains no elements
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: last()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.last.aspx">MSDN: Observable.Last</a>
+   */
+  def last : T = {
+    asJava.last : T
+  }
+
+  /**
+   * Returns the first item emitted by a specified [[Observable]], or
+   * `IllegalArgumentException` if source contains no elements.
+   * 
+   * @return the first item emitted by the source [[Observable]]
+   * @throws IllegalArgumentException
+   *             if source contains no elements
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229177.aspx">MSDN: Observable.First</a>
+   */
+  def first : T = {
+    asJava.first : T
+  }
+
+  /**
+   * Returns the first item emitted by a specified [[Observable]], or
+   * `IllegalArgumentException` if source contains no elements.
+   * 
+   * @return the first item emitted by the source [[Observable]]
+   * @throws IllegalArgumentException
+   *             if source contains no elements
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229177.aspx">MSDN: Observable.First</a>
+   * @see [[BlockingObservable.first]]
+   */
+  def head : T = first
+
   // last                 -> use toIterable.last
   // lastOrDefault        -> use toIterable.lastOption
   // first                -> use toIterable.head

From c1ed51d10be2a2a134d4eb1d8401010b99b9bf1b Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 17 Mar 2014 16:55:33 +0800
Subject: [PATCH 135/422] Throw NoSuchElementException in the first, last and
 single operators when the Observable is empty

---
 .../main/scala/rx/lang/scala/Observable.scala | 14 +++++-----
 .../observables/BlockingObservable.scala      | 12 ++++-----
 rxjava-core/src/main/java/rx/Observable.java  | 27 ++++++++++---------
 .../rx/observables/BlockingObservable.java    | 20 +++++++-------
 .../java/rx/operators/OperatorSingle.java     |  4 ++-
 .../src/test/java/rx/ObservableTests.java     |  9 ++++---
 rxjava-core/src/test/java/rx/ZipTests.java    |  5 ++--
 .../observables/BlockingObservableTest.java   |  8 +++---
 .../OperationFirstOrDefaultTest.java          |  6 +++--
 .../java/rx/operators/OperationLastTest.java  | 16 ++++++-----
 .../rx/operators/OperationMinMaxTest.java     |  9 ++++---
 .../java/rx/operators/OperatorMapTest.java    |  5 ++--
 .../java/rx/operators/OperatorSingleTest.java |  6 +++--
 .../java/rx/operators/OperatorZipTest.java    |  5 ++--
 14 files changed, 82 insertions(+), 64 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 73abed3d8a..1d17b3ebee 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
@@ -1950,12 +1950,12 @@ trait Observable[+T]
 
   /**
    * Returns an Observable that emits only the very first item emitted by the source Observable, or raises an
-   * `IllegalArgumentException` if the source Observable is empty.
+   * `NoSuchElementException` if the source Observable is empty.
    * <p>
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
    * 
    * @return an Observable that emits only the very first item emitted by the source Observable, or raises an
-   *         `IllegalArgumentException` if the source Observable is empty
+   *         `NoSuchElementException` if the source Observable is empty
    * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
    * @see "MSDN: Observable.firstAsync()"
    */
@@ -1965,12 +1965,12 @@ trait Observable[+T]
 
   /**
    * Returns an Observable that emits only the very first item emitted by the source Observable, or raises an
-   * `IllegalArgumentException` if the source Observable is empty.
+   * `NoSuchElementException` if the source Observable is empty.
    * <p>
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
    * 
    * @return an Observable that emits only the very first item emitted by the source Observable, or raises an
-   *         `IllegalArgumentException` if the source Observable is empty
+   *         `NoSuchElementException` if the source Observable is empty
    * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
    * @see "MSDN: Observable.firstAsync()"
    * @see [[Observable.first]]
@@ -1979,7 +1979,7 @@ trait Observable[+T]
   
   /**
    * Returns an Observable that emits the last item emitted by the source Observable or notifies observers of
-   * an `IllegalArgumentException` if the source Observable is empty.
+   * an `NoSuchElementException` if the source Observable is empty.
    * 
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.png">
    * 
@@ -1994,12 +1994,12 @@ trait Observable[+T]
 
   /**
    * 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`.
+   * item. If the source Observable emits more than one item or no items, throw an `NoSuchElementException`.
    * 
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.png">
    * 
    * @return an Observable that emits the single item emitted by the source Observable
-   * @throws IllegalArgumentException
+   * @throws NoSuchElementException
    *             if the source emits more than one item or no items
    * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
    * @see "MSDN: Observable.singleAsync()"
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 fb2c2764f8..4ae6a54ce7 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
@@ -55,12 +55,12 @@ class BlockingObservable[+T] private[scala] (val asJava: rx.observables.Blocking
 
   /**
    * Returns the last item emitted by a specified [[Observable]], or
-   * throws `IllegalArgumentException` if it emits no items.
+   * throws `NoSuchElementException` if it emits no items.
    * 
    * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.last.png">
    * 
    * @return the last item emitted by the source [[Observable]]
-   * @throws IllegalArgumentException
+   * @throws NoSuchElementException
    *             if source contains no elements
    * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: last()</a>
    * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.last.aspx">MSDN: Observable.Last</a>
@@ -71,10 +71,10 @@ class BlockingObservable[+T] private[scala] (val asJava: rx.observables.Blocking
 
   /**
    * Returns the first item emitted by a specified [[Observable]], or
-   * `IllegalArgumentException` if source contains no elements.
+   * `NoSuchElementException` if source contains no elements.
    * 
    * @return the first item emitted by the source [[Observable]]
-   * @throws IllegalArgumentException
+   * @throws NoSuchElementException
    *             if source contains no elements
    * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
    * @see <a href="http://msdn.microsoft.com/en-us/library/hh229177.aspx">MSDN: Observable.First</a>
@@ -85,10 +85,10 @@ class BlockingObservable[+T] private[scala] (val asJava: rx.observables.Blocking
 
   /**
    * Returns the first item emitted by a specified [[Observable]], or
-   * `IllegalArgumentException` if source contains no elements.
+   * `NoSuchElementException` if source contains no elements.
    * 
    * @return the first item emitted by the source [[Observable]]
-   * @throws IllegalArgumentException
+   * @throws NoSuchElementException
    *             if source contains no elements
    * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
    * @see <a href="http://msdn.microsoft.com/en-us/library/hh229177.aspx">MSDN: Observable.First</a>
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 5df7b3bba9..17eb5af99d 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4545,12 +4545,12 @@ public final Observable<T> 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.
+     * {@code NoSuchElementException} if the source Observable is empty.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
      * 
      * @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
+     *         {@code NoSuchElementException} if the source Observable is empty
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
      * @see "MSDN: Observable.firstAsync()"
      */
@@ -4560,14 +4560,14 @@ public final Observable<T> 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.
+     * a specified condition, or raises an {@code NoSuchElementException} if no such items are emitted.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/firstN.png">
      * 
      * @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
+     *         the {@code predicate}, or raises an {@code NoSuchElementException} if no such items are emitted
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
      * @see "MSDN: Observable.firstAsync()"
      */
@@ -4778,7 +4778,7 @@ public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> 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.
+     * an {@code NoSuchElementException} if the source Observable is empty.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.png">
      * 
@@ -4793,14 +4793,14 @@ public final Observable<T> 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.
+     * given condition, or an {@code NoSuchElementException} if no such items are emitted.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.p.png">
      * 
      * @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
+     *         {@code NoSuchElementException} if no such items are emitted
      * @throws IllegalArgumentException
      *             if no items that match the predicate are emitted by the source Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
@@ -6205,13 +6205,15 @@ public final Observable<T> serialize() {
     /**
      * 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}.
+     * {@code NoSuchElementException}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.png">
      * 
      * @return an Observable that emits the single item emitted by the source Observable
      * @throws IllegalArgumentException
-     *             if the source emits more than one item or no items
+     *             if the source emits more than one item
+     * @throws NoSuchElementException
+     *             if the source emits no items
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
      * @see "MSDN: Observable.singleAsync()"
      */
@@ -6222,7 +6224,7 @@ public final Observable<T> 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}.
+     * throw an {@code NoSuchElementException}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.p.png">
      * 
@@ -6231,8 +6233,9 @@ public final Observable<T> single() {
      * @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 more than one item that matches the predicate
+     * @throws NoSuchElementException
+     *             if the source Observable emits no item that matches the predicate
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
      * @see "MSDN: Observable.singleAsync()"
      */
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index fdd8db73ed..15957dea4e 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -163,10 +163,10 @@ public Iterator<T> getIterator() {
 
     /**
      * Returns the first item emitted by a specified {@link Observable}, or
-     * <code>IllegalArgumentException</code> if source contains no elements.
+     * <code>NoSuchElementException</code> if source contains no elements.
      * 
      * @return the first item emitted by the source {@link Observable}
-     * @throws IllegalArgumentException
+     * @throws NoSuchElementException
      *             if source contains no elements
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229177.aspx">MSDN: Observable.First</a>
@@ -177,14 +177,14 @@ public T first() {
 
     /**
      * Returns the first item emitted by a specified {@link Observable} that
-     * matches a predicate, or <code>IllegalArgumentException</code> if no such
+     * matches a predicate, or <code>NoSuchElementException</code> 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
+     * @throws NoSuchElementException
      *             if no such items are emitted
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#first-and-firstordefault">RxJava Wiki: first()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229739.aspx">MSDN: Observable.First</a>
@@ -227,12 +227,12 @@ public T firstOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
 
     /**
      * Returns the last item emitted by a specified {@link Observable}, or
-     * throws <code>IllegalArgumentException</code> if it emits no items.
+     * throws <code>NoSuchElementException</code> if it emits no items.
      * <p>
      * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.last.png">
      * 
      * @return the last item emitted by the source {@link Observable}
-     * @throws IllegalArgumentException
+     * @throws NoSuchElementException
      *             if source contains no elements
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: last()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.last.aspx">MSDN: Observable.Last</a>
@@ -243,7 +243,7 @@ public T last() {
 
     /**
      * Returns the last item emitted by a specified {@link Observable} that
-     * matches a predicate, or throws <code>IllegalArgumentException</code> if
+     * matches a predicate, or throws <code>NoSuchElementException</code> if
      * it emits no such items.
      * <p>
      * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.last.p.png">
@@ -252,7 +252,7 @@ public T last() {
      *            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
+     * @throws NoSuchElementException
      *             if no such items are emitted
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#last-and-lastordefault">RxJava Wiki: last()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.last.aspx">MSDN: Observable.Last</a>
@@ -349,7 +349,7 @@ public Iterable<T> latest() {
 
     /**
      * If the {@link Observable} completes after emitting a single item, return
-     * that item, otherwise throw an <code>IllegalArgumentException</code>.
+     * that item, otherwise throw an <code>NoSuchElementException</code>.
      * <p>
      * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.single.png">
      * 
@@ -364,7 +364,7 @@ public T single() {
     /**
      * If the {@link Observable} completes after emitting a single item that
      * matches a given predicate, return that item, otherwise throw an
-     * <code>IllegalArgumentException</code>.
+     * <code>NoSuchElementException</code>.
      * <p>
      * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.single.p.png">
      * 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSingle.java b/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
index 6a63b025ce..e00aa87d82 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
@@ -15,6 +15,8 @@
  */
 package rx.operators;
 
+import java.util.NoSuchElementException;
+
 import rx.Observable.Operator;
 import rx.Subscriber;
 
@@ -73,7 +75,7 @@ public void onCompleted() {
                             subscriber.onNext(defaultValue);
                             subscriber.onCompleted();
                         } else {
-                            subscriber.onError(new IllegalArgumentException("Sequence contains no elements"));
+                            subscriber.onError(new NoSuchElementException("Sequence contains no elements"));
                         }
                     }
                 }
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index e4a84c15ac..d75af529dc 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -23,6 +23,7 @@
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.NoSuchElementException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -204,7 +205,7 @@ public void testFirstOfNone() {
         observable.first().subscribe(w);
         verify(w, never()).onNext(anyInt());
         verify(w, never()).onCompleted();
-        verify(w, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(w, times(1)).onError(isA(NoSuchElementException.class));
     }
 
     @Test
@@ -213,7 +214,7 @@ public void testFirstWithPredicateOfNoneMatchingThePredicate() {
         observable.first(IS_EVEN).subscribe(w);
         verify(w, never()).onNext(anyInt());
         verify(w, never()).onCompleted();
-        verify(w, times(1)).onError(isA(IllegalArgumentException.class));
+        verify(w, times(1)).onError(isA(NoSuchElementException.class));
     }
 
     @Test
@@ -233,9 +234,9 @@ public Integer call(Integer t1, Integer t2) {
     }
 
     /**
-     * A reduce should fail with an IllegalArgumentException if done on an empty Observable.
+     * A reduce should fail with an NoSuchElementException if done on an empty Observable.
      */
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testReduceWithEmptyObservable() {
         Observable<Integer> observable = Observable.range(1, 0);
         observable.reduce(new Func2<Integer, Integer, Integer>() {
diff --git a/rxjava-core/src/test/java/rx/ZipTests.java b/rxjava-core/src/test/java/rx/ZipTests.java
index 8735cb2e66..e8cd9a90dd 100644
--- a/rxjava-core/src/test/java/rx/ZipTests.java
+++ b/rxjava-core/src/test/java/rx/ZipTests.java
@@ -21,6 +21,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.NoSuchElementException;
 
 import org.junit.Test;
 
@@ -100,9 +101,9 @@ public void testCovarianceOfZip() {
      * Occasionally zip may be invoked with 0 observables. Test that we don't block indefinitely instead
      * of immediately invoking zip with 0 argument.
      * 
-     * We now expect an IllegalArgumentException since last() requires at least one value and nothing will be emitted.
+     * We now expect an NoSuchElementException since last() requires at least one value and nothing will be emitted.
      */
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void nonBlockingObservable() {
 
         final Object invoked = new Object();
diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
index 50b3d8f161..663f5d95f6 100644
--- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
@@ -52,7 +52,7 @@ public void testLast() {
         assertEquals("three", obs.last());
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testLastEmptyObservable() {
         BlockingObservable<Object> obs = BlockingObservable.from(Observable.empty());
         obs.last();
@@ -175,7 +175,7 @@ public void testSingleWrong() {
         observable.single();
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testSingleWrongPredicate() {
         BlockingObservable<Integer> observable = BlockingObservable.from(Observable.from(-1));
         observable.single(new Func1<Integer, Boolean>() {
@@ -319,7 +319,7 @@ public void testFirst() {
         assertEquals("one", observable.first());
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testFirstWithEmpty() {
         BlockingObservable.from(Observable.<String> empty()).first();
     }
@@ -336,7 +336,7 @@ public Boolean call(String args) {
         assertEquals("three", first);
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testFirstWithPredicateAndEmpty() {
         BlockingObservable<String> observable = BlockingObservable.from(Observable.from("one", "two", "three"));
         observable.first(new Func1<String, Boolean>() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
index 84f1b6aee0..369b29ce7e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
@@ -19,6 +19,8 @@
 import static org.mockito.Mockito.*;
 import static org.mockito.MockitoAnnotations.*;
 
+import java.util.NoSuchElementException;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -127,7 +129,7 @@ public void testFirstWithEmpty() {
 
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -189,7 +191,7 @@ public Boolean call(Integer t1) {
 
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         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 6cb6d44ff5..7f9009625a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
@@ -15,9 +15,13 @@
  */
 package rx.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.isA;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+
+import java.util.NoSuchElementException;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -34,7 +38,7 @@ public void testLastWithElements() {
         assertEquals(3, last.toBlockingObservable().single().intValue());
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testLastWithNoElements() {
         Observable<?> last = Observable.empty().last();
         last.toBlockingObservable().single();
@@ -90,7 +94,7 @@ public void testLastWithEmpty() {
 
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -152,7 +156,7 @@ public Boolean call(Integer t1) {
 
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
index cad4805c7c..bf0ebe59a0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
@@ -23,6 +23,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -56,7 +57,7 @@ public void testMinWithEmpty() {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -96,7 +97,7 @@ public int compare(Integer o1, Integer o2) {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -216,7 +217,7 @@ public void testMaxWithEmpty() {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -256,7 +257,7 @@ public int compare(Integer o1, Integer o2) {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
index fd091bdaef..111f694637 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
@@ -20,6 +20,7 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.NoSuchElementException;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -211,9 +212,9 @@ public String call(String arg0) {
     }
 
     /**
-     * While mapping over range(1,1).last() we expect IllegalArgumentException since the sequence is empty.
+     * While mapping over range(1,0).last() we expect NoSuchElementException since the sequence is empty.
      */
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testErrorPassesThruMap() {
         Observable.range(1, 0).last().map(new Func1<Integer, Integer>() {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSingleTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSingleTest.java
index baf83929ec..54673db194 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSingleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSingleTest.java
@@ -18,6 +18,8 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
+import java.util.NoSuchElementException;
+
 import org.junit.Test;
 import org.mockito.InOrder;
 
@@ -65,7 +67,7 @@ public void testSingleWithEmpty() {
 
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -127,7 +129,7 @@ public Boolean call(Integer t1) {
 
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
index 7862c9f49a..51e1395e3d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -24,6 +24,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.NoSuchElementException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -1034,10 +1035,10 @@ public Object call(final Object... args) {
     }
 
     /**
-     * Expect IllegalArgumentException instead of blocking forever as zip should emit onCompleted and no onNext
+     * Expect NoSuchElementException instead of blocking forever as zip should emit onCompleted and no onNext
      * and last() expects at least a single response.
      */
-    @Test(expected = IllegalArgumentException.class)
+    @Test(expected = NoSuchElementException.class)
     public void testZipEmptyListBlocking() {
 
         final Object invoked = new Object();

From badadd14064f58e6f687e34eca519de31bda13aa Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 17 Mar 2014 21:41:20 +0800
Subject: [PATCH 136/422] Rename OperationFirstOrDefaultTest and
 OperationLastTest to OperatorFirstOrDefaultTest and OperatorLastTest

---
 ...{OperationFirstOrDefaultTest.java => OperatorFirstTest.java} | 2 +-
 .../operators/{OperationLastTest.java => OperatorLastTest.java} | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename rxjava-core/src/test/java/rx/operators/{OperationFirstOrDefaultTest.java => OperatorFirstTest.java} (99%)
 rename rxjava-core/src/test/java/rx/operators/{OperationLastTest.java => OperatorLastTest.java} (99%)

diff --git a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFirstTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorFirstTest.java
index 369b29ce7e..2408a6004d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorFirstTest.java
@@ -30,7 +30,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 
-public class OperationFirstOrDefaultTest {
+public class OperatorFirstTest {
 
     @Mock
     Observer<String> w;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorLastTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationLastTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorLastTest.java
index 7f9009625a..5eee929fbd 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorLastTest.java
@@ -30,7 +30,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 
-public class OperationLastTest {
+public class OperatorLastTest {
 
     @Test
     public void testLastWithElements() {

From b8524108ac3f6a486d32e0a333e88ce9aa5946a5 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 17 Mar 2014 23:26:56 +0800
Subject: [PATCH 137/422] Fix clojure test

---
 .../src/test/clojure/rx/lang/clojure/blocking_test.clj          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
index df8e9fae1e..260e6a3dc5 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/blocking_test.clj
@@ -36,7 +36,7 @@
   (testing "returns one element"
     (is (= 1 (b/single (rx/return 1)))))
   (testing "throw if empty"
-    (is (thrown? java.lang.IllegalArgumentException (b/single (rx/empty)))))
+    (is (thrown? java.util.NoSuchElementException (b/single (rx/empty)))))
   (testing "throw if many"
     (is (thrown? java.lang.IllegalArgumentException (b/single (rx/seq->o [1 2])))))
   (testing "rethrows errors"

From 88679528fa96c0b0dbeb0da14f35566279fde8ff Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 17 Mar 2014 23:48:22 +0800
Subject: [PATCH 138/422] Fix tests in rxjava-math

---
 .../test/java/rx/math/operators/OperationMinMaxTest.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
index 63eee7b28f..64d0a38f4d 100644
--- a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
@@ -23,6 +23,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 import org.junit.Test;
 import org.mockito.InOrder;
@@ -56,7 +57,7 @@ public void testMinWithEmpty() {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -96,7 +97,7 @@ public int compare(Integer o1, Integer o2) {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -216,7 +217,7 @@ public void testMaxWithEmpty() {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 
@@ -256,7 +257,7 @@ public int compare(Integer o1, Integer o2) {
         observable.subscribe(observer);
         InOrder inOrder = inOrder(observer);
         inOrder.verify(observer, times(1)).onError(
-                isA(IllegalArgumentException.class));
+                isA(NoSuchElementException.class));
         inOrder.verifyNoMoreInteractions();
     }
 

From 00703cfffdc6687f460445eecd3d6b8a801acf17 Mon Sep 17 00:00:00 2001
From: George Campbell <gscampbell@netflix.com>
Date: Wed, 19 Mar 2014 23:04:01 -0700
Subject: [PATCH 139/422] Notifications for the allocation adverse.

---
 .../java/rx/observers/SerializedObserver.java |  44 +----
 .../rx/operators/BufferUntilSubscriber.java   |  39 +---
 .../java/rx/operators/NotificationLite.java   | 167 ++++++++++++++++++
 .../java/rx/operators/OperatorObserveOn.java  |  39 +---
 .../operators/OperatorObserveOnBounded.java   |  58 ++----
 .../main/java/rx/operators/OperatorZip.java   |  42 +++--
 6 files changed, 226 insertions(+), 163 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/NotificationLite.java

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 93f1632973..8c87a7b855 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -2,7 +2,11 @@
 
 import java.util.ArrayList;
 
+import javax.management.NotificationListener;
+
+import rx.Notification;
 import rx.Observer;
+import rx.operators.NotificationLite;
 
 /**
  * Enforce single-threaded, serialized, ordered execution of onNext, onCompleted, onError.
@@ -22,21 +26,7 @@ public class SerializedObserver<T> implements Observer<T> {
     private boolean emitting = false;
     private boolean terminated = false;
     private ArrayList<Object> queue = new ArrayList<Object>();
-
-    private static Sentinel NULL_SENTINEL = new Sentinel();
-    private static Sentinel COMPLETE_SENTINEL = new Sentinel();
-
-    private static class Sentinel {
-
-    }
-
-    private static class ErrorSentinel extends Sentinel {
-        final Throwable e;
-
-        ErrorSentinel(Throwable e) {
-            this.e = e;
-        }
-    }
+    private NotificationLite<T> on = NotificationLite.instance();
 
     public SerializedObserver(Observer<? super T> s) {
         this.actual = s;
@@ -61,7 +51,7 @@ public void onCompleted() {
                 }
             } else {
                 // someone else is already emitting so just queue it
-                queue.add(COMPLETE_SENTINEL);
+                queue.add(on.completed());
             }
         }
         if (canEmit) {
@@ -97,7 +87,7 @@ public void onError(final Throwable e) {
             } else {
                 // someone else is already emitting so just queue it ... after eliminating the queue to shortcut
                 queue.clear();
-                queue.add(new ErrorSentinel(e));
+                queue.add(on.error(e));
             }
         }
         if (canEmit) {
@@ -131,11 +121,7 @@ public void onNext(T t) {
                 }
             } else {
                 // someone else is already emitting so just queue it
-                if (t == null) {
-                    queue.add(NULL_SENTINEL);
-                } else {
-                    queue.add(t);
-                }
+                queue.add(on.next(t));
             }
         }
         if (canEmit) {
@@ -168,19 +154,7 @@ public void drainQueue(ArrayList<Object> list) {
             return;
         }
         for (Object v : list) {
-            if (v != null) {
-                if (v instanceof Sentinel) {
-                    if (v == NULL_SENTINEL) {
-                        actual.onNext(null);
-                    } else if (v == COMPLETE_SENTINEL) {
-                        actual.onCompleted();
-                    } else if (v instanceof ErrorSentinel) {
-                        actual.onError(((ErrorSentinel) v).e);
-                    }
-                } else {
-                    actual.onNext((T) v);
-                }
-            }
+            on.accept(actual, v);
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index 7526674636..c849421ee5 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -17,6 +17,7 @@
 
 import java.util.LinkedList;
 import java.util.Queue;
+
 import rx.Subscriber;
 import rx.subscriptions.CompositeSubscription;
 
@@ -36,21 +37,8 @@ public class BufferUntilSubscriber<T> extends Subscriber<T> {
     private final Queue<Object> queue = new LinkedList<Object>();
     /** 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. */
-    private static final Object COMPLETE_SENTINEL = new Object();
-    /**
-     * Container for an onError event.
-     */
-    private static final class ErrorSentinel {
-        final Throwable t;
+    private final NotificationLite<T> on = NotificationLite.instance();
 
-        public ErrorSentinel(Throwable t) {
-            this.t = t;
-        }
-        
-    }
     /**
      * Constructor that wraps the actual subscriber and shares its subscription.
      * @param capacity the queue capacity to accept before blocking, negative value indicates an unbounded queue
@@ -85,22 +73,7 @@ public void enterPassthroughMode() {
                     while (!queue.isEmpty()) {
                         Object o = queue.poll();
                         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();
-                            }
+                            on.accept(actual, o);
                         }
                     }
                     passthroughMode = true;
@@ -115,7 +88,7 @@ public void onNext(T t) {
             synchronized (gate) {
                 if (!passthroughMode) {
                     if (capacity < 0 || queue.size() < capacity) {
-                        queue.offer(t != null ? t : NULL_SENTINEL);
+                        queue.offer(on.next(t));
                         return;
                     }
                     try {
@@ -142,7 +115,7 @@ public void onError(Throwable e) {
             synchronized (gate) {
                 if (!passthroughMode) {
                     if (capacity < 0 || queue.size() < capacity) {
-                        queue.offer(new ErrorSentinel(e));
+                        queue.offer(on.error(e));
                         return;
                     }
                     try {
@@ -169,7 +142,7 @@ public void onCompleted() {
             synchronized (gate) {
                 if (!passthroughMode) {
                     if (capacity < 0 || queue.size() < capacity) {
-                        queue.offer(COMPLETE_SENTINEL);
+                        queue.offer(on.completed());
                         return;
                     }
                     try {
diff --git a/rxjava-core/src/main/java/rx/operators/NotificationLite.java b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
new file mode 100644
index 0000000000..54e807855e
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
@@ -0,0 +1,167 @@
+package rx.operators;
+
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+import rx.Notification;
+import rx.Notification.Kind;
+import rx.Observer;
+
+/**
+ * For use in internal operators that need something like materialize and dematerialize wholly
+ * within the implementation of the operator but don't want to incur the allocation cost of actually
+ * creating {@link rx.Notification} objects for every onNext and onComplete.
+ * 
+ * An object is allocated inside {@link #error(Throwable)} to wrap the {@link Throwable} but this
+ * shouldn't effect performance because exceptions should be exceptionally rare.
+ * 
+ * It's implemented as a singleton to maintain some semblance of type safety that is completely
+ * non-existent.
+ * 
+ * @author gscampbell
+ * 
+ * @param <T>
+ */
+public final class NotificationLite<T> {
+    private NotificationLite() {
+    }
+
+    private static final NotificationLite INSTANCE = new NotificationLite();
+
+    @SuppressWarnings("unchecked")
+    public static <T> NotificationLite<T> instance() {
+        return INSTANCE;
+    }
+
+    private static final Object ON_COMPLETED_SENTINEL = new Serializable() {
+        private static final long serialVersionUID = 1;
+    };
+
+    private static final Object ON_NEXT_NULL_SENTINEL = new Serializable() {
+        private static final long serialVersionUID = 2;
+    };
+
+    private static class OnErrorSentinel implements Serializable {
+        private static final long serialVersionUID = 3;
+        private final Throwable e;
+
+        public OnErrorSentinel(Throwable e) {
+            this.e = e;
+        }
+    }
+
+    /**
+     * Creates a lite onNext notification for the value passed in without doing any allocation. Can
+     * be unwrapped and sent with the {@link #accept} method.
+     * 
+     * @param t
+     * @return
+     */
+    public Object next(T t) {
+        if (t == null)
+            return ON_NEXT_NULL_SENTINEL;
+        else
+            return t;
+    }
+
+    /**
+     * Creates a lite onComplete notification without doing any allocation. Can be unwrapped and
+     * sent with the {@link #accept} method.
+     * 
+     * @return
+     */
+    public Object completed() {
+        return ON_COMPLETED_SENTINEL;
+    }
+
+    /**
+     * Create a lite onError notification. This call does new up an object to wrap the
+     * {@link Throwable} but since there should only be one of these the performance impact should
+     * be small. Can be unwrapped and sent with the {@link #accept} method.
+     * 
+     * @param e
+     * @return
+     */
+    public Object error(Throwable e) {
+        return new OnErrorSentinel(e);
+    }
+
+    /**
+     * Unwraps the lite notification and calls the appropriate method on the {@link Observer}.
+     * 
+     * @param o
+     *            the {@link Observer} to call onNext, onCompleted or onError.
+     * @param n
+     * @throws IllegalArgumentException
+     *             if the notification is null.
+     * @throws NullPointerException
+     *             if the {@link Observer} is null.
+     */
+    @SuppressWarnings("unchecked")
+    public void accept(Observer<? super T> o, Object n) {
+        switch (kind(n)) {
+        case OnNext:
+            o.onNext(getValue(n));
+            break;
+        case OnCompleted:
+            o.onCompleted();
+            break;
+        case OnError:
+            o.onError(getError(n));
+            break;
+        }
+    }
+
+    public boolean isCompleted(Object n) {
+        return n == ON_COMPLETED_SENTINEL;
+    }
+
+    public boolean isError(Object n) {
+        return n instanceof OnErrorSentinel;
+    }
+
+    /**
+     * If there is custom logic that isn't as simple as call the right method on an {@link Observer}
+     * then this method can be used to get the {@link Notification.Kind}
+     * 
+     * @param n
+     * @return
+     */
+    public Kind kind(Object n) {
+        if (n == null)
+            throw new IllegalArgumentException("The lite notification can not be null");
+        else if (n == ON_COMPLETED_SENTINEL)
+            return Kind.OnCompleted;
+        else if (n instanceof OnErrorSentinel)
+            return Kind.OnError;
+        else
+            // value or ON_NEXT_NULL_SENTINEL but either way it's an OnNext
+            return Kind.OnNext;
+    }
+
+    /**
+     * returns value passed in {@link #next(Object)} method call. Bad things happen if you call this
+     * the onComplete or onError notification type. For performance you are expected to use this
+     * when it is appropriate.
+     * 
+     * @param n
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    public T getValue(Object n) {
+        return n == ON_NEXT_NULL_SENTINEL ? null : (T) n;
+    }
+
+    /**
+     * returns {@link Throwable} passed in {@link #error(Throwable)} method call. Bad things happen
+     * if you
+     * call this the onComplete or onNext notification type. For performance you are expected to use
+     * this when it is appropriate.
+     * 
+     * @param n
+     * @return The {@link Throwable} wrapped inside n
+     */
+    public Throwable getError(Object n) {
+        return ((OnErrorSentinel) n).e;
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index c2457dd8d2..9a3b6937f5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -55,20 +55,7 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
         }
     }
 
-    private static class Sentinel {
-
-    }
-
-    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) {
-            this.e = e;
-        }
-    }
+    private final NotificationLite<T> on = NotificationLite.instance();
 
     /** Observe through individual queue per observer. */
     private class ObserveOnSubscriber extends Subscriber<T> {
@@ -85,23 +72,19 @@ public ObserveOnSubscriber(Subscriber<? super T> observer) {
 
         @Override
         public void onNext(final T t) {
-            if (t == null) {
-                queue.offer(NULL_SENTINEL);
-            } else {
-                queue.offer(t);
-            }
+            queue.offer(on.next(t));
             schedule();
         }
 
         @Override
         public void onCompleted() {
-            queue.offer(COMPLETE_SENTINEL);
+            queue.offer(on.completed());
             schedule();
         }
 
         @Override
         public void onError(final Throwable e) {
-            queue.offer(new ErrorSentinel(e));
+            queue.offer(on.error(e));
             schedule();
         }
 
@@ -134,19 +117,7 @@ public void call(Inner inner) {
         private void pollQueue() {
             do {
                 Object v = queue.poll();
-                if (v != null) {
-                    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);
-                    }
-                }
+                on.accept(observer, v);
             } while (counter.decrementAndGet() > 0);
         }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
index 97c53ae431..7901a86f4f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
@@ -32,17 +32,18 @@
 /**
  * Delivers events on the specified Scheduler.
  * <p>
- * This provides backpressure by blocking the incoming onNext when there is already one in the queue.
+ * This provides backpressure by blocking the incoming onNext when there is already one in the
+ * queue.
  * <p>
- * 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
+ * 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.
+ * 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.
  * 
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/observeOn.png">
  */
@@ -97,16 +98,7 @@ public Subscriber<? super T> call(Subscriber<? super T> 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;
-        }
-    }
+    private final NotificationLite<T> on = NotificationLite.instance();
 
     /** Observe through individual queue per observer. */
     private class ObserveOnSubscriber extends Subscriber<T> {
@@ -126,11 +118,7 @@ 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);
-                }
+                queue.addBlocking(on.next(t));
                 schedule();
             } catch (InterruptedException e) {
                 if (!isUnsubscribed()) {
@@ -144,7 +132,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.addBlocking(COMPLETE_SENTINEL);
+                queue.addBlocking(on.completed());
                 schedule();
             } catch (InterruptedException e) {
                 onError(e);
@@ -156,7 +144,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.addBlocking(new ErrorSentinel(e));
+                queue.addBlocking(on.error(e));
                 schedule();
             } catch (InterruptedException e2) {
                 // call directly if we can't schedule
@@ -205,26 +193,18 @@ public void call(Inner inner) {
         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);
-                    }
-                }
+                on.accept(observer, v);
             } while (counter.decrementAndGet() > 0);
         }
 
     }
 
     /**
-     * Single-producer-single-consumer queue (only thread-safe for 1 producer thread with 1 consumer thread).
+     * 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
+     * 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 <E>
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index 21da75d417..9ecc99b376 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -134,6 +134,7 @@ public void onNext(Observable[] observables) {
         };
     }
 
+    static final NotificationLite on = NotificationLite.instance();
     private static class Zip<R> {
         @SuppressWarnings("rawtypes")
         final Observable[] os;
@@ -141,9 +142,7 @@ private static class Zip<R> {
         final Observer<? super R> observer;
         final FuncN<? extends R> 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<? super R> observer, FuncN<? extends R> zipFunction) {
@@ -180,23 +179,26 @@ public void zip() {
         void tick() {
             if (counter.getAndIncrement() == 0) {
                 do {
-                    Object[] vs = new Object[observers.length];
+                    final Object[] vs = new Object[observers.length];
                     boolean allHaveValues = true;
                     for (int i = 0; i < observers.length; i++) {
-                        vs[i] = ((InnerObserver) observers[i]).items.peek();
-                        if (vs[i] == NULL_SENTINEL) {
-                            // special handling for null
-                            vs[i] = null;
-                        } else if (vs[i] == COMPLETE_SENTINEL) {
-                            // special handling for onComplete
+                        Object n = ((InnerObserver) observers[i]).items.peek();
+
+                        if (n == null) {
+                            allHaveValues = false;
+                            continue;
+                        }
+
+                        switch (on.kind(n)) {
+                        case OnNext:
+                            vs[i] = on.getValue(n);
+                            break;
+                        case OnCompleted:
                             observer.onCompleted();
-                            // we need to unsubscribe from all children since children are independently subscribed
+                            // we need to unsubscribe from all children since children are
+                            // independently subscribed
                             childSubscription.unsubscribe();
                             return;
-                        } else if (vs[i] == null) {
-                            allHaveValues = false;
-                            // we continue as there may be an onCompleted on one of the others
-                            continue;
                         }
                     }
                     if (allHaveValues) {
@@ -211,7 +213,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() == COMPLETE_SENTINEL) {
+                            if (on.isCompleted(((InnerObserver) observers[i]).items.peek())) {
                                 // it is an onComplete so shut down
                                 observer.onCompleted();
                                 // we need to unsubscribe from all children since children are independently subscribed
@@ -235,7 +237,7 @@ final class InnerObserver extends Subscriber {
             @SuppressWarnings("unchecked")
             @Override
             public void onCompleted() {
-                items.add(COMPLETE_SENTINEL);
+                items.add(on.completed());
                 tick();
             }
 
@@ -248,11 +250,7 @@ public void onError(Throwable e) {
             @SuppressWarnings("unchecked")
             @Override
             public void onNext(Object t) {
-                if (t == null) {
-                    items.add(NULL_SENTINEL);
-                } else {
-                    items.add(t);
-                }
+                items.add(on.next(t));
                 tick();
             }
         };

From ceff938a5b31dc992d2db0e8aa5e4b1735b0468e Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 20 Mar 2014 13:59:28 +0100
Subject: [PATCH 140/422] Fixed deadlock in Subjects + OperatorCache.

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 ...OperationCache.java => OperatorCache.java} |  52 +++---
 .../main/java/rx/subjects/AsyncSubject.java   |  23 ++-
 .../java/rx/subjects/BehaviorSubject.java     |  25 +--
 .../main/java/rx/subjects/PublishSubject.java |  20 ++-
 .../main/java/rx/subjects/ReplaySubject.java  |  26 +--
 .../subjects/SubjectSubscriptionManager.java  |   8 +-
 .../java/rx/operators/OperationCacheTest.java |  87 ---------
 .../java/rx/operators/OperatorCacheTest.java  | 168 ++++++++++++++++++
 9 files changed, 262 insertions(+), 151 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationCache.java => OperatorCache.java} (56%)
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 235e1e62e4..bc20108ade 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -56,7 +56,6 @@
 import rx.operators.OperationAsObservable;
 import rx.operators.OperationAverage;
 import rx.operators.OperationBuffer;
-import rx.operators.OperationCache;
 import rx.operators.OperationCombineLatest;
 import rx.operators.OperationConcat;
 import rx.operators.OperationDebounce;
@@ -105,6 +104,7 @@
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
 import rx.operators.OperatorAmb;
+import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorFilter;
@@ -3863,7 +3863,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialC
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-cache">RxJava Wiki: cache()</a>
      */
     public final Observable<T> cache() {
-        return create(OperationCache.cache(this));
+        return create(new OperatorCache<T>(this));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCache.java b/rxjava-core/src/main/java/rx/operators/OperatorCache.java
similarity index 56%
rename from rxjava-core/src/main/java/rx/operators/OperationCache.java
rename to rxjava-core/src/main/java/rx/operators/OperatorCache.java
index eb10bc9ab6..6f3385f1de 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCache.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCache.java
@@ -18,10 +18,13 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.subjects.ReplaySubject;
+import rx.subjects.Subject;
 
 /**
  * This method has similar behavior to {@link Observable#replay()} except that this auto-subscribes
@@ -35,30 +38,35 @@
  * NOTE: You sacrifice the ability to unsubscribe from the origin when you use this operator, so be
  * careful not to use this operator on Observables that emit infinite or very large numbers of
  * items, as this will use up memory.
+ * 
+ * @param <T> the cached value type
  */
-public class OperationCache {
-
-    public static <T> OnSubscribeFunc<T> cache(final Observable<? extends T> source) {
-        return new OnSubscribeFunc<T>() {
-
-            final AtomicBoolean subscribed = new AtomicBoolean(false);
-            private final ReplaySubject<T> cache = ReplaySubject.create();
+public final class OperatorCache<T> implements OnSubscribe<T> {
+    protected final Observable<? extends T> source;
+    protected final Subject<? super T, ? extends T> cache;
+    protected final AtomicBoolean sourceSubscribed;
 
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                if (subscribed.compareAndSet(false, true)) {
-                    // subscribe to the source once
-                    source.subscribe(cache);
-                    /*
-                     * Note that we will never unsubscribe from 'source' as we want to receive and cache all of its values.
-                     * 
-                     * This means this should never be used on an infinite or very large sequence, similar to toList().
-                     */
-                }
-
-                return cache.subscribe(observer);
-            }
+    public OperatorCache(Observable<? extends T> source) {
+        this(source, ReplaySubject.<T>create());
+    }
+    
+    /** Test support. */
+    public OperatorCache(Observable<? extends T> source, Subject<? super T, ? extends T> cache) {
+        this.source = source;
+        this.cache = cache;
+        this.sourceSubscribed = new AtomicBoolean();
+    }
 
-        };
+    @Override
+    public void call(Subscriber<? super T> t1) {
+        if (sourceSubscribed.compareAndSet(false, true)) {
+            source.subscribe(cache);
+            /*
+             * Note that we will never unsubscribe from 'source' as we want to receive and cache all of its values.
+             * 
+             * This means this should never be used on an infinite or very large sequence, similar to toList().
+             */
+        }
+        cache.subscribe(t1);
     }
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index 7b50cd9468..c2302d9890 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -105,35 +105,40 @@ protected AsyncSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T>
 
     @Override
     public void onCompleted() {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
 
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
-                for (Observer<? super T> o : observers) {
-                    emitValueToObserver(lastNotification.get(), o);
-                }
             }
         });
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                emitValueToObserver(lastNotification.get(), o);
+            }
+        }
     }
 
     @Override
     public void onError(final Throwable e) {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
-
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
-                lastNotification.set(new Notification<T>(e));
-                for (Observer<? super T> o : observers) {
-                    emitValueToObserver(lastNotification.get(), o);
-                }
+                lastNotification.set(Notification.<T>createOnError(e));
             }
         });
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                emitValueToObserver(lastNotification.get(), o);
+            }
+        }
 
     }
 
     @Override
     public void onNext(T v) {
-        lastNotification.set(new Notification<T>(v));
+        lastNotification.set(Notification.createOnNext(v));
     }
 
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index f59dc03133..5f2010fd85 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -144,31 +144,36 @@ protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager
 
     @Override
     public void onCompleted() {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
 
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
-                lastNotification.set(new Notification<T>());
-                for (Observer<? super T> o : observers) {
-                    o.onCompleted();
-                }
+                lastNotification.set(Notification.<T>createOnCompleted());
             }
         });
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                o.onCompleted();
+            }
+        }
     }
 
     @Override
     public void onError(final Throwable e) {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
 
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
-                lastNotification.set(new Notification<T>(e));
-                for (Observer<? super T> o : observers) {
-                    o.onError(e);
-                }
+                lastNotification.set(Notification.<T>createOnError(e));
             }
         });
-
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                o.onError(e);
+            }
+        }
     }
 
     @Override
@@ -176,7 +181,7 @@ public void onNext(T v) {
         // do not overwrite a terminal notification
         // so new subscribers can get them
         if (lastNotification.get().isOnNext()) {
-            lastNotification.set(new Notification<T>(v));
+            lastNotification.set(Notification.createOnNext(v));
             for (Observer<? super T> 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 4d94a087fd..687d039e6a 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -95,31 +95,35 @@ protected PublishSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<
 
     @Override
     public void onCompleted() {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
-
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
                 lastNotification.set(Notification.<T> createOnCompleted());
-                for (Observer<? super T> o : observers) {
-                    o.onCompleted();
-                }
             }
         });
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                o.onCompleted();
+            }
+        }
     }
 
     @Override
     public void onError(final Throwable e) {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
 
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
                 lastNotification.set(Notification.<T>createOnError(e));
-                for (Observer<? super T> o : observers) {
-                    o.onError(e);
-                }
             }
         });
-
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                o.onError(e);
+            }
+        }
     }
 
     @Override
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 7d659822c2..01107efa20 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -122,34 +122,40 @@ protected ReplaySubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T
 
     @Override
     public void onCompleted() {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
 
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
                 state.history.complete(Notification.<T>createOnCompleted());
-                for (SubjectObserver<? super T> o : observers) {
-                    if (caughtUp(o)) {
-                        o.onCompleted();
-                    }
-                }
             }
         });
+        if (observers != null) {
+            for (SubjectObserver<? super T> o : observers) {
+                if (caughtUp(o)) {
+                    o.onCompleted();
+                }
+            }
+        }
     }
 
     @Override
     public void onError(final Throwable e) {
+        Collection<SubjectObserver<? super T>> observers =
         subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
 
             @Override
             public void call(Collection<SubjectObserver<? super T>> observers) {
                 state.history.complete(Notification.<T>createOnError(e));
-                for (SubjectObserver<? super T> o : observers) {
-                    if (caughtUp(o)) {
-                        o.onError(e);
-                    }
-                }
             }
         });
+        if (observers != null) {
+            for (SubjectObserver<? super T> o : observers) {
+                if (caughtUp(o)) {
+                    o.onError(e);
+                }
+            }
+        }
     }
 
     @Override
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 6f049eb38a..8022f9723d 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -113,19 +113,20 @@ public void call() {
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
-    protected void terminate(Action1<Collection<SubjectObserver<? super T>>> onTerminate) {
+    protected Collection<SubjectObserver<? super T>> terminate(Action1<Collection<SubjectObserver<? super T>>> onTerminate) {
         State<T> current;
         State<T> newState = null;
         do {
             current = state.get();
             if (current.terminated) {
                 // already terminated so do nothing
-                return;
+                return null;
             } else {
                 newState = current.terminate();
             }
         } while (!state.compareAndSet(current, newState));
 
+        Collection<SubjectObserver<? super T>> observerCollection = (Collection)Arrays.asList(newState.observers);
         /*
          * if we get here then we won setting the state to terminated
          * and have a deterministic set of Observers to emit to (concurrent subscribes
@@ -134,11 +135,12 @@ protected void terminate(Action1<Collection<SubjectObserver<? super T>>> onTermi
          */
         try {
             // had to circumvent type check, we know what the array contains
-            onTerminate.call((Collection) Arrays.asList(newState.observers));
+            onTerminate.call(observerCollection);
         } finally {
             // mark that termination is completed
             newState.terminationLatch.countDown();
         }
+        return observerCollection;
     }
 
     /**
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java b/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
deleted file mode 100644
index 8637eb8521..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationCacheTest.java
+++ /dev/null
@@ -1,87 +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.junit.Assert.*;
-import static rx.operators.OperationCache.*;
-
-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.Subscription;
-import rx.functions.Action1;
-import rx.subscriptions.BooleanSubscription;
-
-public class OperationCacheTest {
-
-    @Test
-    public void testCache() throws InterruptedException {
-        final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(cache(Observable.create(new Observable.OnSubscribeFunc<String>() {
-
-            @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
-                final BooleanSubscription subscription = new BooleanSubscription();
-                new Thread(new Runnable() {
-
-                    @Override
-                    public void run() {
-                        counter.incrementAndGet();
-                        System.out.println("published observable being executed");
-                        observer.onNext("one");
-                        observer.onCompleted();
-                    }
-                }).start();
-                return subscription;
-            }
-        })));
-
-        // we then expect the following 2 subscriptions to get that same value
-        final CountDownLatch latch = new CountDownLatch(2);
-
-        // subscribe once
-        o.subscribe(new Action1<String>() {
-
-            @Override
-            public void call(String v) {
-                assertEquals("one", v);
-                System.out.println("v: " + v);
-                latch.countDown();
-            }
-        });
-
-        // subscribe again
-        o.subscribe(new Action1<String>() {
-
-            @Override
-            public void call(String v) {
-                assertEquals("one", v);
-                System.out.println("v: " + v);
-                latch.countDown();
-            }
-        });
-
-        if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
-            fail("subscriptions did not receive values");
-        }
-        assertEquals(1, counter.get());
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java b/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
new file mode 100644
index 0000000000..3a6c170c56
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
@@ -0,0 +1,168 @@
+/**
+ * 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.Arrays;
+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.Subscription;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.observers.TestObserver;
+import rx.schedulers.Schedulers;
+import rx.subjects.AsyncSubject;
+import rx.subjects.BehaviorSubject;
+import rx.subjects.PublishSubject;
+import rx.subjects.ReplaySubject;
+import rx.subjects.Subject;
+import rx.subscriptions.BooleanSubscription;
+
+public class OperatorCacheTest {
+
+    @Test
+    public void testCache() throws InterruptedException {
+        final AtomicInteger counter = new AtomicInteger();
+        Observable<String> o = Observable.create(new Observable.OnSubscribeFunc<String>() {
+
+            @Override
+            public Subscription onSubscribe(final Observer<? super String> observer) {
+                final BooleanSubscription subscription = new BooleanSubscription();
+                new Thread(new Runnable() {
+
+                    @Override
+                    public void run() {
+                        counter.incrementAndGet();
+                        System.out.println("published observable being executed");
+                        observer.onNext("one");
+                        observer.onCompleted();
+                    }
+                }).start();
+                return subscription;
+            }
+        }).cache();
+
+        // we then expect the following 2 subscriptions to get that same value
+        final CountDownLatch latch = new CountDownLatch(2);
+
+        // subscribe once
+        o.subscribe(new Action1<String>() {
+
+            @Override
+            public void call(String v) {
+                assertEquals("one", v);
+                System.out.println("v: " + v);
+                latch.countDown();
+            }
+        });
+
+        // subscribe again
+        o.subscribe(new Action1<String>() {
+
+            @Override
+            public void call(String v) {
+                assertEquals("one", v);
+                System.out.println("v: " + v);
+                latch.countDown();
+            }
+        });
+
+        if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
+            fail("subscriptions did not receive values");
+        }
+        assertEquals(1, counter.get());
+    }
+    void testWithCustomSubjectAndRepeat(Subject<Integer, Integer> subject, Integer... expected) {
+        Observable<Integer> source0 = Observable.from(1, 2, 3)
+                .subscribeOn(Schedulers.io())
+                .flatMap(new Func1<Integer, Observable<Integer>>() {
+                    @Override
+                    public Observable<Integer> call(final Integer i) {
+                        return Observable.timer(i * 20, TimeUnit.MILLISECONDS).map(new Func1<Long, Integer>() {
+                            @Override
+                            public Integer call(Long t1) {
+                                return i;
+                            }
+                        });
+                    }
+                });
+        
+        Observable<Integer> source1 = Observable.create(new OperatorCache<Integer>(source0, subject));
+        
+        Observable<Integer> source2 = source1
+                .repeat(4)
+                .zip(Observable.timer(0, 10, TimeUnit.MILLISECONDS, Schedulers.newThread()), new Func2<Integer, Long, Integer>() {
+                    @Override
+                    public Integer call(Integer t1, Long t2) {
+                        return t1;
+                    }
+                    
+                });
+        final CountDownLatch cdl = new CountDownLatch(1);
+        TestObserver<Integer> test = new TestObserver<Integer>(new Observer<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                cdl.countDown();
+            }
+
+            @Override
+            public void onCompleted() {
+                cdl.countDown();
+            }
+        });
+        source2.subscribe(test);
+
+        try {
+            cdl.await(20, TimeUnit.SECONDS);
+        } catch (InterruptedException ex) {
+            fail("Interrupted");
+        }
+        
+        test.assertReceivedOnNext(Arrays.asList(expected));
+        test.assertTerminalEvent();
+        assertTrue(test.getOnErrorEvents().isEmpty());
+    }
+    @Test(timeout = 10000)
+    public void testWithAsyncSubjectAndRepeat() {
+        testWithCustomSubjectAndRepeat(AsyncSubject.<Integer>create(), 3, 3, 3, 3);
+    }
+    @Test(timeout = 10000)
+    public void testWithBehaviorSubjectAndRepeat() {
+        // BehaviorSubject just completes when repeated
+        testWithCustomSubjectAndRepeat(BehaviorSubject.create(0), 0, 1, 2, 3);
+    }
+    @Test(timeout = 10000)
+    public void testWithPublishSubjectAndRepeat() {
+        // PublishSubject just completes when repeated
+        testWithCustomSubjectAndRepeat(PublishSubject.<Integer>create(), 1, 2, 3);
+    }
+    @Test(timeout = 10000)
+    public void testWithReplaySubjectAndRepeat() {
+        testWithCustomSubjectAndRepeat(ReplaySubject.<Integer>create(), 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3);
+    }
+}

From 352e7fa5b44b586b3cd26f067975384e5494ff06 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 20 Mar 2014 09:53:56 -0700
Subject: [PATCH 141/422] Merge with Serialize

- concurrency unit tests
- handle Observable that emits onComplete multiple times
---
 .../main/java/rx/operators/OperatorMerge.java |  13 +-
 .../java/rx/operators/OperatorMergeTest.java  | 120 +++++++++++++++++-
 2 files changed, 127 insertions(+), 6 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
index b3d822ca84..15843ff19f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
@@ -68,15 +68,22 @@ public void onNext(Observable<? extends T> innerObservable) {
 
             final class InnerObserver extends Subscriber<T> {
 
+                private boolean innerCompleted = false;
+
                 public InnerObserver() {
                 }
 
                 @Override
                 public void onCompleted() {
-                    if (runningCount.decrementAndGet() == 0 && completed) {
-                        o.onCompleted();
+                    if (!innerCompleted) {
+                        // we check if already completed otherwise a misbehaving Observable that emits onComplete more than once
+                        // will cause the runningCount to decrement multiple times.
+                        innerCompleted = true;
+                        if (runningCount.decrementAndGet() == 0 && completed) {
+                            o.onCompleted();
+                        }
+                        cleanup();
                     }
-                    cleanup();
                 }
 
                 @Override
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index 4afd9c07b8..934513d0db 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -15,9 +15,14 @@
  */
 package rx.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.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -37,6 +42,7 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -472,4 +478,112 @@ public void call() {
         });
     }
 
+    @Test
+    public void testConcurrency() {
+
+        Observable<Integer> o = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                Schedulers.newThread().schedule(new Action1<Inner>() {
+
+                    @Override
+                    public void call(Inner inner) {
+                        for (int i = 0; i < 10000; i++) {
+                            s.onNext(1);
+                        }
+                        s.onCompleted();
+                    }
+
+                });
+            }
+        });
+
+        for (int i = 0; i < 10; i++) {
+            Observable<Integer> merge = Observable.merge(o, o, o);
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            merge.subscribe(ts);
+
+            ts.awaitTerminalEvent();
+            assertEquals(1, ts.getOnCompletedEvents().size());
+            assertEquals(30000, ts.getOnNextEvents().size());
+            List<Integer> onNextEvents = ts.getOnNextEvents();
+            //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
+        }
+    }
+
+    @Test
+    public void testConcurrencyWithSleeping() {
+
+        Observable<Integer> o = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                Schedulers.newThread().schedule(new Action1<Inner>() {
+
+                    @Override
+                    public void call(Inner inner) {
+                        for (int i = 0; i < 100; i++) {
+                            s.onNext(1);
+                            try {
+                                Thread.sleep(1);
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                        s.onCompleted();
+                    }
+
+                });
+            }
+        });
+
+        for (int i = 0; i < 10; i++) {
+            Observable<Integer> merge = Observable.merge(o, o, o);
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            merge.subscribe(ts);
+
+            ts.awaitTerminalEvent();
+            assertEquals(1, ts.getOnCompletedEvents().size());
+            assertEquals(300, ts.getOnNextEvents().size());
+            List<Integer> onNextEvents = ts.getOnNextEvents();
+            //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
+        }
+    }
+
+    @Test
+    public void testConcurrencyWithBrokenOnCompleteContract() {
+
+        Observable<Integer> o = Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(final Subscriber<? super Integer> s) {
+                Schedulers.newThread().schedule(new Action1<Inner>() {
+
+                    @Override
+                    public void call(Inner inner) {
+                        for (int i = 0; i < 10000; i++) {
+                            s.onNext(1);
+                        }
+                        s.onCompleted();
+                        s.onCompleted();
+                        s.onCompleted();
+                    }
+
+                });
+            }
+        });
+
+        for (int i = 0; i < 100; i++) {
+            Observable<Integer> merge = Observable.merge(o, o, o);
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            merge.subscribe(ts);
+
+            ts.awaitTerminalEvent();
+            assertEquals(1, ts.getOnCompletedEvents().size());
+            assertEquals(30000, ts.getOnNextEvents().size());
+            List<Integer> onNextEvents = ts.getOnNextEvents();
+            //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
+        }
+    }
 }

From 9785ada2e5825b5882e225fc25ec34d073485f1f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 20 Mar 2014 10:38:58 -0700
Subject: [PATCH 142/422] TestSubject, TestObserver and TestScheduler
 Improvements

---
 .../main/java/rx/observers/TestObserver.java  |   4 +-
 .../java/rx/schedulers/TestScheduler.java     |   8 +-
 .../main/java/rx/subjects/TestSubject.java    | 182 ++++++++++++++++++
 .../java/rx/observers/TestObserverTest.java   |   2 +-
 4 files changed, 191 insertions(+), 5 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/subjects/TestSubject.java

diff --git a/rxjava-core/src/main/java/rx/observers/TestObserver.java b/rxjava-core/src/main/java/rx/observers/TestObserver.java
index f4e278118d..dd546359c8 100644
--- a/rxjava-core/src/main/java/rx/observers/TestObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/TestObserver.java
@@ -27,7 +27,6 @@
  */
 public class TestObserver<T> implements Observer<T> {
 
-
     private final Observer<T> delegate;
     private final ArrayList<T> onNextEvents = new ArrayList<T>();
     private final ArrayList<Throwable> onErrorEvents = new ArrayList<Throwable>();
@@ -91,7 +90,8 @@ public void assertReceivedOnNext(List<T> items) {
                     throw new AssertionError("Value at index: " + i + " expected to be [null] but was: [" + onNextEvents.get(i) + "]");
                 }
             } else if (!items.get(i).equals(onNextEvents.get(i))) {
-                throw new AssertionError("Value at index: " + i + " expected to be [" + items.get(i) + "] but was: [" + onNextEvents.get(i) + "]");
+                throw new AssertionError("Value at index: " + i + " expected to be [" + items.get(i) + "] (" + items.get(i).getClass().getSimpleName() + ") but was: [" + onNextEvents.get(i) + "] (" + onNextEvents.get(i).getClass().getSimpleName() + ")");
+
             }
         }
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
index 2bb9a11d40..1231c71fa4 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
@@ -97,9 +97,13 @@ private void triggerActions(long targetTimeInNanos) {
         time = targetTimeInNanos;
     }
 
+    public Inner createInnerScheduler() {
+        return new InnerTestScheduler();
+    }
+
     @Override
     public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        InnerTestScheduler inner = new InnerTestScheduler();
+        Inner inner = createInnerScheduler();
         final TimedAction timedAction = new TimedAction(inner, time + unit.toNanos(delayTime), action);
         queue.add(timedAction);
         return inner;
@@ -107,7 +111,7 @@ public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit uni
 
     @Override
     public Subscription schedule(Action1<Inner> action) {
-        InnerTestScheduler inner = new InnerTestScheduler();
+        Inner inner = createInnerScheduler();
         final TimedAction timedAction = new TimedAction(inner, 0, action);
         queue.add(timedAction);
         return inner;
diff --git a/rxjava-core/src/main/java/rx/subjects/TestSubject.java b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
new file mode 100644
index 0000000000..af3a02f3ee
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
@@ -0,0 +1,182 @@
+/**
+ * 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.subjects;
+
+import java.util.Collection;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Notification;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.functions.Action1;
+import rx.schedulers.TestScheduler;
+import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
+
+/**
+ * Subject that, once and {@link Observer} has subscribed, publishes all subsequent events to the subscriber.
+ * <p>
+ * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/S.PublishSubject.png">
+ * <p>
+ * Example usage:
+ * <p>
+ * <pre> {@code
+
+ * PublishSubject<Object> subject = PublishSubject.create();
+  // observer1 will receive all onNext and onCompleted events
+  subject.subscribe(observer1);
+  subject.onNext("one");
+  subject.onNext("two");
+  // observer2 will only receive "three" and onCompleted
+  subject.subscribe(observer2);
+  subject.onNext("three");
+  subject.onCompleted();
+
+  } </pre>
+ * 
+ * @param <T>
+ */
+public final class TestSubject<T> extends Subject<T, T> {
+
+    public static <T> TestSubject<T> create(TestScheduler scheduler) {
+        final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
+        // set a default value so subscriptions will immediately receive this until a new notification is received
+        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>();
+
+        OnSubscribe<T> onSubscribe = subscriptionManager.getOnSubscribeFunc(
+                /**
+                 * This function executes at beginning of subscription.
+                 * 
+                 * This will always run, even if Subject is in terminal state.
+                 */
+                new Action1<SubjectObserver<? super T>>() {
+
+                    @Override
+                    public void call(SubjectObserver<? super T> 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<SubjectObserver<? super T>>() {
+
+                    @Override
+                    public void call(SubjectObserver<? super T> 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 TestSubject<T>(onSubscribe, subscriptionManager, lastNotification, scheduler);
+    }
+
+    private final SubjectSubscriptionManager<T> subscriptionManager;
+    private final AtomicReference<Notification<T>> lastNotification;
+    private final Scheduler.Inner innerScheduler;
+
+    protected TestSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, AtomicReference<Notification<T>> lastNotification, TestScheduler scheduler) {
+        super(onSubscribe);
+        this.subscriptionManager = subscriptionManager;
+        this.lastNotification = lastNotification;
+        this.innerScheduler = scheduler.createInnerScheduler();
+    }
+
+    @Override
+    public void onCompleted() {
+        onCompleted(innerScheduler.now());
+    }
+
+    private void _onCompleted() {
+        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+
+            @Override
+            public void call(Collection<SubjectObserver<? super T>> observers) {
+                lastNotification.set(Notification.<T> createOnCompleted());
+                for (Observer<? super T> o : observers) {
+                    o.onCompleted();
+                }
+            }
+        });
+    }
+
+    public void onCompleted(long timeInMilliseconds) {
+        innerScheduler.schedule(new Action1<Inner>() {
+
+            @Override
+            public void call(Inner t1) {
+                _onCompleted();
+            }
+
+        }, timeInMilliseconds, TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public void onError(final Throwable e) {
+        onError(e, innerScheduler.now());
+    }
+
+    private void _onError(final Throwable e) {
+        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+
+            @Override
+            public void call(Collection<SubjectObserver<? super T>> observers) {
+                lastNotification.set(Notification.<T> createOnError(e));
+                for (Observer<? super T> o : observers) {
+                    o.onError(e);
+                }
+            }
+        });
+
+    }
+
+    public void onError(final Throwable e, long timeInMilliseconds) {
+        innerScheduler.schedule(new Action1<Inner>() {
+
+            @Override
+            public void call(Inner t1) {
+                _onError(e);
+            }
+
+        }, timeInMilliseconds, TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public void onNext(T v) {
+        onNext(v, innerScheduler.now());
+    }
+
+    private void _onNext(T v) {
+        for (Observer<? super T> o : subscriptionManager.rawSnapshot()) {
+            o.onNext(v);
+        }
+    }
+
+    public void onNext(final T v, long timeInMilliseconds) {
+        innerScheduler.schedule(new Action1<Inner>() {
+
+            @Override
+            public void call(Inner t1) {
+                _onNext(v);
+            }
+
+        }, timeInMilliseconds, TimeUnit.MILLISECONDS);
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/observers/TestObserverTest.java b/rxjava-core/src/test/java/rx/observers/TestObserverTest.java
index 70e22d8fb2..67883043bd 100644
--- a/rxjava-core/src/test/java/rx/observers/TestObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/TestObserverTest.java
@@ -66,7 +66,7 @@ public void testAssertNotMatchValue() {
         oi.subscribe(o);
 
         thrown.expect(AssertionError.class);
-        thrown.expectMessage("Value at index: 1 expected to be [3] but was: [2]");
+        thrown.expectMessage("Value at index: 1 expected to be [3] (Integer) but was: [2] (Integer)");
 
         o.assertReceivedOnNext(Arrays.asList(1, 3));
         assertEquals(2, o.getOnNextEvents().size());

From cbb6fda7364048c12fe931150eeb5afc8032cc24 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 20 Mar 2014 10:45:56 -0700
Subject: [PATCH 143/422] GroupBy & Time Gap Fixes

I ran head-on into the "time gap" (https://github.com/Netflix/RxJava/issues/844) issue while working on a stream processing use case (and new 'pivot' operator I'm writing).
This is a solution. It's still not ideal as the Javadocs of BufferUntilSubscriber mention, but this is working better than nothing and does not require blocking threads.
A better solution will come as part of the back pressure work where BufferUntilSubscriber will evolve to have a bounded buffer.
---
 .../rx/operators/BufferUntilSubscriber.java   | 271 ++++++------
 .../java/rx/operators/OperatorGroupBy.java    |  56 +--
 .../operators/OperatorSubscribeOnBounded.java | 112 -----
 .../rx/operators/OperatorGroupByTest.java     |  37 +-
 .../OperatorSubscribeOnBoundedTest.java       | 416 ------------------
 5 files changed, 211 insertions(+), 681 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java

diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index c849421ee5..d26f84debc 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -15,152 +15,175 @@
  */
 package rx.operators;
 
-import java.util.LinkedList;
-import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicReference;
 
+import rx.Observable;
+import rx.Observer;
 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 <T> the streamed value type
+ * A solution to the "time gap" problem that occurs with `groupBy` and `pivot` => https://github.com/Netflix/RxJava/issues/844
+ * 
+ * This currently has temporary unbounded buffers. It needs to become bounded and then do one of two things:
+ * 
+ * 1) blow up and make the user do something about it
+ * 2) work with the backpressure solution ... still to be implemented (such as co-routines)
+ * 
+ * Generally the buffer should be very short lived (milliseconds) and then stops being involved.
+ * It can become a memory leak though if a GroupedObservable backed by this class is emitted but never subscribed to (such as filtered out).
+ * In that case, either a time-bomb to throw away the buffer, or just blowing up and making the user do something about it is needed.
+ * 
+ * For example, to filter out GroupedObservables, perhaps they need a silent `subscribe()` on them to just blackhole the data.
+ * 
+ * This is an initial start at solving this problem and solves the immediate problem of `groupBy` and `pivot` and trades off the possibility of memory leak for deterministic functionality.
+ *
+ * @param <T>
  */
-public class BufferUntilSubscriber<T> extends Subscriber<T> {
-    /** The actual subscriber. */
-    private final Subscriber<? super T> actual;
-    /** Indicate the pass-through mode. */
-    private volatile boolean passthroughMode;
-    /** Protect mode transition. */
-    private final Object gate = new Object();
-    /** The buffered items. */
-    private final Queue<Object> queue = new LinkedList<Object>();
-    /** The queue capacity. */
-    private final int capacity;
-    private final NotificationLite<T> on = NotificationLite.instance();
+public class BufferUntilSubscriber<T> extends Observable<T> implements Observer<T> {
 
-    /**
-     * Constructor that wraps the actual subscriber and shares its subscription.
-     * @param capacity the queue capacity to accept before blocking, negative value indicates an unbounded queue
-     * @param actual
-     */
-    public BufferUntilSubscriber(int capacity, Subscriber<? super T> 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(int capacity, Subscriber<? super T> actual, CompositeSubscription cs) {
-        super(cs);
-        this.actual = actual;
-        this.capacity = capacity;
+    public static <T> BufferUntilSubscriber<T> create() {
+        return new BufferUntilSubscriber<T>(new AtomicReference<Observer<? super T>>(new BufferedObserver<T>()));
     }
-    
-    /**
-     * 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 (!actual.isUnsubscribed()) {
-                            on.accept(actual, o);
-                        }
-                    }
-                    passthroughMode = true;
-                    gate.notifyAll();
+
+    private final AtomicReference<Observer<? super T>> observerRef;
+
+    private BufferUntilSubscriber(final AtomicReference<Observer<? super T>> observerRef) {
+        super(new OnSubscribe<T>() {
+
+            @Override
+            public void call(Subscriber<? super T> s) {
+                // drain queued notifications before subscription
+                // we do this here before PassThruObserver so the consuming thread can do this before putting itself in the line of the producer
+                BufferedObserver<T> buffered = (BufferedObserver<T>) observerRef.get();
+                Object o = null;
+                while ((o = buffered.buffer.poll()) != null) {
+                    emit(s, o);
                 }
+                // register real observer for pass-thru ... and drain any further events received on first notification
+                observerRef.set(new PassThruObserver<T>(s, buffered.buffer, observerRef));
             }
-        }
+
+        });
+        this.observerRef = observerRef;
+    }
+
+    @Override
+    public void onCompleted() {
+        observerRef.get().onCompleted();
     }
+
+    @Override
+    public void onError(Throwable e) {
+        observerRef.get().onError(e);
+    }
+
     @Override
     public void onNext(T t) {
-        if (!passthroughMode) {
-            synchronized (gate) {
-                if (!passthroughMode) {
-                    if (capacity < 0 || queue.size() < capacity) {
-                        queue.offer(on.next(t));
-                        return;
-                    }
-                    try {
-                        while (!passthroughMode) {
-                            gate.wait();
-                        }
-                        if (actual.isUnsubscribed()) {
-                            return;
-                        }
-                    } catch (InterruptedException ex) {
-                        Thread.currentThread().interrupt();
-                        actual.onError(ex);
-                        return;
-                    }
-                }
+        observerRef.get().onNext(t);
+    }
+
+    /**
+     * This is a temporary observer between buffering and the actual that gets into the line of notifications
+     * from the producer and will drain the queue of any items received during the race of the initial drain and
+     * switching this.
+     * 
+     * It will then immediately swap itself out for the actual (after a single notification), but since this is now
+     * being done on the same producer thread no further buffering will occur.
+     */
+    private static class PassThruObserver<T> implements Observer<T> {
+
+        private final Observer<? super T> actual;
+        // this assumes single threaded synchronous notifications (the Rx contract for a single Observer)
+        private final ConcurrentLinkedQueue<Object> buffer;
+        private final AtomicReference<Observer<? super T>> observerRef;
+
+        PassThruObserver(Observer<? super T> actual, ConcurrentLinkedQueue<Object> buffer, AtomicReference<Observer<? super T>> observerRef) {
+            this.actual = actual;
+            this.buffer = buffer;
+            this.observerRef = observerRef;
+        }
+
+        @Override
+        public void onCompleted() {
+            drainIfNeededAndSwitchToActual();
+            actual.onCompleted();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            drainIfNeededAndSwitchToActual();
+            actual.onError(e);
+        }
+
+        @Override
+        public void onNext(T t) {
+            drainIfNeededAndSwitchToActual();
+            actual.onNext(t);
+        }
+
+        private void drainIfNeededAndSwitchToActual() {
+            Object o = null;
+            while ((o = buffer.poll()) != null) {
+                emit(this, o);
             }
+            // now we can safely change over to the actual and get rid of the pass-thru
+            observerRef.set(actual);
         }
-        actual.onNext(t);
+
     }
 
-    @Override
-    public void onError(Throwable e) {
-        if (!passthroughMode) {
-            synchronized (gate) {
-                if (!passthroughMode) {
-                    if (capacity < 0 || queue.size() < capacity) {
-                        queue.offer(on.error(e));
-                        return;
-                    }
-                    try {
-                        while (!passthroughMode) {
-                            gate.wait();
-                        }
-                        if (actual.isUnsubscribed()) {
-                            return;
-                        }
-                    } catch (InterruptedException ex) {
-                        Thread.currentThread().interrupt();
-                        actual.onError(ex);
-                        return;
-                    }
-                }
+    private static class BufferedObserver<T> implements Observer<T> {
+        private final ConcurrentLinkedQueue<Object> buffer = new ConcurrentLinkedQueue<Object>();
+
+        @Override
+        public void onCompleted() {
+            buffer.add(COMPLETE_SENTINEL);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            buffer.add(new ErrorSentinel(e));
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (t == null) {
+                buffer.add(NULL_SENTINEL);
+            } else {
+                buffer.add(t);
             }
         }
-        actual.onError(e);
+
     }
 
-    @Override
-    public void onCompleted() {
-        if (!passthroughMode) {
-            synchronized (gate) {
-                if (!passthroughMode) {
-                    if (capacity < 0 || queue.size() < capacity) {
-                        queue.offer(on.completed());
-                        return;
-                    }
-                    try {
-                        while (!passthroughMode) {
-                            gate.wait();
-                        }
-                        if (actual.isUnsubscribed()) {
-                            return;
-                        }
-                    } catch (InterruptedException ex) {
-                        Thread.currentThread().interrupt();
-                        actual.onError(ex);
-                        return;
-                    }
-                }
+    private final static <T> void emit(Observer<T> s, Object v) {
+        if (v instanceof Sentinel) {
+            if (v == NULL_SENTINEL) {
+                s.onNext(null);
+            } else if (v == COMPLETE_SENTINEL) {
+                s.onCompleted();
+            } else if (v instanceof ErrorSentinel) {
+                s.onError(((ErrorSentinel) v).e);
             }
+        } else {
+            s.onNext((T) v);
+        }
+    }
+
+    private static class Sentinel {
+
+    }
+
+    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) {
+            this.e = e;
         }
-        actual.onCompleted();
     }
 
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index a8e5ffb53f..2451939581 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -27,8 +27,6 @@
 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;
 
@@ -51,43 +49,50 @@ public Subscriber<? super T> call(final Subscriber<? super GroupedObservable<K,
         // a new CompositeSubscription to decouple the subscription as the inner subscriptions need a separate lifecycle
         // and will unsubscribe on this parent if they are all unsubscribed
         return new Subscriber<T>(new CompositeSubscription()) {
-            private final Map<K, Subject<T, T>> groups = new HashMap<K, Subject<T, T>>();
+            private final Map<K, BufferUntilSubscriber<T>> groups = new HashMap<K, BufferUntilSubscriber<T>>();
             private final AtomicInteger completionCounter = new AtomicInteger(0);
-            private final AtomicBoolean completed = new AtomicBoolean(false);
+            private final AtomicBoolean completionEmitted = new AtomicBoolean(false);
+            private final AtomicBoolean terminated = new AtomicBoolean(false);
 
             @Override
             public void onCompleted() {
-                completed.set(true);
-                // if we receive onCompleted from our parent we onComplete children
-                for (Subject<T, T> ps : groups.values()) {
-                    ps.onCompleted();
-                }
+                if (terminated.compareAndSet(false, true)) {
+                    // if we receive onCompleted from our parent we onComplete children
+                    for (BufferUntilSubscriber<T> ps : groups.values()) {
+                        ps.onCompleted();
+                    }
 
-                // special case for empty (no groups emitted)
-                if (completionCounter.get() == 0) {
-                    childObserver.onCompleted();
+                    // special case for empty (no groups emitted)
+                    if (completionCounter.get() == 0) {
+                        // we must track 'completionEmitted' seperately from 'completed' since `completeInner` can result in childObserver.onCompleted() being emitted 
+                        if (completionEmitted.compareAndSet(false, true)) {
+                            childObserver.onCompleted();
+                        }
+                    }
                 }
             }
 
             @Override
             public void onError(Throwable e) {
-                // we immediately tear everything down if we receive an error
-                childObserver.onError(e);
+                if (terminated.compareAndSet(false, true)) {
+                    // we immediately tear everything down if we receive an error
+                    childObserver.onError(e);
+                }
             }
 
             @Override
             public void onNext(T t) {
                 try {
                     final K key = keySelector.call(t);
-                    Subject<T, T> gps = groups.get(key);
+                    BufferUntilSubscriber<T> gps = groups.get(key);
                     if (gps == null) {
                         // this group doesn't exist
                         if (childObserver.isUnsubscribed()) {
                             // we have been unsubscribed on the outer so won't send any  more groups 
                             return;
                         }
-                        gps = PublishSubject.create();
-                        final Subject<T, T> _gps = gps;
+                        gps = BufferUntilSubscriber.create();
+                        final BufferUntilSubscriber<T> _gps = gps;
 
                         GroupedObservable<K, T> go = new GroupedObservable<K, T>(key, new OnSubscribe<T>() {
 
@@ -136,15 +141,16 @@ public void onNext(T t) {
             }
 
             private void completeInner() {
-                if (completionCounter.decrementAndGet() == 0 && (completed.get() || childObserver.isUnsubscribed())) {
-                    if (childObserver.isUnsubscribed()) {
-                        // if the entire groupBy has been unsubscribed and children are completed we will propagate the unsubscribe up.
-                        unsubscribe();
-                    }
-                    for (Subject<T, T> ps : groups.values()) {
-                        ps.onCompleted();
+                // count can be < 0 because unsubscribe also calls this
+                if (completionCounter.decrementAndGet() <= 0 && (terminated.get() || childObserver.isUnsubscribed())) {
+                    // completionEmitted ensures we only emit onCompleted once
+                    if (completionEmitted.compareAndSet(false, true)) {
+                        if (childObserver.isUnsubscribed()) {
+                            // if the entire groupBy has been unsubscribed and children are completed we will propagate the unsubscribe up.
+                            unsubscribe();
+                        }
+                        childObserver.onCompleted();
                     }
-                    childObserver.onCompleted();
                 }
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
deleted file mode 100644
index f5a459ef5d..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOnBounded.java
+++ /dev/null
@@ -1,112 +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.Operator;
-import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.Subscriber;
-import rx.functions.Action1;
-
-/**
- * Subscribes and unsubscribes Observers on the specified Scheduler.
- * <p>
- * 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.
- * <p>
- * See https://github.com/Netflix/RxJava/issues/844 for more information on the "time gap" issue that the synchronous
- * subscribe is solving.
- * 
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/subscribeOn.png">
- */
-public class OperatorSubscribeOnBounded<T> implements Operator<T, Observable<T>> {
-
-    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<? super Observable<T>> call(final Subscriber<? super T> subscriber) {
-        return new Subscriber<Observable<T>>(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<T> o) {
-                if (checkNeedBuffer(o)) {
-                    // use buffering (possibly blocking) for a possibly synchronous subscribe
-                    final BufferUntilSubscriber<T> bus = new BufferUntilSubscriber<T>(bufferSize, subscriber);
-                    subscriber.add(scheduler.schedule(new Action1<Inner>() {
-                        @Override
-                        public void call(final Inner inner) {
-                            bus.enterPassthroughMode();
-                        }
-                    }));
-                    o.subscribe(bus);
-                } else {
-                    // no buffering (async subscribe)
-                    subscriber.add(scheduler.schedule(new Action1<Inner>() {
-
-                        @Override
-                        public void call(final Inner inner) {
-                            o.subscribe(subscriber);
-                        }
-                    }));
-                }
-            }
-
-        };
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index d79ff8cb99..13afb43a93 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -15,8 +15,14 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -32,6 +38,7 @@
 import org.junit.Test;
 import org.mockito.Matchers;
 
+import rx.Notification;
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
@@ -650,6 +657,7 @@ public void call(String s) {
 
     @Test
     public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException {
+        System.err.println("----------------------------------------------------------------------------------------------");
         final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete
         final ArrayList<String> results = new ArrayList<String>();
         Observable.create(new OnSubscribe<Integer>() {
@@ -701,17 +709,31 @@ public void call() {
 
                             });
                 } else {
-                    return group.nest().lift(new OperatorSubscribeOnBounded<Integer>(Schedulers.newThread(), 1)).delay(400, TimeUnit.MILLISECONDS).map(new Func1<Integer, String>() {
+                    return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Func1<Integer, String>() {
 
                         @Override
                         public String call(Integer t1) {
                             return "last group: " + t1;
                         }
 
+                    }).doOnEach(new Action1<Notification<? super String>>() {
+
+                        @Override
+                        public void call(Notification<? super String> t1) {
+                            System.err.println("subscribeOn notification => " + t1);
+                        }
+
                     });
                 }
             }
 
+        }).doOnEach(new Action1<Notification<? super String>>() {
+
+            @Override
+            public void call(Notification<? super String> t1) {
+                System.err.println("outer notification => " + t1);
+            }
+
         }).toBlockingObservable().forEach(new Action1<String>() {
 
             @Override
@@ -827,7 +849,7 @@ public Integer call(Integer t) {
 
             @Override
             public Observable<String> call(final GroupedObservable<Integer, Integer> group) {
-                return group.nest().lift(new OperatorSubscribeOnBounded<Integer>(Schedulers.newThread(), 0)).map(new Func1<Integer, String>() {
+                return group.subscribeOn(Schedulers.newThread()).map(new Func1<Integer, String>() {
 
                     @Override
                     public String call(Integer t1) {
@@ -838,6 +860,13 @@ public String call(Integer t1) {
                 });
             }
 
+        }).doOnEach(new Action1<Notification<? super String>>() {
+
+            @Override
+            public void call(Notification<? super String> t1) {
+                System.out.println("notification => " + t1);
+            }
+
         }).toBlockingObservable().forEach(new Action1<String>() {
 
             @Override
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
deleted file mode 100644
index 7a38bcd8da..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnBoundedTest.java
+++ /dev/null
@@ -1,416 +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.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.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Func1;
-import rx.observables.GroupedObservable;
-import rx.observers.TestObserver;
-import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
-import rx.schedulers.Timestamped;
-import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
-
-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<Thread> subscribeThread = new AtomicReference<Thread>();
-        Observable<Integer> w = Observable.create(new OnSubscribe<Integer>() {
-
-            @Override
-            public void call(Subscriber<? super Integer> t1) {
-                subscribeThread.set(Thread.currentThread());
-                t1.add(subscription);
-                t1.onNext(1);
-                t1.onNext(2);
-                t1.onCompleted();
-            }
-        });
-
-        TestObserver<Integer> observer = new TestObserver<Integer>();
-        w.nest().lift(new OperatorSubscribeOnBounded<Integer>(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<Integer> observer = new TestObserver<Integer>();
-        final ThreadSubscription s = new ThreadSubscription();
-
-        final Subscription subscription = Observable
-                .create(new Observable.OnSubscribe<Integer>() {
-                    @Override
-                    public void call(
-                            final Subscriber<? super Integer> 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<Integer>(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<Scheduler.Inner> action) {
-            return actual.schedule(action, delay, unit);
-        }
-
-        @Override
-        public Subscription schedule(final Action1<Scheduler.Inner> 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<Integer> ps = PublishSubject.create();
-        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        ps.nest().lift(new OperatorSubscribeOnBounded<Integer>(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<String> results = new ArrayList<String>();
-        Observable.create(new OnSubscribe<Integer>() {
-
-            @Override
-            public void call(Subscriber<? super Integer> sub) {
-                sub.onNext(1);
-                sub.onNext(2);
-                sub.onNext(1);
-                sub.onNext(2);
-                sub.onCompleted();
-            }
-
-        }).groupBy(new Func1<Integer, Integer>() {
-
-            @Override
-            public Integer call(Integer t) {
-                return t;
-            }
-
-        }).flatMap(new Func1<GroupedObservable<Integer, Integer>, Observable<String>>() {
-
-            @Override
-            public Observable<String> call(final GroupedObservable<Integer, Integer> group) {
-                return group.nest().lift(new OperatorSubscribeOnBounded<Integer>(Schedulers.newThread(), 0)).map(new Func1<Integer, String>() {
-
-                    @Override
-                    public String call(Integer t1) {
-                        System.out.println("Received: " + t1 + " on group : " + group.getKey());
-                        return "first groups: " + t1;
-                    }
-
-                });
-            }
-
-        }).toBlockingObservable().forEach(new Action1<String>() {
-
-            @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<String> results = new ArrayList<String>();
-        Observable.create(new OnSubscribe<Integer>() {
-
-            @Override
-            public void call(Subscriber<? super Integer> 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<Integer, Integer>() {
-
-            @Override
-            public Integer call(Integer t) {
-                return t;
-            }
-
-        }).flatMap(new Func1<GroupedObservable<Integer, Integer>, Observable<String>>() {
-
-            @Override
-            public Observable<String> call(final GroupedObservable<Integer, Integer> group) {
-                if (group.getKey() < 3) {
-                    return group.map(new Func1<Integer, String>() {
-
-                        @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<Integer>(Schedulers.newThread(), 0))
-                            .delay(400, TimeUnit.MILLISECONDS).map(new Func1<Integer, String>() {
-
-                                @Override
-                                public String call(Integer t1) {
-                                    return "last group: " + t1;
-                                }
-
-                            });
-                }
-            }
-
-        }).toBlockingObservable().forEach(new Action1<String>() {
-
-            @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<Long> timer = Observable.timer(100, 100, TimeUnit.MILLISECONDS);
-
-        final List<Long> deltas = Collections.synchronizedList(new ArrayList<Long>());
-
-        Subscription s = timer.timestamp().nest().lift(new OperatorSubscribeOnBounded<Timestamped<Long>>(
-                new SlowScheduler(Schedulers.computation(), 1, TimeUnit.SECONDS), size)).map(new Func1<Timestamped<Long>, Long>() {
-            @Override
-            public Long call(Timestamped<Long> t1) {
-                long v = System.currentTimeMillis() - t1.getTimestampMillis();
-                return v;
-            }
-        }).doOnNext(new Action1<Long>() {
-            @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<Integer> ts = new TestSubscriber<Integer>();
-        final AtomicInteger count = new AtomicInteger();
-        Observable.create(new OnSubscribe<Integer>() {
-
-            @Override
-            public void call(Subscriber<? super Integer> sub) {
-                for (int i = 1; !sub.isUnsubscribed(); i++) {
-                    count.incrementAndGet();
-                    sub.onNext(i);
-                }
-            }
-
-        }).nest().lift(new OperatorSubscribeOnBounded<Integer>(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());
-    }
-    @Test(timeout = 2000)
-    public void testNoDeadlock() {
-        List<Integer> data = Arrays.asList(1, 2, 3, 4, 5);
-        Observable<Integer> source = Observable.from(data);
-        
-        Observable<Integer> result = source.nest().lift(new OperatorSubscribeOnBounded<Integer>(Schedulers.newThread(), 1));
-        
-        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-        
-        result.subscribe(ts);
-        
-        ts.awaitTerminalEvent();
-        ts.assertReceivedOnNext(data);
-    }
-}

From 2087f2346a39461f610195851dfdabdc457aa30b Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Thu, 20 Mar 2014 11:21:36 -0700
Subject: [PATCH 144/422] Compilation Fix

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

diff --git a/rxjava-core/src/main/java/rx/subjects/TestSubject.java b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
index af3a02f3ee..7904886c75 100644
--- a/rxjava-core/src/main/java/rx/subjects/TestSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
@@ -83,7 +83,7 @@ public void call(SubjectObserver<? super T> o) {
                          */
                         lastNotification.get().accept(o);
                     }
-                });
+                }, null);
 
         return new TestSubject<T>(onSubscribe, subscriptionManager, lastNotification, scheduler);
     }
@@ -179,4 +179,4 @@ public void call(Inner t1) {
 
         }, timeInMilliseconds, TimeUnit.MILLISECONDS);
     }
-}
\ No newline at end of file
+}

From e68f0b20a5d324032a4989265278dbac4cad9b63 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Thu, 20 Mar 2014 11:22:08 -0700
Subject: [PATCH 145/422] Fix Unit Test Assertion

---
 rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java b/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java
index d3f0830128..1cda136fe6 100644
--- a/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java
@@ -66,7 +66,8 @@ public void testAssertNotMatchValue() {
         oi.subscribe(o);
 
         thrown.expect(AssertionError.class);
-        thrown.expectMessage("Value at index: 1 expected to be [3] but was: [2]");
+        thrown.expectMessage("Value at index: 1 expected to be [3] (Integer) but was: [2] (Integer)");
+
 
         o.assertReceivedOnNext(Arrays.asList(1, 3));
         assertEquals(2, o.getOnNextEvents().size());

From 3013ec902084d2573d37e673331ffa0ae02f9c9d Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 20 Mar 2014 11:31:56 -0700
Subject: [PATCH 146/422] parallel-merge unit test assertions

Using serialize for merge allows less threads to be used under contention instead of blocking and using them all.
This changes the assertion to be <= 3 instead of == 3 because of that.
---
 .../src/main/java/rx/operators/OperationParallelMerge.java | 2 +-
 .../test/java/rx/operators/OperationParallelMergeTest.java | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
index b71aaf5efa..7c06082c41 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
@@ -26,7 +26,7 @@
 public class OperationParallelMerge {
 
     public static <T> Observable<Observable<T>> parallelMerge(final Observable<Observable<T>> source, final int parallelObservables) {
-        return parallelMerge(source, parallelObservables, Schedulers.currentThread());
+        return parallelMerge(source, parallelObservables, Schedulers.immediate());
     }
 
     public static <T> Observable<Observable<T>> parallelMerge(final Observable<Observable<T>> source, final int parallelObservables, final Scheduler scheduler) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
index 8a0b4b6770..b126189c37 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
@@ -15,7 +15,8 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
@@ -79,7 +80,7 @@ public void call(String o) {
                     }
                 });
 
-        assertEquals(3, threads.keySet().size());
+        assertTrue(threads.keySet().size() <= 3); // can be less than since merge doesn't block threads and may not use all of them
     }
 
     @Test
@@ -98,7 +99,7 @@ public void call(String o) {
                     }
                 });
 
-        assertEquals(3, threads.keySet().size());
+        assertTrue(threads.keySet().size() <= 3); // can be less than since merge doesn't block threads and may not use all of them
     }
 
     private static Observable<Observable<String>> getStreams() {

From 75b012448976579e91468a9beb587fe0f829f1b8 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 20 Mar 2014 14:34:03 -0700
Subject: [PATCH 147/422] Dematerialize - handle non-materialized terminal
 events

---
 .../rx/operators/OperationDematerialize.java  |  2 +
 .../operators/OperationDematerializeTest.java | 41 +++++++++++++++++--
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
index 9bfd901f7e..2d937aa47a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
@@ -57,10 +57,12 @@ public Subscription onSubscribe(final Observer<? super T> observer) {
             return sequence.subscribe(new Observer<Notification<? extends T>>() {
                 @Override
                 public void onCompleted() {
+                    observer.onCompleted();
                 }
 
                 @Override
                 public void onError(Throwable e) {
+                    observer.onError(e);
                 }
 
                 @Override
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java b/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
index 147ec2ea1c..c3f9954a48 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
@@ -15,15 +15,19 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationDematerialize.*;
+import static org.mockito.Matchers.any;
+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.OperationDematerialize.dematerialize;
 
 import org.junit.Test;
 
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
+import rx.observers.TestSubscriber;
 
 public class OperationDematerializeTest {
 
@@ -71,4 +75,35 @@ public void testDematerialize3() {
         verify(observer, times(0)).onCompleted();
         verify(observer, times(0)).onNext(any(Integer.class));
     }
+
+    @Test
+    public void testErrorPassThru() {
+        Exception exception = new Exception("test");
+        Observable<Integer> observable = Observable.error(exception);
+        Observable<Integer> dematerialize = observable.dematerialize();
+
+        Observer<Integer> observer = mock(Observer.class);
+        dematerialize.subscribe(observer);
+
+        verify(observer, times(1)).onError(exception);
+        verify(observer, times(0)).onCompleted();
+        verify(observer, times(0)).onNext(any(Integer.class));
+    }
+
+    @Test
+    public void testCompletePassThru() {
+        Observable<Integer> observable = Observable.empty();
+        Observable<Integer> dematerialize = observable.dematerialize();
+
+        Observer<Integer> observer = mock(Observer.class);
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>(observer);
+        dematerialize.subscribe(ts);
+
+        System.out.println(ts.getOnErrorEvents());
+
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        verify(observer, times(0)).onNext(any(Integer.class));
+    }
+
 }

From 3d45dac73b183523594f0f812294b214af6a291f Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sat, 15 Mar 2014 22:03:15 +0800
Subject: [PATCH 148/422] Chain Subscription in TimeoutSubscriber and
 SerializedSubscriber

---
 .../rx/observers/SerializedSubscriber.java    |  1 +
 .../rx/operators/OperatorTimeoutBase.java     |  1 +
 .../rx/operators/OperatorTimeoutTests.java    | 86 +++++++++++++++++++
 3 files changed, 88 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
index db545ff430..b42fd04440 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
@@ -20,6 +20,7 @@ public class SerializedSubscriber<T> extends Subscriber<T> {
     private final Observer<T> s;
 
     public SerializedSubscriber(Subscriber<? super T> s) {
+        super(s);
         this.s = new SerializedObserver<T>(s);
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index 7a6ea8e8d8..73bb966277 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -93,6 +93,7 @@ private TimeoutSubscriber(
                 SerializedSubscriber<T> serializedSubscriber,
                 TimeoutStub<T> timeoutStub, SerialSubscription serial,
                 Observable<? extends T> other) {
+            super(serializedSubscriber);
             this.serializedSubscriber = serializedSubscriber;
             this.timeoutStub = timeoutStub;
             this.serial = serial;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
index c371d90680..6702024636 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
@@ -18,6 +18,7 @@
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
+import java.io.IOException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
@@ -266,4 +267,89 @@ public void call(Subscriber<? super String> subscriber) {
 
         exit.countDown(); // exit the thread
     }
+
+    @Test
+    public void shouldUnsubscribeFromUnderlyingSubscriptionOnTimeout() throws InterruptedException {
+        // From https://github.com/Netflix/RxJava/pull/951
+        final Subscription s = mock(Subscription.class);
+
+        Observable<String> never = Observable.create(new OnSubscribe<String>() {
+            public void call(Subscriber<? super String> subscriber) {
+                subscriber.add(s);
+            }
+        });
+
+        TestScheduler testScheduler = new TestScheduler();
+        Observable<String> observableWithTimeout = never.timeout(1000, TimeUnit.MILLISECONDS, testScheduler);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        observableWithTimeout.subscribe(observer);
+
+        testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer).onError(isA(TimeoutException.class));
+        inOrder.verifyNoMoreInteractions();
+
+        verify(s, times(1)).unsubscribe();
+    }
+
+    @Test
+    public void shouldUnsubscribeFromUnderlyingSubscriptionOnImmediatelyComplete() {
+        // From https://github.com/Netflix/RxJava/pull/951
+        final Subscription s = mock(Subscription.class);
+
+        Observable<String> immediatelyComplete = Observable.create(new OnSubscribe<String>() {
+            public void call(Subscriber<? super String> subscriber) {
+                subscriber.add(s);
+                subscriber.onCompleted();
+            }
+        });
+
+        TestScheduler testScheduler = new TestScheduler();
+        Observable<String> observableWithTimeout = immediatelyComplete.timeout(1000, TimeUnit.MILLISECONDS,
+                testScheduler);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        observableWithTimeout.subscribe(observer);
+
+        testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+
+        verify(s, times(1)).unsubscribe();
+    }
+
+    @Test
+    public void shouldUnsubscribeFromUnderlyingSubscriptionOnImmediatelyErrored() throws InterruptedException {
+        // From https://github.com/Netflix/RxJava/pull/951
+        final Subscription s = mock(Subscription.class);
+
+        Observable<String> immediatelyError = Observable.create(new OnSubscribe<String>() {
+            public void call(Subscriber<? super String> subscriber) {
+                subscriber.add(s);
+                subscriber.onError(new IOException("Error"));
+            }
+        });
+
+        TestScheduler testScheduler = new TestScheduler();
+        Observable<String> observableWithTimeout = immediatelyError.timeout(1000, TimeUnit.MILLISECONDS,
+                testScheduler);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        observableWithTimeout.subscribe(observer);
+
+        testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer).onError(isA(IOException.class));
+        inOrder.verifyNoMoreInteractions();
+
+        verify(s, times(1)).unsubscribe();
+    }
 }

From 25555b4f6f9e83acaf6e0f169b6041975718e7d3 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 16 Mar 2014 00:30:51 +0800
Subject: [PATCH 149/422] Reimplement the ElementAt operator

---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../java/rx/operators/OperationElementAt.java | 137 ------------------
 .../java/rx/operators/OperatorElementAt.java  |  84 +++++++++++
 .../rx/operators/OperationElementAtTest.java  | 127 ----------------
 .../rx/operators/OperatorElementAtTest.java   |  60 ++++++++
 5 files changed, 147 insertions(+), 267 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationElementAt.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorElementAt.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 235e1e62e4..98885a765c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -66,7 +66,7 @@
 import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
-import rx.operators.OperationElementAt;
+import rx.operators.OperatorElementAt;
 import rx.operators.OperationFinally;
 import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupByUntil;
@@ -4466,7 +4466,7 @@ public final void onNext(T args) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementat">RxJava Wiki: elementAt()</a>
      */
     public final Observable<T> elementAt(int index) {
-        return create(OperationElementAt.elementAt(this, index));
+        return create(new OperatorElementAt<T>(this, index));
     }
 
     /**
@@ -4486,7 +4486,7 @@ public final Observable<T> elementAt(int index) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementatordefault">RxJava Wiki: elementAtOrDefault()</a>
      */
     public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
-        return create(OperationElementAt.elementAtOrDefault(this, index, defaultValue));
+        return create(new OperatorElementAt<T>(this, index, defaultValue));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationElementAt.java b/rxjava-core/src/main/java/rx/operators/OperationElementAt.java
deleted file mode 100644
index 729258e734..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationElementAt.java
+++ /dev/null
@@ -1,137 +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.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-
-/**
- * Returns the element at a specified index in a sequence.
- */
-public class OperationElementAt {
-
-    /**
-     * Returns the element at a specified index in a sequence.
-     * 
-     * @param source
-     *            Observable sequence to return the element from.
-     * @param index
-     *            The zero-based index of the element to retrieve.
-     * 
-     * @return An observable sequence that produces the element at the specified
-     *         position in the source sequence.
-     * 
-     * @throws IndexOutOfBoundsException
-     *             Index is greater than or equal to the number of elements in
-     *             the source sequence.
-     * @throws IndexOutOfBoundsException
-     *             Index is less than 0.
-     */
-    public static <T> OnSubscribeFunc<T> elementAt(Observable<? extends T> source, int index) {
-        return new ElementAt<T>(source, index, null, false);
-    }
-
-    /**
-     * Returns the element at a specified index in a sequence or the default
-     * value if the index is out of range.
-     * 
-     * @param source
-     *            Observable sequence to return the element from.
-     * @param index
-     *            The zero-based index of the element to retrieve.
-     * @param defaultValue
-     *            The default value.
-     * 
-     * @return An observable sequence that produces the element at the specified
-     *         position in the source sequence, or the default value if the
-     *         index is outside the bounds of the source sequence.
-     * 
-     * @throws IndexOutOfBoundsException
-     *             Index is less than 0.
-     */
-    public static <T> OnSubscribeFunc<T> elementAtOrDefault(Observable<? extends T> source, int index, T defaultValue) {
-        return new ElementAt<T>(source, index, defaultValue, true);
-    }
-
-    private static class ElementAt<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<? extends T> source;
-        private final int index;
-        private final boolean hasDefault;
-        private final T defaultValue;
-
-        private ElementAt(Observable<? extends T> source, int index,
-                T defaultValue, boolean hasDefault) {
-            this.source = source;
-            this.index = index;
-            this.defaultValue = defaultValue;
-            this.hasDefault = hasDefault;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(source.subscribe(new Observer<T>() {
-
-                private AtomicInteger counter = new AtomicInteger();
-
-                @Override
-                public void onNext(T value) {
-                    try {
-                        int currentIndex = counter.getAndIncrement();
-                        if (currentIndex == index) {
-                            observer.onNext(value);
-                            observer.onCompleted();
-                        } else if (currentIndex > index) {
-                            // this will work if the sequence is asynchronous,
-                            // it will have no effect on a synchronous observable
-                            subscription.unsubscribe();
-                        }
-                    } 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();
-                    }
-
-                }
-
-                @Override
-                public void onError(Throwable ex) {
-                    observer.onError(ex);
-                }
-
-                @Override
-                public void onCompleted() {
-                    if (index < 0) {
-                        observer.onError(new IndexOutOfBoundsException(index + " is out of bounds"));
-                    } else if (counter.get() <= index) {
-                        if (hasDefault) {
-                            observer.onNext(defaultValue);
-                            observer.onCompleted();
-                        } else {
-                            observer.onError(new IndexOutOfBoundsException(index + " is out of bounds"));
-                        }
-                    }
-                }
-            }));
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorElementAt.java b/rxjava-core/src/main/java/rx/operators/OperatorElementAt.java
new file mode 100644
index 0000000000..fe7d94c518
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorElementAt.java
@@ -0,0 +1,84 @@
+/**
+ * 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.OnSubscribe;
+import rx.Subscriber;
+
+/**
+ * Returns the element at a specified index in a sequence.
+ */
+public final class OperatorElementAt<T> implements OnSubscribe<T> {
+
+    private final Observable<? extends T> source;
+    private final int index;
+    private final boolean hasDefault;
+    private final T defaultValue;
+
+    public OperatorElementAt(Observable<? extends T> source, int index) {
+        this(source, index, null, false);
+    }
+
+    public OperatorElementAt(Observable<? extends T> source, int index, T defaultValue) {
+        this(source, index, defaultValue, true);
+    }
+
+    private OperatorElementAt(Observable<? extends T> source, int index, T defaultValue, boolean hasDefault) {
+        if (index < 0) {
+            throw new IndexOutOfBoundsException(index + " is out of bounds");
+        }
+        this.source = source;
+        this.index = index;
+        this.defaultValue = defaultValue;
+        this.hasDefault = hasDefault;
+    }
+
+    @Override
+    public void call(final Subscriber<? super T> subscriber) {
+        source.subscribe(new Subscriber<T>(subscriber) {
+
+            private int currentIndex = 0;
+
+            @Override
+            public void onNext(T value) {
+                if (currentIndex == index) {
+                    subscriber.onNext(value);
+                    subscriber.onCompleted();
+                }
+                currentIndex++;
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (currentIndex <= index) {
+                    // If "subscriber.onNext(value)" is called, currentIndex must be greater than index
+                    if (hasDefault) {
+                        subscriber.onNext(defaultValue);
+                        subscriber.onCompleted();
+                    } else {
+                        subscriber.onError(new IndexOutOfBoundsException(index + " is out of bounds"));
+                    }
+                }
+            }
+        });
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java b/rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java
deleted file mode 100644
index 7728c8791b..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationElementAtTest.java
+++ /dev/null
@@ -1,127 +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.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationElementAt.*;
-
-import java.util.Iterator;
-import java.util.concurrent.ExecutionException;
-
-import org.junit.Test;
-
-import rx.Observable;
-import rx.Observer;
-
-public class OperationElementAtTest {
-
-    @Test
-    public void testElementAt() {
-        Observable<Integer> w = Observable.from(1, 2);
-        Observable<Integer> observable = Observable.create(elementAt(w, 1));
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, never()).onNext(1);
-        verify(observer, times(1)).onNext(2);
-        verify(observer, never()).onError(
-                any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testElementAtWithMinusIndex() {
-        Observable<Integer> w = Observable.from(1, 2);
-        Observable<Integer> observable = Observable
-                .create(elementAt(w, -1));
-
-        try {
-            Iterator<Integer> iter = OperationToIterator
-                    .toIterator(observable);
-            assertTrue(iter.hasNext());
-            iter.next();
-            fail("expect an IndexOutOfBoundsException when index is out of bounds");
-        } catch (IndexOutOfBoundsException e) {
-        }
-    }
-
-    @Test
-    public void testElementAtWithIndexOutOfBounds()
-            throws InterruptedException, ExecutionException {
-        Observable<Integer> w = Observable.from(1, 2);
-        Observable<Integer> observable = Observable.create(elementAt(w, 2));
-        try {
-            Iterator<Integer> iter = OperationToIterator
-                    .toIterator(observable);
-            assertTrue(iter.hasNext());
-            iter.next();
-            fail("expect an IndexOutOfBoundsException when index is out of bounds");
-        } catch (IndexOutOfBoundsException e) {
-        }
-    }
-
-    @Test
-    public void testElementAtOrDefault() throws InterruptedException,
-            ExecutionException {
-        Observable<Integer> w = Observable.from(1, 2);
-        Observable<Integer> observable = Observable
-                .create(elementAtOrDefault(w, 1, 0));
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, never()).onNext(1);
-        verify(observer, times(1)).onNext(2);
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testElementAtOrDefaultWithIndexOutOfBounds()
-            throws InterruptedException, ExecutionException {
-        Observable<Integer> w = Observable.from(1, 2);
-        Observable<Integer> observable = Observable
-                .create(elementAtOrDefault(w, 2, 0));
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, never()).onNext(1);
-        verify(observer, never()).onNext(2);
-        verify(observer, times(1)).onNext(0);
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testElementAtOrDefaultWithMinusIndex() {
-        Observable<Integer> w = Observable.from(1, 2);
-        Observable<Integer> observable = Observable
-                .create(elementAtOrDefault(w, -1, 0));
-
-        try {
-            Iterator<Integer> iter = OperationToIterator
-                    .toIterator(observable);
-            assertTrue(iter.hasNext());
-            iter.next();
-            fail("expect an IndexOutOfBoundsException when index is out of bounds");
-        } catch (IndexOutOfBoundsException e) {
-        }
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java b/rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java
new file mode 100644
index 0000000000..a9a21f0087
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java
@@ -0,0 +1,60 @@
+/**
+ * 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 java.util.Arrays;
+
+import org.junit.Test;
+
+import rx.Observable;
+
+public class OperatorElementAtTest {
+
+    @Test
+    public void testElementAt() {
+        assertEquals(2, Observable.from(Arrays.asList(1, 2)).elementAt(1).toBlockingObservable().single()
+                .intValue());
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testElementAtWithMinusIndex() {
+        Observable.from(Arrays.asList(1, 2)).elementAt(-1);
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testElementAtWithIndexOutOfBounds() {
+        Observable.from(Arrays.asList(1, 2)).elementAt(2).toBlockingObservable().single();
+    }
+
+    @Test
+    public void testElementAtOrDefault() {
+        assertEquals(2, Observable.from(Arrays.asList(1, 2)).elementAtOrDefault(1, 0).toBlockingObservable()
+                .single().intValue());
+    }
+
+    @Test
+    public void testElementAtOrDefaultWithIndexOutOfBounds() {
+        assertEquals(0, Observable.from(Arrays.asList(1, 2)).elementAtOrDefault(2, 0).toBlockingObservable()
+                .single().intValue());
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testElementAtOrDefaultWithMinusIndex() {
+        Observable.from(Arrays.asList(1, 2)).elementAtOrDefault(-1, 0);
+    }
+}

From 11a18aaa68031e1503edf054855b90a6a41aeb94 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 16 Mar 2014 00:31:09 +0800
Subject: [PATCH 150/422] Add ElementAt and ElementAtOrDefault to rxjava-scala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  |  9 +++
 .../main/scala/rx/lang/scala/Observable.scala | 59 +++++++++++++++++++
 2 files changed, 68 insertions(+)

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 e09e6a7ec9..d0ee67838e 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
@@ -564,4 +564,13 @@ class RxScalaDemo extends JUnitSuite {
     println(result)
   }
 
+  @Test def elementAtExample(): Unit = {
+    val o = List("red", "green", "blue").toObservable
+    println(o(2).toBlockingObservable.single)
+  }
+
+  @Test def elementAtOrDefaultExample(): Unit = {
+    val o : Observable[Seq[Char]] = List("red".toList, "green".toList, "blue".toList).toObservable.elementAtOrDefault(3, "black".toSeq)
+    println(o.toBlockingObservable.single)
+  }
 }
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 8dafa30e2b..d185c1af8b 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
@@ -2305,6 +2305,65 @@ trait Observable[+T]
   def delaySubscription(delay: Duration, scheduler: Scheduler): Observable[T] = {
     toScalaObservable[T](asJavaObservable.delaySubscription(delay.length, delay.unit, scheduler))
   }
+
+  /**
+   * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
+   * source Observbable.
+   * 
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAt.png">
+   * 
+   * @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
+   * @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 `Observable.elementAt`
+   */
+  def apply(index: Int): Observable[T] = elementAt(index)
+
+  /**
+   * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
+   * source Observbable.
+   * 
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAt.png">
+   * 
+   * @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
+   * @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
+   */
+  def elementAt(index: Int): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.elementAt(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.
+   * 
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAtOrDefault.png">
+   * 
+   * @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 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
+   */
+  def elementAtOrDefault[U >: T](index: Int, default: U): Observable[U] = {
+    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable[U](thisJava.elementAtOrDefault(index, default))
+  }
 }
 
 /**

From f0fea5fa67bc9ed770ddfa55845e276d4a766e69 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 16 Mar 2014 11:28:43 +0800
Subject: [PATCH 151/422] Implement ElementAt as Operator

---
 rxjava-core/src/main/java/rx/Observable.java  |  4 ++--
 .../java/rx/operators/OperatorElementAt.java  | 24 +++++++++----------
 2 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 98885a765c..1745f148ea 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4466,7 +4466,7 @@ public final void onNext(T args) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementat">RxJava Wiki: elementAt()</a>
      */
     public final Observable<T> elementAt(int index) {
-        return create(new OperatorElementAt<T>(this, index));
+        return lift(new OperatorElementAt<T>(index));
     }
 
     /**
@@ -4486,7 +4486,7 @@ public final Observable<T> elementAt(int index) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementatordefault">RxJava Wiki: elementAtOrDefault()</a>
      */
     public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
-        return create(new OperatorElementAt<T>(this, index, defaultValue));
+        return lift(new OperatorElementAt<T>(index, defaultValue));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorElementAt.java b/rxjava-core/src/main/java/rx/operators/OperatorElementAt.java
index fe7d94c518..6c92c49009 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorElementAt.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorElementAt.java
@@ -15,41 +15,38 @@
  */
 package rx.operators;
 
-import rx.Observable;
-import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
 import rx.Subscriber;
 
 /**
  * Returns the element at a specified index in a sequence.
  */
-public final class OperatorElementAt<T> implements OnSubscribe<T> {
+public final class OperatorElementAt<T> implements Operator<T, T> {
 
-    private final Observable<? extends T> source;
     private final int index;
     private final boolean hasDefault;
     private final T defaultValue;
 
-    public OperatorElementAt(Observable<? extends T> source, int index) {
-        this(source, index, null, false);
+    public OperatorElementAt(int index) {
+        this(index, null, false);
     }
 
-    public OperatorElementAt(Observable<? extends T> source, int index, T defaultValue) {
-        this(source, index, defaultValue, true);
+    public OperatorElementAt(int index, T defaultValue) {
+        this(index, defaultValue, true);
     }
 
-    private OperatorElementAt(Observable<? extends T> source, int index, T defaultValue, boolean hasDefault) {
+    private OperatorElementAt(int index, T defaultValue, boolean hasDefault) {
         if (index < 0) {
             throw new IndexOutOfBoundsException(index + " is out of bounds");
         }
-        this.source = source;
         this.index = index;
         this.defaultValue = defaultValue;
         this.hasDefault = hasDefault;
     }
 
     @Override
-    public void call(final Subscriber<? super T> subscriber) {
-        source.subscribe(new Subscriber<T>(subscriber) {
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
 
             private int currentIndex = 0;
 
@@ -79,6 +76,7 @@ public void onCompleted() {
                     }
                 }
             }
-        });
+        };
     }
+
 }

From 682f4bd73fb942cd70116dd3aa4d49953bc3c66e Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 24 Mar 2014 10:56:41 +0800
Subject: [PATCH 152/422] Fix typos

---
 .../src/main/java/rx/operators/OperatorSingle.java        | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSingle.java b/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
index e00aa87d82..f633354817 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSingle.java
@@ -49,12 +49,12 @@ public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
 
             private T value;
             private boolean isNonEmpty = false;
-            private boolean hasTooManyElemenets = false;
+            private boolean hasTooManyElements = false;
 
             @Override
             public void onNext(T value) {
                 if (isNonEmpty) {
-                    hasTooManyElemenets = true;
+                    hasTooManyElements = true;
                     subscriber.onError(new IllegalArgumentException("Sequence contains too many elements"));
                 } else {
                     this.value = value;
@@ -64,8 +64,8 @@ public void onNext(T value) {
 
             @Override
             public void onCompleted() {
-                if (hasTooManyElemenets) {
-                    // We has already sent an onError message
+                if (hasTooManyElements) {
+                    // We have already sent an onError message
                 } else {
                     if (isNonEmpty) {
                         subscriber.onNext(value);

From 07e27697dc51ffa4c26f9e20a427d9900bf6b0b9 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 20 Mar 2014 11:00:04 -0700
Subject: [PATCH 153/422] Pivot Operator

---
 rxjava-core/src/main/java/rx/Observable.java  |  31 +-
 .../rx/observables/GroupedObservable.java     |  11 +
 .../java/rx/observers/SerializedObserver.java |   4 +-
 .../main/java/rx/operators/OperatorPivot.java | 497 ++++++++++++++++++
 .../java/rx/operators/OperatorPivotTest.java  | 201 +++++++
 5 files changed, 736 insertions(+), 8 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorPivot.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 235e1e62e4..9048a888c2 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.functions.Functions.*;
+import static rx.functions.Functions.alwaysFalse;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -115,6 +115,7 @@
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
 import rx.operators.OperatorParallel;
+import rx.operators.OperatorPivot;
 import rx.operators.OperatorRepeat;
 import rx.operators.OperatorRetry;
 import rx.operators.OperatorScan;
@@ -1640,8 +1641,18 @@ public final static Observable<Long> interval(long interval, TimeUnit unit, Sche
      * @return an Observable that emits {@code value} as a single item and then completes
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-just">RxJava Wiki: just()</a>
      */
-    public final static <T> Observable<T> just(T value) {
-        return from(Arrays.asList(value));
+    public final static <T> Observable<T> just(final T value) {
+        return Observable.create(new OnSubscribe<T>() {
+
+            @Override
+            public void call(Subscriber<? super T> s) {
+                if (!s.isUnsubscribed()) {
+                    s.onNext(value);
+                    s.onCompleted();
+                }
+            }
+
+        });
     }
     
     /**
@@ -1664,7 +1675,7 @@ public final static <T> Observable<T> just(T value) {
      */
     @Deprecated
     public final static <T> Observable<T> just(T value, Scheduler scheduler) {
-        return from(Arrays.asList((value)), scheduler);
+        return just(value).subscribeOn(scheduler);
     }
 
     /**
@@ -2410,7 +2421,7 @@ public final static <T extends Comparable<? super T>> Observable<T> min(Observab
      * @return an Observable that emits a single item: the source Observable
      */
     public final Observable<Observable<T>> nest() {
-        return from(this);
+        return just(this);
     }
     
     /**
@@ -2477,6 +2488,16 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
         return OperationParallelMerge.parallelMerge(source, parallelObservables, scheduler);
     }
 
+    /**
+     * Pivot GroupedObservable streams without serializing/synchronizing to a single stream first. 
+     * 
+     * @param groups
+     * @return
+     */
+    public static final <K1, K2, T> Observable<GroupedObservable<K2, GroupedObservable<K1, T>>> pivot(Observable<GroupedObservable<K1, GroupedObservable<K2, T>>> groups) {
+        return groups.lift(new OperatorPivot<K1, K2, T>());        
+    }
+    
     /**
      * Returns an Observable that emits a sequence of Integers within a specified range.
      * <p>
diff --git a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
index 120f742e77..13b36edd82 100644
--- a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
@@ -16,6 +16,7 @@
 package rx.observables;
 
 import rx.Observable;
+import rx.Subscriber;
 import rx.functions.Func1;
 
 /**
@@ -31,6 +32,16 @@
 public class GroupedObservable<K, T> extends Observable<T> {
     private final K key;
 
+    public static <K, T> GroupedObservable<K, T> from(K key, final Observable<T> o) {
+        return new GroupedObservable<K, T>(key, new OnSubscribe<T>() {
+
+            @Override
+            public void call(Subscriber<? super T> s) {
+                o.subscribe(s);
+            }
+        });
+    }
+
     public GroupedObservable(K key, OnSubscribe<T> onSubscribe) {
         super(onSubscribe);
         this.key = key;
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 8c87a7b855..6be8d7a23e 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -2,9 +2,6 @@
 
 import java.util.ArrayList;
 
-import javax.management.NotificationListener;
-
-import rx.Notification;
 import rx.Observer;
 import rx.operators.NotificationLite;
 
@@ -54,6 +51,7 @@ public void onCompleted() {
                 queue.add(on.completed());
             }
         }
+
         if (canEmit) {
             // we won the right to emit
             try {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorPivot.java b/rxjava-core/src/main/java/rx/operators/OperatorPivot.java
new file mode 100644
index 0000000000..c341cca1b3
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorPivot.java
@@ -0,0 +1,497 @@
+/**
+ * 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.Collections;
+import java.util.HashSet;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observables.GroupedObservable;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
+
+public class OperatorPivot<K1, K2, T> implements Operator<GroupedObservable<K2, GroupedObservable<K1, T>>, GroupedObservable<K1, GroupedObservable<K2, T>>> {
+
+    @Override
+    public Subscriber<? super GroupedObservable<K1, GroupedObservable<K2, T>>> call(final Subscriber<? super GroupedObservable<K2, GroupedObservable<K1, T>>> child) {
+        final AtomicReference<State> state = new AtomicReference<State>(State.create());
+        final OperatorPivot<K1, K2, T>.PivotSubscriber pivotSubscriber = new PivotSubscriber(new CompositeSubscription(), child, state);
+        child.add(Subscriptions.create(new Action0() {
+
+            @Override
+            public void call() {
+                State current;
+                State newState = null;
+                do {
+                    current = state.get();
+                    newState = current.unsubscribe();
+                } while (!state.compareAndSet(current, newState));
+
+                // If all outer/inner groups are completed/unsubscribed then we can shut it all down
+                if (newState.shouldComplete()) {
+                    pivotSubscriber.groups.completeAll(newState);
+                }
+                // otherwise it is just marked as unsubscribed and groups being completed/unsubscribed will allow it to cleanup
+            }
+
+        }));
+
+        return pivotSubscriber;
+    }
+
+    private final class PivotSubscriber extends Subscriber<GroupedObservable<K1, GroupedObservable<K2, T>>> {
+        /*
+         * needs to decouple the subscription as the inner subscriptions need a separate lifecycle
+         * and will unsubscribe on this parent if they are all unsubscribed
+         */
+        private final CompositeSubscription parentSubscription;
+        private final Subscriber<? super GroupedObservable<K2, GroupedObservable<K1, T>>> child;
+        private final AtomicReference<State> state;
+        private final GroupState<K1, K2, T> groups;
+
+        private PivotSubscriber(CompositeSubscription parentSubscription, Subscriber<? super GroupedObservable<K2, GroupedObservable<K1, T>>> child, AtomicReference<State> state) {
+            super(parentSubscription);
+            this.parentSubscription = parentSubscription;
+            this.child = child;
+            this.state = state;
+            this.groups = new GroupState<K1, K2, T>(parentSubscription, child);
+        }
+
+        @Override
+        public void onCompleted() {
+            State current;
+            State newState = null;
+            do {
+                current = state.get();
+                newState = current.complete();
+            } while (!state.compareAndSet(current, newState));
+
+            // special case for empty (no groups emitted) or all groups already done
+            if (newState.shouldComplete()) {
+                groups.completeAll(newState);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            // we immediately tear everything down if we receive an error
+            child.onError(e);
+        }
+
+        @Override
+        public void onNext(final GroupedObservable<K1, GroupedObservable<K2, T>> k1Group) {
+            groups.startK1Group(state, k1Group.getKey());
+            k1Group.subscribe(new Subscriber<GroupedObservable<K2, T>>(parentSubscription) {
+
+                @Override
+                public void onCompleted() {
+                    groups.completeK1Group(state, k1Group.getKey());
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    child.onError(e);
+                }
+
+                @Override
+                public void onNext(final GroupedObservable<K2, T> k2Group) {
+                    /*
+                     * In this scope once pivoted, k2 == outer and k2.k1 == inner
+                     */
+                    final Inner<K1, K2, T> inner = groups.getOrCreateFor(state, child, k1Group.getKey(), k2Group.getKey());
+                    if (inner == null) {
+                        // we have been unsubscribed
+                        return;
+                    }
+                    k2Group.subscribe(new Subscriber<T>(parentSubscription) {
+
+                        @Override
+                        public void onCompleted() {
+                            /*
+                             * we don't actually propagate onCompleted to the 'inner.subscriber' here
+                             * since multiple upstream groups will be sent to a single downstream
+                             * and a single upstream group completing does not indicate total completion
+                             */
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            inner.subscriber.onError(e);
+                        }
+
+                        @Override
+                        public void onNext(T t) {
+                            inner.subscriber.onNext(t);
+                        }
+
+                    });
+
+                }
+
+            });
+
+        }
+
+    }
+
+    private static class GroupState<K1, K2, T> {
+        private final ConcurrentHashMap<KeyPair<K1, K2>, Inner<K1, K2, T>> innerSubjects = new ConcurrentHashMap<KeyPair<K1, K2>, Inner<K1, K2, T>>();
+        private final ConcurrentHashMap<K2, Outer<K1, K2, T>> outerSubjects = new ConcurrentHashMap<K2, Outer<K1, K2, T>>();
+        private final AtomicBoolean completeEmitted = new AtomicBoolean();
+        private final CompositeSubscription parentSubscription;
+        private final Subscriber<? super GroupedObservable<K2, GroupedObservable<K1, T>>> child;
+
+        public GroupState(CompositeSubscription parentSubscription, Subscriber<? super GroupedObservable<K2, GroupedObservable<K1, T>>> child) {
+            this.parentSubscription = parentSubscription;
+            this.child = child;
+        }
+
+        public void startK1Group(AtomicReference<State> state, K1 key) {
+            State current;
+            State newState = null;
+            do {
+                current = state.get();
+                newState = current.addK1(key);
+            } while (!state.compareAndSet(current, newState));
+        }
+
+        public void completeK1Group(AtomicReference<State> state, K1 key) {
+            State current;
+            State newState = null;
+            do {
+                current = state.get();
+                newState = current.removeK1(key);
+            } while (!state.compareAndSet(current, newState));
+
+            if (newState.shouldComplete()) {
+                completeAll(newState);
+            }
+        }
+
+        public void startK1K2Group(AtomicReference<State> state, KeyPair<K1, K2> keyPair) {
+            State current;
+            State newState = null;
+            do {
+                current = state.get();
+                newState = current.addK1k2(keyPair);
+            } while (!state.compareAndSet(current, newState));
+        }
+
+        public void completeK1K2Group(AtomicReference<State> state, KeyPair<K1, K2> keyPair) {
+            State current;
+            State newState = null;
+            do {
+                current = state.get();
+                newState = current.removeK1k2(keyPair);
+            } while (!state.compareAndSet(current, newState));
+
+            if (newState.shouldComplete()) {
+                completeAll(newState);
+            }
+        }
+
+        public void completeAll(State state) {
+            if (completeEmitted.compareAndSet(false, true)) {
+                /*
+                 * after we are completely done emitting we can now shut down the groups
+                 */
+                for (Entry<K2, Outer<K1, K2, T>> outer : outerSubjects.entrySet()) {
+                    outer.getValue().subscriber.onCompleted();
+                }
+                for (Entry<KeyPair<K1, K2>, Inner<K1, K2, T>> inner : innerSubjects.entrySet()) {
+                    inner.getValue().subscriber.onCompleted();
+                }
+                // unsubscribe eagerly
+                if (state.unsubscribed) {
+                    parentSubscription.unsubscribe(); // unsubscribe from parent
+                }
+                child.onCompleted();
+            }
+        }
+
+        private Inner<K1, K2, T> getOrCreateFor(final AtomicReference<State> state, final Subscriber<? super GroupedObservable<K2, GroupedObservable<K1, T>>> child, K1 key1, K2 key2) {
+            Outer<K1, K2, T> outer = getOrCreateOuter(state, child, key2);
+            if (outer == null) {
+                // we have been unsubscribed
+                return null;
+            }
+
+            Inner<K1, K2, T> orCreateInnerSubject = getOrCreateInnerSubject(state, outer, key1, key2);
+            return orCreateInnerSubject;
+        }
+
+        private Inner<K1, K2, T> getOrCreateInnerSubject(final AtomicReference<State> state, final Outer<K1, K2, T> outer, final K1 key1, final K2 key2) {
+            KeyPair<K1, K2> keyPair = new KeyPair<K1, K2>(key1, key2);
+            Inner<K1, K2, T> innerSubject = innerSubjects.get(keyPair);
+            if (innerSubject != null) {
+                return innerSubject;
+            } else {
+                Inner<K1, K2, T> newInner = Inner.create(this, state, outer, keyPair);
+                Inner<K1, K2, T> existing = innerSubjects.putIfAbsent(keyPair, newInner);
+                if (existing != null) {
+                    // we lost the race to create so return the one that did
+                    return existing;
+                } else {
+                    startK1K2Group(state, keyPair);
+                    outer.subscriber.onNext(newInner.group);
+                    return newInner;
+                }
+            }
+        }
+
+        private Outer<K1, K2, T> getOrCreateOuter(final AtomicReference<State> state, final Subscriber<? super GroupedObservable<K2, GroupedObservable<K1, T>>> child, final K2 key2) {
+            Outer<K1, K2, T> outerSubject = outerSubjects.get(key2);
+            if (outerSubject != null) {
+                return outerSubject;
+            } else {
+                // this group doesn't exist
+                if (child.isUnsubscribed()) {
+                    // we have been unsubscribed on the outer so won't send any  more groups 
+                    return null;
+                }
+
+                Outer<K1, K2, T> newOuter = Outer.<K1, K2, T> create(this, state, key2);
+                Outer<K1, K2, T> existing = outerSubjects.putIfAbsent(key2, newOuter);
+                if (existing != null) {
+                    // we lost the race to create so return the one that did
+                    return existing;
+                } else {
+                    child.onNext(newOuter.group);
+                    return newOuter;
+                }
+            }
+        }
+    }
+
+    private static class Inner<K1, K2, T> {
+
+        private final BufferUntilSubscriber<T> subscriber;
+        private final GroupedObservable<K1, T> group;
+
+        private Inner(BufferUntilSubscriber<T> subscriber, GroupedObservable<K1, T> group) {
+            this.subscriber = subscriber;
+            this.group = group;
+        }
+
+        public static <K1, K2, T> Inner<K1, K2, T> create(final GroupState<K1, K2, T> groupState, final AtomicReference<State> state, final Outer<K1, K2, T> outer, final KeyPair<K1, K2> keyPair) {
+            final BufferUntilSubscriber<T> subject = BufferUntilSubscriber.create();
+            GroupedObservable<K1, T> group = new GroupedObservable<K1, T>(keyPair.k1, new OnSubscribe<T>() {
+
+                @Override
+                public void call(final Subscriber<? super T> o) {
+                    o.add(Subscriptions.create(new Action0() {
+
+                        @Override
+                        public void call() {
+                            groupState.completeK1K2Group(state, keyPair);
+                        }
+
+                    }));
+                    subject.subscribe(new Subscriber<T>(o) {
+
+                        @Override
+                        public void onCompleted() {
+                            groupState.completeK1K2Group(state, keyPair);
+                            o.onCompleted();
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            o.onError(e);
+                        }
+
+                        @Override
+                        public void onNext(T t) {
+                            if (!isUnsubscribed()) {
+                                o.onNext(t);
+                            }
+                        }
+
+                    });
+                }
+
+            });
+            return new Inner<K1, K2, T>(subject, group);
+        }
+    }
+
+    private static class Outer<K1, K2, T> {
+
+        private final BufferUntilSubscriber<GroupedObservable<K1, T>> subscriber;
+        private final GroupedObservable<K2, GroupedObservable<K1, T>> group;
+
+        private Outer(BufferUntilSubscriber<GroupedObservable<K1, T>> subscriber, GroupedObservable<K2, GroupedObservable<K1, T>> group) {
+            this.subscriber = subscriber;
+            this.group = group;
+        }
+
+        public static <K1, K2, T> Outer<K1, K2, T> create(final GroupState<K1, K2, T> groups, final AtomicReference<State> state, final K2 key2) {
+            final BufferUntilSubscriber<GroupedObservable<K1, T>> subject = BufferUntilSubscriber.create();
+            GroupedObservable<K2, GroupedObservable<K1, T>> group = new GroupedObservable<K2, GroupedObservable<K1, T>>(key2, new OnSubscribe<GroupedObservable<K1, T>>() {
+
+                @Override
+                public void call(final Subscriber<? super GroupedObservable<K1, T>> o) {
+                    subject.subscribe(new Subscriber<GroupedObservable<K1, T>>(o) {
+
+                        @Override
+                        public void onCompleted() {
+                            o.onCompleted();
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            o.onError(e);
+                        }
+
+                        @Override
+                        public void onNext(GroupedObservable<K1, T> t) {
+                            if (!isUnsubscribed()) {
+                                o.onNext(t);
+                            }
+                        }
+
+                    });
+                }
+
+            });
+
+            return new Outer<K1, K2, T>(subject, group);
+        }
+    }
+
+    private static class State {
+        private final boolean unsubscribed;
+        private final boolean completed;
+        private final Set<Object> k1Keys;
+        private final Set<KeyPair<?, ?>> k1k2Keys;
+
+        private State(boolean completed, boolean unsubscribed, Set<Object> k1Keys, Set<KeyPair<?, ?>> k1k2Keys) {
+            this.completed = completed;
+            this.unsubscribed = unsubscribed;
+            this.k1Keys = k1Keys;
+            this.k1k2Keys = k1k2Keys;
+        }
+
+        public static State create() {
+            return new State(false, false, Collections.emptySet(), Collections.<KeyPair<?, ?>> emptySet());
+        }
+
+        public State addK1(Object key) {
+            Set<Object> newKeys = new HashSet<Object>(k1Keys);
+            newKeys.add(key);
+            return new State(completed, unsubscribed, newKeys, k1k2Keys);
+        }
+
+        public State removeK1(Object key) {
+            Set<Object> newKeys = new HashSet<Object>(k1Keys);
+            newKeys.remove(key);
+            return new State(completed, unsubscribed, newKeys, k1k2Keys);
+        }
+
+        public State addK1k2(KeyPair<?, ?> key) {
+            Set<KeyPair<?, ?>> newKeys = new HashSet<KeyPair<?, ?>>(k1k2Keys);
+            newKeys.add(key);
+            return new State(completed, unsubscribed, k1Keys, newKeys);
+        }
+
+        public State removeK1k2(KeyPair<?, ?> key) {
+            Set<KeyPair<?, ?>> newKeys = new HashSet<KeyPair<?, ?>>(k1k2Keys);
+            newKeys.remove(key);
+            return new State(completed, unsubscribed, k1Keys, newKeys);
+        }
+
+        public State complete() {
+            return new State(true, unsubscribed, k1Keys, k1k2Keys);
+        }
+
+        public State unsubscribe() {
+            return new State(completed, true, k1Keys, k1k2Keys);
+        }
+
+        public boolean shouldComplete() {
+            if (k1Keys.size() == 0 && completed) {
+                return true;
+            } else if (unsubscribed) {
+                // if unsubscribed and all groups are completed/unsubscribed we can complete
+                return k1k2Keys.size() == 0;
+            } else {
+                return false;
+            }
+        }
+
+        @Override
+        public String toString() {
+            return "State =>  k1: " + k1Keys.size() + " k1k2: " + k1k2Keys.size() + " completed: " + completed + " unsubscribed: " + unsubscribed;
+        }
+    }
+
+    private static class KeyPair<K1, K2> {
+        private final K1 k1;
+        private final K2 k2;
+
+        KeyPair(K1 k1, K2 k2) {
+            this.k1 = k1;
+            this.k2 = k2;
+        }
+
+        @Override
+        public int hashCode() {
+            final int prime = 31;
+            int result = 1;
+            result = prime * result + ((k1 == null) ? 0 : k1.hashCode());
+            result = prime * result + ((k2 == null) ? 0 : k2.hashCode());
+            return result;
+        }
+
+        @SuppressWarnings("rawtypes")
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj)
+                return true;
+            if (obj == null)
+                return false;
+            if (getClass() != obj.getClass())
+                return false;
+            KeyPair other = (KeyPair) obj;
+            if (k1 == null) {
+                if (other.k1 != null)
+                    return false;
+            } else if (!k1.equals(other.k1))
+                return false;
+            if (k2 == null) {
+                if (other.k2 != null)
+                    return false;
+            } else if (!k2.equals(other.k2))
+                return false;
+            return true;
+        }
+
+        @Override
+        public String toString() {
+            return k2 + "." + k1;
+        }
+
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
new file mode 100644
index 0000000000..306252db3f
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
@@ -0,0 +1,201 @@
+/**
+ * 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.assertTrue;
+import static org.junit.Assert.fail;
+
+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.OnSubscribe;
+import rx.Observer;
+import rx.Subscriber;
+import rx.functions.Func1;
+import rx.observables.GroupedObservable;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+
+public class OperatorPivotTest {
+
+    @Test
+    public void testPivotEvenAndOdd() throws InterruptedException {
+        Observable<GroupedObservable<Boolean, Integer>> o1 = Observable.range(1, 10).groupBy(modKeySelector).subscribeOn(Schedulers.newThread());
+        Observable<GroupedObservable<Boolean, Integer>> o2 = Observable.range(11, 10).groupBy(modKeySelector).subscribeOn(Schedulers.newThread());
+        Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>> groups = Observable.from(GroupedObservable.from("o1", o1), GroupedObservable.from("o2", o2));
+        Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>> pivoted = Observable.pivot(groups);
+
+        final AtomicInteger count = new AtomicInteger();
+
+        final CountDownLatch latch = new CountDownLatch(1);
+
+        pivoted.flatMap(new Func1<GroupedObservable<Boolean, GroupedObservable<String, Integer>>, Observable<String>>() {
+
+            @Override
+            public Observable<String> call(final GroupedObservable<Boolean, GroupedObservable<String, Integer>> outerGroup) {
+                return outerGroup.flatMap(new Func1<GroupedObservable<String, Integer>, Observable<String>>() {
+
+                    @Override
+                    public Observable<String> call(final GroupedObservable<String, Integer> innerGroup) {
+                        return innerGroup.map(new Func1<Integer, String>() {
+
+                            @Override
+                            public String call(Integer i) {
+                                return (outerGroup.getKey() ? "Even" : "Odd ") + " => from source: " + innerGroup.getKey() + " Value: " + i;
+                            }
+
+                        });
+                    }
+
+                });
+            }
+
+        }).subscribe(new Observer<String>() {
+
+            @Override
+            public void onCompleted() {
+                System.out.println("============> OnCompleted");
+                System.out.println("-------------------------------------------------------------------------------------");
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                System.out.println("============> Error: " + e);
+                System.out.println("-------------------------------------------------------------------------------------");
+                latch.countDown();
+            }
+
+            @Override
+            public void onNext(String t) {
+                System.out.println("============> OnNext: " + t);
+                count.incrementAndGet();
+            }
+
+        });
+
+        if (!latch.await(800, TimeUnit.MILLISECONDS)) {
+            System.out.println("xxxxxxxxxxxxxxxxxx> TIMED OUT <xxxxxxxxxxxxxxxxxxxx");
+            System.out.println("Received count: " + count.get());
+            fail("Timed Out");
+        }
+
+        System.out.println("Received count: " + count.get());
+        assertEquals(20, count.get());
+    }
+
+    /**
+     * The Parent and Inner must be unsubscribed, otherwise it will keep waiting for more.
+     * 
+     * Unsubscribing from pivot is not a very easy (or typical) thing ... but it sort of works.
+     * 
+     * It's NOT easy to understand though, and easy to end up with far more data consumed than expected, because pivot by definition
+     * is inverting the data so we can not unsubscribe from the parent until all children are done since the top key becomes the leaf once pivoted.
+     */
+    @Test
+    public void testUnsubscribeFromGroups() throws InterruptedException {
+        AtomicInteger counter1 = new AtomicInteger();
+        AtomicInteger counter2 = new AtomicInteger();
+        Observable<GroupedObservable<Boolean, Integer>> o1 = getSource(2000, counter1).subscribeOn(Schedulers.newThread()).groupBy(modKeySelector);
+        Observable<GroupedObservable<Boolean, Integer>> o2 = getSource(4000, counter2).subscribeOn(Schedulers.newThread()).groupBy(modKeySelector);
+        Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>> groups = Observable.from(GroupedObservable.from("o1", o1), GroupedObservable.from("o2", o2));
+        Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>> pivoted = Observable.pivot(groups);
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        pivoted.take(2).flatMap(new Func1<GroupedObservable<Boolean, GroupedObservable<String, Integer>>, Observable<String>>() {
+
+            @Override
+            public Observable<String> call(final GroupedObservable<Boolean, GroupedObservable<String, Integer>> outerGroup) {
+                return outerGroup.flatMap(new Func1<GroupedObservable<String, Integer>, Observable<String>>() {
+
+                    @Override
+                    public Observable<String> call(final GroupedObservable<String, Integer> innerGroup) {
+                        return innerGroup.take(10).map(new Func1<Integer, String>() {
+
+                            @Override
+                            public String call(Integer i) {
+                                return (outerGroup.getKey() ? "Even" : "Odd ") + " => from source: " + innerGroup.getKey() + " Value: " + i;
+                            }
+
+                        });
+                    }
+
+                });
+            }
+
+        }).subscribe(ts);
+
+        ts.awaitTerminalEvent();
+        System.out.println("onNext [" + ts.getOnNextEvents().size() + "]: " + ts.getOnNextEvents());
+        assertEquals(40, ts.getOnNextEvents().size()); // 2 (o1 + o2) + 2 (odd + even) * take(10) on each
+
+        int c1 = counter1.get();
+        int c2 = counter2.get();
+
+        System.out.println("Counter1: " + c1);
+        System.out.println("Counter2: " + c2);
+
+        Thread.sleep(200);
+
+        System.out.println("Counter1: " + counter1.get());
+        System.out.println("Counter2: " + counter2.get());
+
+        // after time it should be same if unsubscribed
+        assertEquals(c1, counter1.get(), 1); // delta of 1 for race to unsubscribe
+        assertEquals(c2, counter2.get(), 1); // delta of 1 for race to unsubscribe
+
+        assertTrue(counter1.get() < 50000); // should be much smaller (< 1000) but this will be non-deterministic
+        assertTrue(counter2.get() < 50000); // should be much smaller (< 1000) but this will be non-deterministic
+    }
+
+    private static Observable<Integer> getSource(final int start, final AtomicInteger counter) {
+        return Observable.create(new OnSubscribe<Integer>() {
+
+            @Override
+            public void call(Subscriber<? super Integer> s) {
+                for (int i = start; i < 1000000; i++) {
+                    if (s.isUnsubscribed()) {
+                        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsubscribed so quitting in source: " + start);
+                        return;
+                    }
+                    counter.incrementAndGet();
+                    s.onNext(i);
+                    try {
+                        // slow it down so it's not just emitting it all into a buffer (merge)
+                        Thread.sleep(1);
+                    } catch (InterruptedException e) {
+                    }
+                }
+                s.onCompleted();
+            }
+
+        });
+    }
+
+    final static Func1<Integer, Boolean> modKeySelector = new Func1<Integer, Boolean>() {
+
+        @Override
+        public Boolean call(Integer i) {
+            return i % 2 == 0;
+        }
+
+    };
+}

From eb0839b7bb93fb009ee74e49190a5bac05a55e9f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 25 Mar 2014 11:16:10 -0700
Subject: [PATCH 154/422] Pivot Unit Test

---
 .../java/rx/operators/OperatorPivotTest.java  | 136 +++++++++++++++++-
 1 file changed, 135 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
index 306252db3f..85ff2a995c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
@@ -60,7 +60,7 @@ public Observable<String> call(final GroupedObservable<String, Integer> innerGro
 
                             @Override
                             public String call(Integer i) {
-                                return (outerGroup.getKey() ? "Even" : "Odd ") + " => from source: " + innerGroup.getKey() + " Value: " + i;
+                                return (outerGroup.getKey() ? "Even" : "Odd ") + " => from source: " + outerGroup.getKey() + "." + innerGroup.getKey() + " Value: " + i + " Thread: " + Thread.currentThread();
                             }
 
                         });
@@ -166,6 +166,140 @@ public String call(Integer i) {
         assertTrue(counter2.get() < 50000); // should be much smaller (< 1000) but this will be non-deterministic
     }
 
+    /**
+     * The pivot operator does not need to add any serialization but this is confirming the expected behavior.
+     * 
+     * It does not need serializing as it never merges groups, it just re-arranges them.
+     * 
+     * For example, a simple 2-stream case with odd/even:
+     * 
+     * Observable<GroupedObservable<Boolean, Integer>> o1 = Observable.range(1, 10).groupBy(modKeySelector).subscribeOn(Schedulers.newThread()); // thread 1
+     * Observable<GroupedObservable<Boolean, Integer>> o2 = Observable.range(11, 10).groupBy(modKeySelector).subscribeOn(Schedulers.newThread()); // thread 2
+     * Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>> groups = Observable.from(GroupedObservable.from("o1", o1), GroupedObservable.from("o2", o2));
+     * Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>> pivoted = Observable.pivot(groups);
+     * 
+     * ============> OnNext: Odd => from source: false.o1 Value: 1 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Even => from source: true.o2 Value: 12 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Even => from source: true.o1 Value: 2 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Odd => from source: false.o2 Value: 11 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Odd => from source: false.o2 Value: 13 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Odd => from source: false.o2 Value: 15 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Odd => from source: false.o2 Value: 17 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Even => from source: true.o2 Value: 14 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Odd => from source: false.o1 Value: 3 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Odd => from source: false.o1 Value: 5 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Odd => from source: false.o1 Value: 7 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Odd => from source: false.o1 Value: 9 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Even => from source: true.o2 Value: 16 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Even => from source: true.o2 Value: 18 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Odd => from source: false.o2 Value: 19 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnNext: Even => from source: true.o1 Value: 4 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Even => from source: true.o1 Value: 6 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Even => from source: true.o1 Value: 8 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Even => from source: true.o1 Value: 10 Thread: Thread[RxNewThreadScheduler-1,5,main]
+     * ============> OnNext: Even => from source: true.o2 Value: 20 Thread: Thread[RxNewThreadScheduler-2,5,main]
+     * ============> OnCompleted
+     * 
+     * This starts as:
+     * 
+     * => Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>>:
+     * 
+     *  o1.odd:  1,  3,  5,  7,  9 on Thread 1
+     * o1.even:  2,  4,  6,  8, 10 on Thread 1
+     *  o2.odd: 11, 13, 15, 17, 19 on Thread 2
+     * o2.even: 12, 14, 16, 18, 20 on Thread 2
+     * 
+     * It pivots to become: 
+     * 
+     * => Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>>:
+     * 
+     *  odd.o1:  1,  3,  5,  7,  9 on Thread 1
+     *  odd.o2: 11, 13, 15, 17, 19 on Thread 2
+     * even.o1:  2,  4,  6,  8, 10 on Thread 1
+     * even.o2: 12, 14, 16, 18, 20 on Thread 2
+     * 
+     * Then a subsequent step can merge them if desired and add serialization, such as merge(even.o1, even.o2) to become a serialized "even"
+     */
+    @Test
+    public void testConcurrencyAndSerialization() throws InterruptedException {
+        final AtomicInteger maxOuterConcurrency = new AtomicInteger();
+        final AtomicInteger maxGroupConcurrency = new AtomicInteger();
+        Observable<GroupedObservable<Boolean, Integer>> o1 = getSource(2000).subscribeOn(Schedulers.newThread()).groupBy(modKeySelector);
+        Observable<GroupedObservable<Boolean, Integer>> o2 = getSource(4000).subscribeOn(Schedulers.newThread()).groupBy(modKeySelector);
+        Observable<GroupedObservable<Boolean, Integer>> o3 = getSource(6000).subscribeOn(Schedulers.newThread()).groupBy(modKeySelector);
+        Observable<GroupedObservable<Boolean, Integer>> o4 = getSource(8000).subscribeOn(Schedulers.newThread()).groupBy(modKeySelector);
+        Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>> groups = Observable.from(GroupedObservable.from("o1", o1), GroupedObservable.from("o2", o2),
+                GroupedObservable.from("o3", o3), GroupedObservable.from("o4", o4));
+        Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>> pivoted = Observable.pivot(groups);
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        pivoted.take(2).flatMap(new Func1<GroupedObservable<Boolean, GroupedObservable<String, Integer>>, Observable<String>>() {
+
+            final AtomicInteger outerThreads = new AtomicInteger();
+
+            @Override
+            public Observable<String> call(final GroupedObservable<Boolean, GroupedObservable<String, Integer>> outerGroup) {
+                return outerGroup.flatMap(new Func1<GroupedObservable<String, Integer>, Observable<String>>() {
+
+                    @Override
+                    public Observable<String> call(final GroupedObservable<String, Integer> innerGroup) {
+                        final AtomicInteger threadsPerGroup = new AtomicInteger();
+                        return innerGroup.take(100).map(new Func1<Integer, String>() {
+
+                            @Override
+                            public String call(Integer i) {
+                                int outerThreadCount = outerThreads.incrementAndGet();
+                                setMaxConcurrency(maxOuterConcurrency, outerThreadCount);
+                                int innerThreadCount = threadsPerGroup.incrementAndGet();
+                                setMaxConcurrency(maxGroupConcurrency, innerThreadCount);
+                                if (innerThreadCount > 1) {
+                                    System.err.println("more than 1 thread for this group [" + innerGroup.getKey() + "]: " + innerThreadCount + " (before)");
+                                    throw new RuntimeException("more than 1 thread for this group [" + innerGroup.getKey() + "]: " + innerThreadCount + " (before)");
+                                }
+                                try {
+                                    return (outerGroup.getKey() ? "Even" : "Odd ") + " => from source: " + innerGroup.getKey() + " Value: " + i;
+                                } finally {
+                                    int outerThreadCountAfter = outerThreads.decrementAndGet();
+                                    setMaxConcurrency(maxOuterConcurrency, outerThreadCountAfter);
+                                    int innerThreadCountAfter = threadsPerGroup.decrementAndGet();
+                                    setMaxConcurrency(maxGroupConcurrency, innerThreadCountAfter);
+                                    if (innerThreadCountAfter > 0) {
+                                        System.err.println("more than 1 thread for this group [" + innerGroup.getKey() + "]: " + innerThreadCount + " (after)");
+                                        throw new RuntimeException("more than 1 thread for this group [" + innerGroup.getKey() + "]: " + innerThreadCountAfter + " (after)");
+                                    }
+                                }
+                            }
+
+                            private void setMaxConcurrency(final AtomicInteger maxOuterConcurrency, int outerThreadCount) {
+                                int max = maxOuterConcurrency.get();
+                                if (outerThreadCount > max) {
+                                    maxOuterConcurrency.compareAndSet(max, outerThreadCount);
+                                }
+                            }
+
+                        });
+                    }
+
+                });
+            }
+
+        }).subscribe(ts);
+
+        ts.awaitTerminalEvent();
+
+        System.out.println("onNext [" + ts.getOnNextEvents().size() + "]: " + ts.getOnNextEvents());
+        System.out.println("max outer concurrency: " + maxOuterConcurrency.get());
+        assertTrue(maxOuterConcurrency.get() > 2); // should be 4 since we have 4 threads running but setting at 3 as this is somewhat non-deterministic
+        System.out.println("max group concurrency: " + maxGroupConcurrency.get());
+        assertTrue(maxGroupConcurrency.get() == 1); // should always be 1
+
+        assertEquals(800, ts.getOnNextEvents().size());
+
+    }
+
+    private static Observable<Integer> getSource(final int start) {
+        return getSource(start, new AtomicInteger());
+    }
+
     private static Observable<Integer> getSource(final int start, final AtomicInteger counter) {
         return Observable.create(new OnSubscribe<Integer>() {
 

From b1c14f3a178e9f65c10add4a39ae78f10e2d630f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 25 Mar 2014 11:17:29 -0700
Subject: [PATCH 155/422] Add Javadoc to Pivot

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 9048a888c2..172e3962bd 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2489,7 +2489,25 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
     }
 
     /**
-     * Pivot GroupedObservable streams without serializing/synchronizing to a single stream first. 
+     * Pivot GroupedObservable streams without serializing/synchronizing to a single stream first.
+     *
+     * For example an Observable such as this =>
+     * 
+     * Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>>:
+     * 
+     * o1.odd: 1, 3, 5, 7, 9 on Thread 1
+     * o1.even: 2, 4, 6, 8, 10 on Thread 1
+     * o2.odd: 11, 13, 15, 17, 19 on Thread 2
+     * o2.even: 12, 14, 16, 18, 20 on Thread 2
+     * 
+     * is pivoted to become this =>
+     * 
+     * Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>>:
+     * 
+     * odd.o1: 1, 3, 5, 7, 9 on Thread 1
+     * odd.o2: 11, 13, 15, 17, 19 on Thread 2
+     * even.o1: 2, 4, 6, 8, 10 on Thread 1
+     * even.o2: 12, 14, 16, 18, 20 on Thread 2
      * 
      * @param groups
      * @return

From d1ac686cfc8895365b38084e0857eb316b15d4eb Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Tue, 25 Mar 2014 13:00:34 -0700
Subject: [PATCH 156/422] add marble diagrams to pivot() javadocs

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 172e3962bd..8f72aaea7a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -2490,24 +2490,29 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
 
     /**
      * Pivot GroupedObservable streams without serializing/synchronizing to a single stream first.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/pivot.png">
      *
-     * For example an Observable such as this =>
-     * 
-     * Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>>:
-     * 
-     * o1.odd: 1, 3, 5, 7, 9 on Thread 1
-     * o1.even: 2, 4, 6, 8, 10 on Thread 1
-     * o2.odd: 11, 13, 15, 17, 19 on Thread 2
-     * o2.even: 12, 14, 16, 18, 20 on Thread 2
+     * For example an Observable such as this =&gt;
      * 
-     * is pivoted to become this =>
-     * 
-     * Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>>:
+     * {@code Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>>}:
+     * <ul>
+     * <li>o1.odd: 1, 3, 5, 7, 9 on Thread 1</li>
+     * <li>o1.even: 2, 4, 6, 8, 10 on Thread 1</li>
+     * <li>o2.odd: 11, 13, 15, 17, 19 on Thread 2</li>
+     * <li>o2.even: 12, 14, 16, 18, 20 on Thread 2</li>
+     * </ul>
+     * is pivoted to become this =&gt;
      * 
-     * odd.o1: 1, 3, 5, 7, 9 on Thread 1
-     * odd.o2: 11, 13, 15, 17, 19 on Thread 2
-     * even.o1: 2, 4, 6, 8, 10 on Thread 1
-     * even.o2: 12, 14, 16, 18, 20 on Thread 2
+     * {@code Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>>}:
+     * <ul>
+     * <li>odd.o1: 1, 3, 5, 7, 9 on Thread 1</li>
+     * <li>odd.o2: 11, 13, 15, 17, 19 on Thread 2</li>
+     * <li>even.o1: 2, 4, 6, 8, 10 on Thread 1</li>
+     * <li>even.o2: 12, 14, 16, 18, 20 on Thread 2</li>
+     * </ul>
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/pivot.ex.png">
      * 
      * @param groups
      * @return

From 792fffe44742158030730035c05c55231e93a27d Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 25 Mar 2014 14:31:49 -0700
Subject: [PATCH 157/422] Fix SynchronizedObserver.runConcurrencyTest

It wasn't waiting on all threads before emitting onCompleted.
---
 .../src/test/java/rx/observers/SynchronizedObserverTest.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
index aad021d2e3..e3b7a6d9e5 100644
--- a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
@@ -361,14 +361,14 @@ public void runConcurrencyTest() {
 
             // 12000 + 5000 + 75000 + 13500 + 22000 + 15000 + 7500 + 23500 = 173500
 
-            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4));
+            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4, f5, f6, f7, f8));
             try {
                 Thread.sleep(1);
             } catch (InterruptedException e) {
                 // ignore
             }
 
-            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10);
+            waitOnThreads(f10);
             @SuppressWarnings("unused")
             int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
             assertEquals(173500, numNextEvents);

From 7298e763b34ca5bfd5537407a74fb6c63032ee3f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 25 Mar 2014 14:37:35 -0700
Subject: [PATCH 158/422] Fix Non-Deterministic Pivot Test

This failed on build servers (small, slow, single or dual-core machines).
---
 .../src/test/java/rx/operators/OperatorPivotTest.java       | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
index 85ff2a995c..6293974272 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
@@ -287,8 +287,10 @@ private void setMaxConcurrency(final AtomicInteger maxOuterConcurrency, int oute
         ts.awaitTerminalEvent();
 
         System.out.println("onNext [" + ts.getOnNextEvents().size() + "]: " + ts.getOnNextEvents());
-        System.out.println("max outer concurrency: " + maxOuterConcurrency.get());
-        assertTrue(maxOuterConcurrency.get() > 2); // should be 4 since we have 4 threads running but setting at 3 as this is somewhat non-deterministic
+        if (Runtime.getRuntime().availableProcessors() >= 4) {
+            System.out.println("max outer concurrency: " + maxOuterConcurrency.get());
+            assertTrue(maxOuterConcurrency.get() > 1); // should be 4 since we have 4 threads and cores running but setting at just > 1 as this is non-deterministic
+        }
         System.out.println("max group concurrency: " + maxGroupConcurrency.get());
         assertTrue(maxGroupConcurrency.get() == 1); // should always be 1
 

From fb47ac80792cbaa029a31a6755d7e82d06e787a5 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 25 Mar 2014 14:55:50 -0700
Subject: [PATCH 159/422] OnErrorFailedException

Re-throw when onError throws an Exception.
This fixes https://github.com/Netflix/RxJava/issues/969
---
 .../main/java/rx/exceptions/Exceptions.java   |  7 ++++
 .../rx/exceptions/OnErrorFailedException.java | 35 +++++++++++++++++++
 .../java/rx/observers/SafeSubscriber.java     |  7 ++--
 .../java/rx/exceptions/ExceptionsTest.java    | 33 +++++++++++++++++
 .../java/rx/observers/SafeObserverTest.java   | 10 ++++--
 5 files changed, 87 insertions(+), 5 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/exceptions/OnErrorFailedException.java

diff --git a/rxjava-core/src/main/java/rx/exceptions/Exceptions.java b/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
index 5fccfb2a61..86679c61b2 100644
--- a/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
+++ b/rxjava-core/src/main/java/rx/exceptions/Exceptions.java
@@ -44,6 +44,13 @@ public static RuntimeException propagate(Throwable t) {
     public static void throwIfFatal(Throwable t) {
         if (t instanceof OnErrorNotImplementedException) {
             throw (OnErrorNotImplementedException) t;
+        } else if (t instanceof OnErrorFailedException) {
+            Throwable cause = ((OnErrorFailedException) t).getCause();
+            if (cause instanceof RuntimeException) {
+                throw (RuntimeException) cause;
+            } else {
+                throw (OnErrorFailedException) t;
+            }
         }
         // values here derived from https://github.com/Netflix/RxJava/issues/748#issuecomment-32471495
         else if (t instanceof StackOverflowError) {
diff --git a/rxjava-core/src/main/java/rx/exceptions/OnErrorFailedException.java b/rxjava-core/src/main/java/rx/exceptions/OnErrorFailedException.java
new file mode 100644
index 0000000000..be75ac82af
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/exceptions/OnErrorFailedException.java
@@ -0,0 +1,35 @@
+/**
+ * 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;
+
+import rx.Subscriber;
+
+/**
+ * Used for re-throwing errors thrown from {@link Subscriber#onError(Throwable)}.
+ * 
+ * https://github.com/Netflix/RxJava/issues/969
+ */
+public class OnErrorFailedException extends RuntimeException {
+    private static final long serialVersionUID = -419289748403337611L;
+
+    public OnErrorFailedException(String message, Throwable e) {
+        super(message, e);
+    }
+
+    public OnErrorFailedException(Throwable e) {
+        super(e.getMessage(), e);
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
index ff121eeb77..1bdbcd8272 100644
--- a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
@@ -21,6 +21,7 @@
 import rx.Subscriber;
 import rx.exceptions.CompositeException;
 import rx.exceptions.Exceptions;
+import rx.exceptions.OnErrorFailedException;
 import rx.exceptions.OnErrorNotImplementedException;
 import rx.plugins.RxJavaPlugins;
 
@@ -165,10 +166,10 @@ protected void _onError(Throwable e) {
                     } 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)));
+                    throw new OnErrorFailedException("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)));
+                throw new OnErrorFailedException("Error occurred when trying to propagate error to Observer.onError", new CompositeException(Arrays.asList(e, e2)));
             }
         }
         // if we did not throw above we will unsubscribe here, if onError failed then unsubscribe happens in the catch
@@ -180,7 +181,7 @@ protected void _onError(Throwable e) {
             } catch (Throwable pluginException) {
                 handlePluginException(pluginException);
             }
-            throw unsubscribeException;
+            throw new OnErrorFailedException(unsubscribeException);
         }
     }
 
diff --git a/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
index 6880553736..75ce52c27e 100644
--- a/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/ExceptionsTest.java
@@ -15,6 +15,9 @@
  */
 package rx.exceptions;
 
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import org.junit.Test;
 
 import rx.Observable;
@@ -134,4 +137,34 @@ public void onNext(Integer t) {
         });
     }
 
+    /**
+     * https://github.com/Netflix/RxJava/issues/969
+     */
+    @Test
+    public void testOnErrorExceptionIsThrown() {
+        try {
+            Observable.error(new IllegalArgumentException("original exception")).subscribe(new Observer<Object>() {
+                @Override
+                public void onCompleted() {
+
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    throw new IllegalStateException("This should be thrown");
+                }
+
+                @Override
+                public void onNext(Object o) {
+
+                }
+            });
+            fail("expecting an exception to be thrown");
+        } catch (CompositeException t) {
+            CompositeException ce = (CompositeException) t;
+            assertTrue(ce.getExceptions().get(0) instanceof IllegalArgumentException);
+            assertTrue(ce.getExceptions().get(1) instanceof IllegalStateException);
+        }
+    }
+
 }
diff --git a/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java b/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
index 89b835ce00..f4316d4698 100644
--- a/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SafeObserverTest.java
@@ -15,7 +15,11 @@
  */
 package rx.observers;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -23,6 +27,7 @@
 
 import rx.Subscriber;
 import rx.exceptions.CompositeException;
+import rx.exceptions.OnErrorFailedException;
 import rx.exceptions.OnErrorNotImplementedException;
 import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
@@ -215,7 +220,8 @@ public void call() {
             assertEquals("failed", onError.get().getMessage());
 
             // now assert the exception that was thrown
-            assertTrue(e instanceof SafeObserverTestException);
+            OnErrorFailedException onErrorFailedException = (OnErrorFailedException) e;
+            assertTrue(onErrorFailedException.getCause() instanceof SafeObserverTestException);
             assertEquals("failure from unsubscribe", e.getMessage());
         }
     }

From 007774ba6207ffaa2157a98ac684e37894c71308 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Tue, 25 Mar 2014 22:24:04 +0000
Subject: [PATCH 160/422] [Gradle Release Plugin] - pre tag commit:  '0.17.2'.

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

diff --git a/gradle.properties b/gradle.properties
index bc0a89d83b..b7d2c2b03a 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.2-SNAPSHOT
+version=0.17.2

From 156132a32e76bc8a9a1a5eeb8e9247758aabd9af Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Tue, 25 Mar 2014 22:24:08 +0000
Subject: [PATCH 161/422] [Gradle Release Plugin] - new version commit: 
 '0.17.3-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index b7d2c2b03a..6d1856974e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.2
+version=0.17.3-SNAPSHOT

From f999255e8733275b07a7e0baec289f923191dc76 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Tue, 25 Mar 2014 15:30:06 -0700
Subject: [PATCH 162/422] 0.17.2

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

diff --git a/CHANGES.md b/CHANGES.md
index 881656798b..c510b7abab 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,24 @@
 # RxJava Releases #
 
+### Version 0.17.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.2%22)) ###
+
+* [Pull 963](https://github.com/Netflix/RxJava/pull/963) A more robust JMH benchmarking set-up 
+* [Pull 964](https://github.com/Netflix/RxJava/pull/964) SubjectSubscriptionManager fix.
+* [Pull 970](https://github.com/Netflix/RxJava/pull/970) Notifications for the allocation averse.
+* [Pull 973](https://github.com/Netflix/RxJava/pull/973) Merge - Handle Bad Observables
+* [Pull 974](https://github.com/Netflix/RxJava/pull/974) TestSubject, TestObserver and TestScheduler Improvements
+* [Pull 975](https://github.com/Netflix/RxJava/pull/975) GroupBy & Time Gap Fixes
+* [Pull 976](https://github.com/Netflix/RxJava/pull/976) parallel-merge unit test assertions
+* [Pull 977](https://github.com/Netflix/RxJava/pull/977) Dematerialize - handle non-materialized terminal events
+* [Pull 982](https://github.com/Netflix/RxJava/pull/982) Pivot Operator
+* [Pull 984](https://github.com/Netflix/RxJava/pull/984) Tests and Javadoc for Pivot
+* [Pull 966](https://github.com/Netflix/RxJava/pull/966) Reimplement the ElementAt operator and add it to rxjava-scala
+* [Pull 965](https://github.com/Netflix/RxJava/pull/965) BugFix: Chain Subscription in TimeoutSubscriber and SerializedSubscriber
+* [Pull 986](https://github.com/Netflix/RxJava/pull/986) Fix SynchronizedObserver.runConcurrencyTest
+* [Pull 987](https://github.com/Netflix/RxJava/pull/987) Fix Non-Deterministic Pivot Test
+* [Pull 988](https://github.com/Netflix/RxJava/pull/988) OnErrorFailedException
+
+
 ### Version 0.17.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.1%22)) ###
 
 * [Pull 953](https://github.com/Netflix/RxJava/pull/953) Make ObserveOnTest.testNonBlockingOuterWhileBlockingOnNext deterministic

From 770240d008880861edf804911c05c260c56e0314 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Wed, 26 Mar 2014 22:19:30 +0200
Subject: [PATCH 163/422] Use Quasar 0.5.0 release

---
 .gitignore                                | 2 ++
 rxjava-contrib/rxjava-quasar/build.gradle | 6 +++---
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 606575380d..3889cb7d51 100644
--- a/.gitignore
+++ b/.gitignore
@@ -63,6 +63,8 @@ bin/
 # NetBeans specific files/directories
 .nbattrs
 /.nb-gradle/profiles/private/
+.nb-gradle-properties
 
 # Scala build
 *.cache
+/.nb-gradle/private/
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-quasar/build.gradle b/rxjava-contrib/rxjava-quasar/build.gradle
index 72586db6a1..fdcac9663f 100644
--- a/rxjava-contrib/rxjava-quasar/build.gradle
+++ b/rxjava-contrib/rxjava-quasar/build.gradle
@@ -10,13 +10,13 @@ configurations {
 repositories {
     mavenLocal()
     mavenCentral()
-    maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
+    // maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
 }
 
 dependencies {
     compile project(':rxjava-core')
-    compile 'co.paralleluniverse:quasar-core:0.5.0-SNAPSHOT'
-    quasar  'co.paralleluniverse:quasar-core:0.5.0-SNAPSHOT'
+    compile 'co.paralleluniverse:quasar-core:0.5.0'
+    quasar  'co.paralleluniverse:quasar-core:0.5.0'
     testCompile project(":rxjava-core").sourceSets.test.output 
     provided 'junit:junit-dep:4.10'
     provided 'org.mockito:mockito-core:1.8.5'

From bcb44e0990135fd70c7a20906dc84126eecf456a Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 26 Mar 2014 15:31:11 -0700
Subject: [PATCH 164/422] fix jmh build config

This is now working from command-line and Eclipse
---
 build.gradle             | 46 +++++++++++-----------------------------
 rxjava-core/build.gradle |  4 ++--
 2 files changed, 14 insertions(+), 36 deletions(-)

diff --git a/build.gradle b/build.gradle
index 366a6f94dc..3cafa5b42c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -10,19 +10,9 @@ buildscript {
     repositories {
         mavenLocal()
         mavenCentral()
-        maven {
-            //FIXME: waiting for https://github.com/johnrengelman/shadow/pull/38 to merge
-            name 'Shadow'
-            url 'http://dl.bintray.com/content/gvsmirnov/gradle-plugins'
-        }
         jcenter()
     }
 
-    dependencies {
-        // Required for benchmarks
-        classpath 'com.github.jengelman.gradle.plugins:shadow:0.8.1'
-    }
-
     apply from: file('gradle/buildscript.gradle'), to: buildscript 
 }
 
@@ -43,6 +33,8 @@ subprojects {
     configurations { 
         examplesCompile.extendsFrom compile
         examplesRuntime.extendsFrom runtime
+        perfCompile.extendsFrom compile
+        perfRuntime.extendsFrom runtime
     }
 
 
@@ -52,19 +44,22 @@ subprojects {
 
     sourceSets {
         examples
-        perf
+        perf {
+		    compileClasspath += sourceSets.main.output
+		}
     }
 
     tasks.build { 
         //include 'examples' in build task
         dependsOn(examplesClasses)
+		dependsOn(perfClasses)
     }
 
     dependencies {
         perfCompile 'org.openjdk.jmh:jmh-core:0.5.3'
         perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:0.5.3'
 
-        perfCompile project
+        //perfCompile project
     }
     
     eclipse {  
@@ -83,28 +78,11 @@ subprojects {
         }
     }
 
-    task perfJar(type: Jar, dependsOn: perfClasses) {
-        from sourceSets.perf.output + sourceSets.main.output
-    }
-
-    task benchmarks(dependsOn: perfJar) {
-
-        apply plugin: "shadow"
-
-        shadow {
-            classifier = "benchmarks"
-            includeDependenciesFor = ["runtime", "perfRuntime"]
-
-            transformer(com.github.jengelman.gradle.plugins.shadow.transformers.ManifestResourceTransformer) {
-                mainClass = "org.openjdk.jmh.Main"
-            }
-        }
-
-        doLast {
-            shadowJar.execute()
-        }
-
-    }
+	task benchmarks(type: JavaExec) {
+		main = 'org.openjdk.jmh.Main'
+		classpath = sourceSets.perf.runtimeClasspath + sourceSets.main.output
+	}
+	
 }
 
 project(':rxjava-core') {
diff --git a/rxjava-core/build.gradle b/rxjava-core/build.gradle
index d03c5653a4..6e50441495 100644
--- a/rxjava-core/build.gradle
+++ b/rxjava-core/build.gradle
@@ -5,8 +5,8 @@ sourceCompatibility = JavaVersion.VERSION_1_6
 targetCompatibility = JavaVersion.VERSION_1_6
 
 dependencies {
-    provided 'junit:junit-dep:4.10'
-    provided 'org.mockito:mockito-core:1.8.5'
+    testCompile 'junit:junit-dep:4.10'
+    testCompile 'org.mockito:mockito-core:1.8.5'
 }
 
 javadoc {

From 3520445b61b7f4f483dfbd742cb973044e5fde13 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 26 Mar 2014 16:42:22 -0700
Subject: [PATCH 165/422] Migrate Pre-JMH Tests to rx.archive

---
 .../ObservableCreatePerformance.java          |   8 +-
 .../composition/RangeMapTakeOnNextPerf.java   |   6 +-
 .../OperatorFromIterablePerformance.java      |   8 +-
 .../operators/OperatorMapPerformance.java     |   6 +-
 .../operators/OperatorMergePerformance.java   |   8 +-
 .../OperatorObserveOnPerformance.java         |   7 +-
 .../OperatorParallelPerformance.java          |   6 +-
 .../operators/OperatorRangePerformance.java   |   6 +-
 .../OperatorSerializePerformance.java         |   6 +-
 .../OperatorSynchronizePerformance.java       |   6 +-
 .../operators/OperatorTakePerformance.java    |   6 +-
 .../operators/OperatorZipPerformance.java     |   6 +-
 .../perf/AbstractPerformanceTester.java       |   2 +-
 .../perf/IntegerSumObserver.java              |   2 +-
 .../{ => archive}/perf/LongSumObserver.java   |   2 +-
 .../performance/PerformanceTest.java          |   2 +-
 .../performance/TestChainPerformance.java     |   2 +-
 .../schedulers/SchedulerPerformanceTests.java |   3 +-
 .../schedulers/TestRecursionMemoryUsage.java  | 106 ++++++++++++++++++
 .../subjects/SubjectPerformanceTests.java     |   3 +-
 .../CompositeSubscriptionAddRemovePerf.java   |   6 +-
 ...bleBenchmark.java => OperatorMapPerf.java} |  10 +-
 .../schedulers/TestRecursionMemoryUsage.java  | 100 -----------------
 23 files changed, 167 insertions(+), 150 deletions(-)
 rename rxjava-core/src/perf/java/rx/{ => archive}/ObservableCreatePerformance.java (92%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/composition/RangeMapTakeOnNextPerf.java (92%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorFromIterablePerformance.java (96%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorMapPerformance.java (92%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorMergePerformance.java (96%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorObserveOnPerformance.java (94%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorParallelPerformance.java (92%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorRangePerformance.java (91%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorSerializePerformance.java (98%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorSynchronizePerformance.java (98%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorTakePerformance.java (91%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/operators/OperatorZipPerformance.java (96%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/perf/AbstractPerformanceTester.java (98%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/perf/IntegerSumObserver.java (93%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/perf/LongSumObserver.java (92%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/performance/PerformanceTest.java (99%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/performance/TestChainPerformance.java (98%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/schedulers/SchedulerPerformanceTests.java (98%)
 create mode 100644 rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
 rename rxjava-core/src/perf/java/rx/{ => archive}/subjects/SubjectPerformanceTests.java (98%)
 rename rxjava-core/src/perf/java/rx/{ => archive}/subscriptions/CompositeSubscriptionAddRemovePerf.java (89%)
 rename rxjava-core/src/perf/java/rx/operators/{ObservableBenchmark.java => OperatorMapPerf.java} (91%)
 delete mode 100644 rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java

diff --git a/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java b/rxjava-core/src/perf/java/rx/archive/ObservableCreatePerformance.java
similarity index 92%
rename from rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
rename to rxjava-core/src/perf/java/rx/archive/ObservableCreatePerformance.java
index 845cfeb412..5ac888a14e 100644
--- a/rxjava-core/src/perf/java/rx/ObservableCreatePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/ObservableCreatePerformance.java
@@ -1,9 +1,11 @@
-package rx;
+package rx.archive;
 
+import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.LongSumObserver;
 import rx.functions.Action0;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.LongSumObserver;
 
 public class ObservableCreatePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/composition/RangeMapTakeOnNextPerf.java b/rxjava-core/src/perf/java/rx/archive/composition/RangeMapTakeOnNextPerf.java
similarity index 92%
rename from rxjava-core/src/perf/java/rx/composition/RangeMapTakeOnNextPerf.java
rename to rxjava-core/src/perf/java/rx/archive/composition/RangeMapTakeOnNextPerf.java
index 8bb8942357..3ca90131a4 100644
--- a/rxjava-core/src/perf/java/rx/composition/RangeMapTakeOnNextPerf.java
+++ b/rxjava-core/src/perf/java/rx/archive/composition/RangeMapTakeOnNextPerf.java
@@ -1,8 +1,8 @@
-package rx.composition;
+package rx.archive.composition;
 
 import rx.Observable;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.util.functions.Action0;
 import rx.util.functions.Func1;
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorFromIterablePerformance.java
similarity index 96%
rename from rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorFromIterablePerformance.java
index 522dc15351..ff370e5c27 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorFromIterablePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorFromIterablePerformance.java
@@ -1,13 +1,13 @@
-package rx.operators;
+package rx.archive.operators;
 
 import java.util.Arrays;
 import java.util.Iterator;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
+import rx.archive.perf.LongSumObserver;
 import rx.functions.Action0;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
-import rx.perf.LongSumObserver;
 
 public class OperatorFromIterablePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorMapPerformance.java
similarity index 92%
rename from rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorMapPerformance.java
index b40aa72dd5..a9bfb30c7c 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorMapPerformance.java
@@ -1,10 +1,10 @@
-package rx.operators;
+package rx.archive.operators;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.LongSumObserver;
 import rx.functions.Action0;
 import rx.functions.Func1;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.LongSumObserver;
 
 public class OperatorMapPerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorMergePerformance.java
similarity index 96%
rename from rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorMergePerformance.java
index ee3713baf6..25d8684c29 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMergePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorMergePerformance.java
@@ -1,10 +1,10 @@
-package rx.operators;
+package rx.archive.operators;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
+import rx.archive.perf.LongSumObserver;
 import rx.functions.Action0;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
-import rx.perf.LongSumObserver;
 import rx.schedulers.Schedulers;
 
 public class OperatorMergePerformance extends AbstractPerformanceTester {
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorObserveOnPerformance.java
similarity index 94%
rename from rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorObserveOnPerformance.java
index c892fe493b..e86f112990 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorObserveOnPerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorObserveOnPerformance.java
@@ -1,9 +1,10 @@
-package rx.operators;
+package rx.archive.operators;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
+import rx.operators.OperatorObserveOnBounded;
 import rx.schedulers.Schedulers;
 
 public class OperatorObserveOnPerformance extends AbstractPerformanceTester {
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorParallelPerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorParallelPerformance.java
similarity index 92%
rename from rxjava-core/src/perf/java/rx/operators/OperatorParallelPerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorParallelPerformance.java
index 818407d7e4..41afed5c6d 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorParallelPerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorParallelPerformance.java
@@ -1,10 +1,10 @@
-package rx.operators;
+package rx.archive.operators;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
 import rx.functions.Func1;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
 
 public class OperatorParallelPerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorRangePerformance.java
similarity index 91%
rename from rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorRangePerformance.java
index 034342c183..4a658b2f44 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorRangePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorRangePerformance.java
@@ -1,9 +1,9 @@
-package rx.operators;
+package rx.archive.operators;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
 
 public class OperatorRangePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
similarity index 98%
rename from rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
index cfe70889cf..366d23d092 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
@@ -1,4 +1,4 @@
-package rx.operators;
+package rx.archive.operators;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -6,11 +6,11 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Subscriber;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
 import rx.schedulers.Schedulers;
 
 public class OperatorSerializePerformance extends AbstractPerformanceTester {
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSynchronizePerformance.java
similarity index 98%
rename from rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorSynchronizePerformance.java
index a7396693fb..dd5e2f0703 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSynchronizePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSynchronizePerformance.java
@@ -1,4 +1,4 @@
-package rx.operators;
+package rx.archive.operators;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -6,11 +6,11 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Subscriber;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
 import rx.schedulers.Schedulers;
 
 public class OperatorSynchronizePerformance extends AbstractPerformanceTester {
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorTakePerformance.java
similarity index 91%
rename from rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorTakePerformance.java
index 6e28f51545..85a8a09f49 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorTakePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorTakePerformance.java
@@ -1,9 +1,9 @@
-package rx.operators;
+package rx.archive.operators;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
 
 public class OperatorTakePerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorZipPerformance.java
similarity index 96%
rename from rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
rename to rxjava-core/src/perf/java/rx/archive/operators/OperatorZipPerformance.java
index aa2c071560..6248409f8f 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorZipPerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorZipPerformance.java
@@ -1,10 +1,10 @@
-package rx.operators;
+package rx.archive.operators;
 
 import rx.Observable;
+import rx.archive.perf.AbstractPerformanceTester;
+import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
 import rx.functions.Func2;
-import rx.perf.AbstractPerformanceTester;
-import rx.perf.IntegerSumObserver;
 
 public class OperatorZipPerformance extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java b/rxjava-core/src/perf/java/rx/archive/perf/AbstractPerformanceTester.java
similarity index 98%
rename from rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
rename to rxjava-core/src/perf/java/rx/archive/perf/AbstractPerformanceTester.java
index 32ef5c3a7b..490489ed5c 100644
--- a/rxjava-core/src/perf/java/rx/perf/AbstractPerformanceTester.java
+++ b/rxjava-core/src/perf/java/rx/archive/perf/AbstractPerformanceTester.java
@@ -1,4 +1,4 @@
-package rx.perf;
+package rx.archive.perf;
 
 import java.util.Iterator;
 
diff --git a/rxjava-core/src/perf/java/rx/perf/IntegerSumObserver.java b/rxjava-core/src/perf/java/rx/archive/perf/IntegerSumObserver.java
similarity index 93%
rename from rxjava-core/src/perf/java/rx/perf/IntegerSumObserver.java
rename to rxjava-core/src/perf/java/rx/archive/perf/IntegerSumObserver.java
index 28a522fbd8..30a7560311 100644
--- a/rxjava-core/src/perf/java/rx/perf/IntegerSumObserver.java
+++ b/rxjava-core/src/perf/java/rx/archive/perf/IntegerSumObserver.java
@@ -1,4 +1,4 @@
-package rx.perf;
+package rx.archive.perf;
 
 import rx.Subscriber;
 
diff --git a/rxjava-core/src/perf/java/rx/perf/LongSumObserver.java b/rxjava-core/src/perf/java/rx/archive/perf/LongSumObserver.java
similarity index 92%
rename from rxjava-core/src/perf/java/rx/perf/LongSumObserver.java
rename to rxjava-core/src/perf/java/rx/archive/perf/LongSumObserver.java
index 5465b326f0..c112d1598a 100644
--- a/rxjava-core/src/perf/java/rx/perf/LongSumObserver.java
+++ b/rxjava-core/src/perf/java/rx/archive/perf/LongSumObserver.java
@@ -1,4 +1,4 @@
-package rx.perf;
+package rx.archive.perf;
 
 import rx.Subscriber;
 
diff --git a/rxjava-core/src/perf/java/rx/performance/PerformanceTest.java b/rxjava-core/src/perf/java/rx/archive/performance/PerformanceTest.java
similarity index 99%
rename from rxjava-core/src/perf/java/rx/performance/PerformanceTest.java
rename to rxjava-core/src/perf/java/rx/archive/performance/PerformanceTest.java
index 7b69baa964..d54d3bcfa0 100644
--- a/rxjava-core/src/perf/java/rx/performance/PerformanceTest.java
+++ b/rxjava-core/src/perf/java/rx/archive/performance/PerformanceTest.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.performance;
+package rx.archive.performance;
 
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
diff --git a/rxjava-core/src/perf/java/rx/performance/TestChainPerformance.java b/rxjava-core/src/perf/java/rx/archive/performance/TestChainPerformance.java
similarity index 98%
rename from rxjava-core/src/perf/java/rx/performance/TestChainPerformance.java
rename to rxjava-core/src/perf/java/rx/archive/performance/TestChainPerformance.java
index 8cbf000aa5..d230df026c 100644
--- a/rxjava-core/src/perf/java/rx/performance/TestChainPerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/performance/TestChainPerformance.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.performance;
+package rx.archive.performance;
 
 import java.util.ArrayList;
 import java.util.concurrent.Callable;
diff --git a/rxjava-core/src/perf/java/rx/schedulers/SchedulerPerformanceTests.java b/rxjava-core/src/perf/java/rx/archive/schedulers/SchedulerPerformanceTests.java
similarity index 98%
rename from rxjava-core/src/perf/java/rx/schedulers/SchedulerPerformanceTests.java
rename to rxjava-core/src/perf/java/rx/archive/schedulers/SchedulerPerformanceTests.java
index e5f5e5a8b3..392dc50283 100644
--- a/rxjava-core/src/perf/java/rx/schedulers/SchedulerPerformanceTests.java
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/SchedulerPerformanceTests.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.schedulers;
+package rx.archive.schedulers;
 
 import java.util.Arrays;
 
@@ -21,6 +21,7 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.functions.Action0;
+import rx.schedulers.Schedulers;
 
 public class SchedulerPerformanceTests {
 
diff --git a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
new file mode 100644
index 0000000000..2e120596ee
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.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.archive.schedulers;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Scheduler;
+import rx.Scheduler.Inner;
+import rx.Subscriber;
+import rx.functions.Action1;
+import rx.schedulers.Schedulers;
+
+/**
+ * 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.computation());
+		usingAction0(Schedulers.computation());
+
+		System.exit(0);
+	}
+
+	protected static void usingFunc2(final Scheduler scheduler) {
+		System.out.println("************ usingFunc2: " + scheduler);
+		Observable.create(new OnSubscribe<Long>() {
+
+			@Override
+			public void call(final Subscriber<? super Long> o) {
+				o.add(scheduler.schedule(new Action1<Inner>() {
+					long i = 0;
+
+					@Override
+					public void call(Inner inner) {
+						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;
+						}
+
+						inner.schedule(this);
+					}
+				}));
+			}
+		}).toBlockingObservable().last();
+	}
+
+	protected static void usingAction0(final Scheduler scheduler) {
+		System.out.println("************ usingAction0: " + scheduler);
+		Observable.create(new OnSubscribe<Long>() {
+
+			@Override
+			public void call(final Subscriber<? super Long> o) {
+				o.add(scheduler.schedule(new Action1<Inner>() {
+
+					private long i = 0;
+
+					@Override
+					public void call(Inner inner) {
+						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;
+						}
+						inner.schedule(this);
+					}
+				}));
+			}
+		}).toBlockingObservable().last();
+	}
+}
diff --git a/rxjava-core/src/perf/java/rx/subjects/SubjectPerformanceTests.java b/rxjava-core/src/perf/java/rx/archive/subjects/SubjectPerformanceTests.java
similarity index 98%
rename from rxjava-core/src/perf/java/rx/subjects/SubjectPerformanceTests.java
rename to rxjava-core/src/perf/java/rx/archive/subjects/SubjectPerformanceTests.java
index 4b5f3af5b1..187c63b328 100644
--- a/rxjava-core/src/perf/java/rx/subjects/SubjectPerformanceTests.java
+++ b/rxjava-core/src/perf/java/rx/archive/subjects/SubjectPerformanceTests.java
@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package rx.subjects;
+package rx.archive.subjects;
 
 import rx.Subscriber;
 import rx.functions.Action0;
+import rx.subjects.ReplaySubject;
 
 public class SubjectPerformanceTests {
 
diff --git a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java b/rxjava-core/src/perf/java/rx/archive/subscriptions/CompositeSubscriptionAddRemovePerf.java
similarity index 89%
rename from rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
rename to rxjava-core/src/perf/java/rx/archive/subscriptions/CompositeSubscriptionAddRemovePerf.java
index 17931430d4..f1524b4769 100644
--- a/rxjava-core/src/perf/java/rx/subscriptions/CompositeSubscriptionAddRemovePerf.java
+++ b/rxjava-core/src/perf/java/rx/archive/subscriptions/CompositeSubscriptionAddRemovePerf.java
@@ -1,7 +1,9 @@
-package rx.subscriptions;
+package rx.archive.subscriptions;
 
+import rx.archive.perf.AbstractPerformanceTester;
 import rx.functions.Action0;
-import rx.perf.AbstractPerformanceTester;
+import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.CompositeSubscription;
 
 public class CompositeSubscriptionAddRemovePerf extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
similarity index 91%
rename from rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
rename to rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
index 5de2a022d7..7ae07c68b1 100644
--- a/rxjava-core/src/perf/java/rx/operators/ObservableBenchmark.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
@@ -4,9 +4,13 @@
 import java.util.Collection;
 import java.util.concurrent.CountDownLatch;
 
-import org.openjdk.jmh.annotations.*;
-
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.logic.BlackHole;
+
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
@@ -14,7 +18,7 @@
 import rx.Subscriber;
 import rx.functions.Func1;
 
-public class ObservableBenchmark {
+public class OperatorMapPerf {
 
     @GenerateMicroBenchmark
     public void measureBaseline(BlackHole bh, Input input) {
diff --git a/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java
deleted file mode 100644
index 7453fb941d..0000000000
--- a/rxjava-core/src/perf/java/rx/schedulers/TestRecursionMemoryUsage.java
+++ /dev/null
@@ -1,100 +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.schedulers;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.Subscription;
-import rx.functions.Action1;
-
-/**
- * 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.computation());
-        usingAction0(Schedulers.computation());
-        
-        System.exit(0);
-    }
-
-    protected static void usingFunc2(final Scheduler scheduler) {
-        System.out.println("************ usingFunc2: " + scheduler);
-        Observable.create(new OnSubscribeFunc<Long>() {
-
-            @Override
-            public Subscription onSubscribe(final Observer<? super Long> o) {
-                return scheduler.schedule(new Action1<Inner>() {
-                    long i = 0;
-
-                    @Override
-                    public void call(Inner inner) {
-                        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;
-                        }
-
-                        inner.schedule(this);
-                    }
-                });
-            }
-        }).toBlockingObservable().last();
-    }
-
-    protected static void usingAction0(final Scheduler scheduler) {
-        System.out.println("************ usingAction0: " + scheduler);
-        Observable.create(new OnSubscribeFunc<Long>() {
-
-            @Override
-            public Subscription onSubscribe(final Observer<? super Long> o) {
-                return scheduler.schedule(new Action1<Inner>() {
-
-                    private long i = 0;
-
-                    @Override
-                    public void call(Inner inner) {
-                        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;
-                        }
-                        inner.schedule(this);
-                    }
-                });
-            }
-        }).toBlockingObservable().last();
-    }
-}

From 5f3622127e8c9ae2c9ceeb2fb7cc6d0446283aff Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Thu, 27 Mar 2014 02:42:01 +0200
Subject: [PATCH 166/422] Target Java 1.6

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

diff --git a/rxjava-contrib/rxjava-quasar/build.gradle b/rxjava-contrib/rxjava-quasar/build.gradle
index fdcac9663f..bb80b916d4 100644
--- a/rxjava-contrib/rxjava-quasar/build.gradle
+++ b/rxjava-contrib/rxjava-quasar/build.gradle
@@ -1,7 +1,7 @@
 apply plugin: 'osgi'
 
 sourceCompatibility = JavaVersion.VERSION_1_6
-targetCompatibility = JavaVersion.VERSION_1_7
+targetCompatibility = JavaVersion.VERSION_1_6
 
 configurations {
     quasar

From 30d53a5b557e0ddac3b6ed0d955954c93a0a34e1 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Thu, 27 Mar 2014 03:50:15 +0200
Subject: [PATCH 167/422] Match updated RxJava API (rx.util.function ->
 rx.functions etc.)

---
 .../java/rx/quasar/BlockingObservable.java    |  6 ++---
 .../java/rx/quasar/NewFiberScheduler.java     |  4 ++--
 .../rx/quasar/RxSuspendableClassifier.java    | 18 ++++++++++----
 .../resources/META-INF/suspendable-supers     | 24 +------------------
 4 files changed, 20 insertions(+), 32 deletions(-)

diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
index a161e184d8..7bffe4747f 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
@@ -34,10 +34,10 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.exceptions.Exceptions;
+import rx.functions.Action1;
+import rx.functions.Func1;
 import rx.observers.SafeSubscriber;
-import rx.util.Exceptions;
-import rx.util.functions.Action1;
-import rx.util.functions.Func1;
 
 /**
  * An extension of {@link Observable} that provides blocking operators, compatible with both threads and fibers.
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
index ec6720d4b2..f5edc254f6 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
@@ -26,7 +26,7 @@
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.util.functions.Action1;
+import rx.functions.Action1;
 
 /**
  * Schedules work on a new fiber.
@@ -58,7 +58,7 @@ public Subscription schedule(Action1<Scheduler.Inner> action) {
         innerScheduler.schedule(action);
         return innerScheduler.innerSubscription;
     }
-
+    
     @Override
     public Subscription schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit) {
         EventLoopScheduler innerScheduler = new EventLoopScheduler();
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
index 14b24f294d..4905ea4bfa 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
@@ -25,12 +25,13 @@
 public class RxSuspendableClassifier implements SuspendableClassifier {
     private static final Set<String> CORE_PACKAGES = new HashSet<String>(Arrays.asList(new String[]{
         "rx", "rx.joins", "rx.observables", "rx.observers", "rx.operators", "rx.plugins", "rx.schedulers",
-        "rx.subjects", "rx.subscriptions", "rx.util", "rx.util.functions"
+        "rx.subjects", "rx.subscriptions", "rx.functions", "rx.util", "rx.util.functions"
     }));
 
     private static final Set<String> EXCEPTIONS = new HashSet<String>(Arrays.asList(new String[]{
         "rx/observers/SynchronizedObserver",
-        "rx/schedulers/AbstractSchedulerTests$ConcurrentObserverValidator",}));
+        "rx/schedulers/AbstractSchedulerTests$ConcurrentObserverValidator",
+    }));
 
     private static final Set<String> OBSERVER_METHODS = new HashSet<String>(Arrays.asList(new String[]{
         "onNext(Ljava/lang/Object;)V", "onCompleted()V", "onError(Ljava/lang/Throwable;)V"
@@ -47,6 +48,12 @@ public MethodDatabase.SuspendableType isSuspendable(MethodDatabase db, String cl
             else if (isUtilFunction(db, className, superClassName, interfaces, methodName, methodDesc))
                 s = MethodDatabase.SuspendableType.SUSPENDABLE;
         }
+        if (s == null 
+                && methodName.equals("call")
+                && (className.startsWith("rx/functions/Func") || className.startsWith("rx/functions/Action")
+                || className.startsWith("rx/util/functions/Func") || className.startsWith("rx/util/functions/Action"))) {
+            s = MethodDatabase.SuspendableType.SUSPENDABLE_SUPER;
+        }
         // System.out.println("-- " + className + "." + methodName + ": " + s);
         return s;
     }
@@ -62,9 +69,12 @@ private static boolean isObserverImplementation(MethodDatabase db, String classN
     }
 
     private static boolean isUtilFunction(MethodDatabase db, String className, String superClassName, String[] interfaces, String methodName, String methodDesc) {
-        return (className.startsWith("rx/util/functions/Functions") || className.startsWith("rx/util/functions/Actions"))
+        return (className.startsWith("rx/functions/Functions") || className.startsWith("rx/functions/Actions")
+                || className.startsWith("rx/util/functions/Functions") || className.startsWith("rx/util/functions/Actions"))
                 && methodName.equals(FUNCTION_METHOD)
-                && (SimpleSuspendableClassifier.extendsOrImplements("rx/util/functions/Function", db, className, superClassName, interfaces)
+                && (SimpleSuspendableClassifier.extendsOrImplements("rx/functions/Function", db, className, superClassName, interfaces)
+                || SimpleSuspendableClassifier.extendsOrImplements("rx/functions/Action", db, className, superClassName, interfaces)
+                || SimpleSuspendableClassifier.extendsOrImplements("rx/util/functions/Function", db, className, superClassName, interfaces)
                 || SimpleSuspendableClassifier.extendsOrImplements("rx/util/functions/Action", db, className, superClassName, interfaces));
     }
 
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
index e547d95ce6..d79c590311 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendable-supers
@@ -1,25 +1,3 @@
 rx.Observer.onNext
 rx.Observer.onError
-rx.Observer.onCompleted
-rx.util.functions.Action0.call
-rx.util.functions.Action1.call
-rx.util.functions.Action2.call
-rx.util.functions.Action3.call
-rx.util.functions.Action4.call
-rx.util.functions.Action5.call
-rx.util.functions.Action6.call
-rx.util.functions.Action7.call
-rx.util.functions.Action8.call
-rx.util.functions.Action9.call
-rx.util.functions.ActionN.call
-rx.util.functions.Func0.call
-rx.util.functions.Func1.call
-rx.util.functions.Func2.call
-rx.util.functions.Func3.call
-rx.util.functions.Func4.call
-rx.util.functions.Func5.call
-rx.util.functions.Func6.call
-rx.util.functions.Func7.call
-rx.util.functions.Func8.call
-rx.util.functions.Func9.call
-rx.util.functions.FuncN.call
+rx.Observer.onCompleted
\ No newline at end of file

From 9ae36cf4fb43ab27bd5d77a75f8c4c07c7dbf2b8 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Thu, 27 Mar 2014 04:07:48 +0200
Subject: [PATCH 168/422] Change target back to 1.7

doesn't compile b/c channels implement AutoCloseable, added in JDK 7.
---
 rxjava-contrib/rxjava-quasar/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-quasar/build.gradle b/rxjava-contrib/rxjava-quasar/build.gradle
index bb80b916d4..fdcac9663f 100644
--- a/rxjava-contrib/rxjava-quasar/build.gradle
+++ b/rxjava-contrib/rxjava-quasar/build.gradle
@@ -1,7 +1,7 @@
 apply plugin: 'osgi'
 
 sourceCompatibility = JavaVersion.VERSION_1_6
-targetCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_7
 
 configurations {
     quasar

From ab7f40847159baf742ea4180757a3af45350bde0 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 26 Mar 2014 22:39:12 -0700
Subject: [PATCH 169/422] JMH Benchmarks Gradle Config

- this allows running benchmarks
- config is hardcoded right now
- wasn't able to get uberjar/shadowjar functionality working (https://github.com/Netflix/RxJava/pull/963#issuecomment-38770680)
---
 build.gradle | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 3cafa5b42c..e8192208fd 100644
--- a/build.gradle
+++ b/build.gradle
@@ -12,7 +12,7 @@ buildscript {
         mavenCentral()
         jcenter()
     }
-
+	
     apply from: file('gradle/buildscript.gradle'), to: buildscript 
 }
 
@@ -81,6 +81,28 @@ subprojects {
 	task benchmarks(type: JavaExec) {
 		main = 'org.openjdk.jmh.Main'
 		classpath = sourceSets.perf.runtimeClasspath + sourceSets.main.output
+		maxHeapSize = "512m"
+//		args '-h' // help output
+		args '-f' // fork
+		args '1' 
+		args '-tu' // time unit
+		args 'ns'
+		args '-bm' // benchmark mode
+		args 'avgt'
+		args '-wi' // warmup iterations
+		args '5' 
+		args '-i' // test iterations
+		args '5' 
+		args '-r' // time per execution in seconds
+		args '1'
+//		args '-prof' // profilers
+//		args 'HS_GC' // HotSpot (tm) memory manager (GC) profiling via implementation-specific MBeans
+//		args 'HS_RT' // HotSpot (tm) runtime profiling via implementation-specific MBeans
+//		args 'HS_THR' // HotSpot (tm) threading subsystem via implementation-specific MBeans
+//		args 'HS_COMP' // HotSpot (tm) JIT compiler profiling via implementation-specific MBeans
+//		args 'HS_CL' // HotSpot (tm) classloader profiling via implementation-specific MBeans
+//		args 'STACK' // Simple and naive Java stack profiler
+//		args '.*OperatorSerializePerf.*' // for running only a specific test
 	}
 	
 }

From 5dc029274e41fdf5f761b0207e1dc96a1af2cb96 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 26 Mar 2014 22:39:41 -0700
Subject: [PATCH 170/422] Perf Tests with JMH

---
 .../src/perf/java/rx/jmh/Baseline.java        | 35 ++++++++
 .../java/rx/operators/OperatorMapPerf.java    | 21 +----
 .../rx/operators/OperatorSerializePerf.java   | 86 +++++++++++++++++++
 3 files changed, 124 insertions(+), 18 deletions(-)
 create mode 100644 rxjava-core/src/perf/java/rx/jmh/Baseline.java
 create mode 100644 rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java

diff --git a/rxjava-core/src/perf/java/rx/jmh/Baseline.java b/rxjava-core/src/perf/java/rx/jmh/Baseline.java
new file mode 100644
index 0000000000..549118752f
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/jmh/Baseline.java
@@ -0,0 +1,35 @@
+package rx.jmh;
+
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.logic.BlackHole;
+
+import rx.functions.Func1;
+
+public class Baseline {
+
+    @GenerateMicroBenchmark
+    public void forLoopInvokingFunction(BlackHole bh, Input input) {
+        for (int value = 0; value < input.size; value++) {
+            bh.consume(IDENTITY_FUNCTION.call(value));
+        }
+    }
+
+    private static final Func1<Integer, Integer> IDENTITY_FUNCTION = new Func1<Integer, Integer>() {
+        @Override
+        public Integer call(Integer value) {
+            return value;
+        }
+    };
+
+    @State(Scope.Thread)
+    public static class Input {
+
+        @Param({ "1024", "1048576" })
+        public int size;
+
+    }
+
+}
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
index 7ae07c68b1..70074b4b08 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
@@ -1,7 +1,5 @@
 package rx.operators;
 
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.concurrent.CountDownLatch;
 
 import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
@@ -21,14 +19,7 @@
 public class OperatorMapPerf {
 
     @GenerateMicroBenchmark
-    public void measureBaseline(BlackHole bh, Input input) {
-        for (Integer value : input.values) {
-            bh.consume(IDENTITY_FUNCTION.call(value));
-        }
-    }
-
-    @GenerateMicroBenchmark
-    public void measureMap(Input input) throws InterruptedException {
+    public void mapIdentityFunction(Input input) throws InterruptedException {
         input.observable.lift(MAP_OPERATOR).subscribe(input.observer);
 
         input.awaitCompletion();
@@ -46,10 +37,9 @@ public Integer call(Integer value) {
     @State(Scope.Thread)
     public static class Input {
 
-        @Param({"1", "1024", "1048576"})
+        @Param({ "1", "1024", "1048576" })
         public int size;
 
-        public Collection<Integer> values;
         public Observable<Integer> observable;
         public Observer<Integer> observer;
 
@@ -57,15 +47,10 @@ public static class Input {
 
         @Setup
         public void setup() {
-            values = new ArrayList<Integer>();
-            for(int i = 0; i < size; i ++) {
-                values.add(i);
-            }
-
             observable = Observable.create(new OnSubscribe<Integer>() {
                 @Override
                 public void call(Subscriber<? super Integer> o) {
-                    for (Integer value : values) {
+                    for (int value = 0; value < size; value++) {
                         if (o.isUnsubscribed())
                             return;
                         o.onNext(value);
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java
new file mode 100644
index 0000000000..a130c0711c
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java
@@ -0,0 +1,86 @@
+package rx.operators;
+
+import java.util.concurrent.CountDownLatch;
+
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.logic.BlackHole;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.Subscriber;
+import rx.observers.TestSubscriber;
+
+public class OperatorSerializePerf {
+
+    @GenerateMicroBenchmark
+    public void noSerializationSingleThreaded(Input input) {
+        input.observable.subscribe(input.subscriber);
+    }
+
+    @GenerateMicroBenchmark
+    public void serializedSingleStream(Input input) {
+        input.observable.serialize().subscribe(input.subscriber);
+    }
+
+    @GenerateMicroBenchmark
+    public void synchronizedSingleStream(Input input) {
+        input.observable.synchronize().subscribe(input.subscriber);
+    }
+
+    @State(Scope.Thread)
+    public static class Input {
+
+        @Param({ "1024", "1048576" })
+        public int size;
+
+        public Observable<Integer> observable;
+        public TestSubscriber<Integer> subscriber;
+
+        private CountDownLatch latch;
+
+        @Setup
+        public void setup() {
+            observable = Observable.create(new OnSubscribe<Integer>() {
+                @Override
+                public void call(Subscriber<? super Integer> o) {
+                    for (int value = 0; value < size; value++) {
+                        if (o.isUnsubscribed())
+                            return;
+                        o.onNext(value);
+                    }
+                    o.onCompleted();
+                }
+            });
+
+            final BlackHole bh = new BlackHole();
+            latch = new CountDownLatch(1);
+
+            subscriber = new TestSubscriber<Integer>(new Observer<Integer>() {
+                @Override
+                public void onCompleted() {
+                    latch.countDown();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    throw new RuntimeException(e);
+                }
+
+                @Override
+                public void onNext(Integer value) {
+                    bh.consume(value);
+                }
+            });
+
+        }
+
+        public void awaitCompletion() throws InterruptedException {
+            latch.await();
+        }
+    }
+}

From ed392d7a0d77a22d4ad3b50bcc8e7b8a462eced8 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 27 Mar 2014 11:04:14 -0700
Subject: [PATCH 171/422] New Implementation of SerializedObserver

#### JMH Benchmarks

0.17.3

Benchmark                                                          (size)   Mode   Samples         Mean   Mean error    Units
r.operators.OperatorSerializePerf.noSerializationSingleThreaded      1024   avgt         5       45.504        1.710    ns/op
r.operators.OperatorSerializePerf.noSerializationSingleThreaded   1048576   avgt         5       58.600        5.647    ns/op
r.operators.OperatorSerializePerf.serializedSingleStream             1024   avgt         5       68.610        4.596    ns/op
r.operators.OperatorSerializePerf.serializedSingleStream          1048576   avgt         5       71.313        2.318    ns/op
r.operators.OperatorSerializePerf.synchronizedSingleStream           1024   avgt         5       73.322        3.666    ns/op
r.operators.OperatorSerializePerf.synchronizedSingleStream        1048576   avgt         5       76.518        1.355    ns/op

0.17.2

Benchmark                                                          (size)   Mode   Samples         Mean   Mean error    Units
r.operators.OperatorSerializePerf.noSerializationSingleThreaded      1024   avgt         5       45.790        1.184    ns/op
r.operators.OperatorSerializePerf.noSerializationSingleThreaded   1048576   avgt         5       58.518        3.788    ns/op
r.operators.OperatorSerializePerf.serializedSingleStream             1024   avgt         5       72.665        7.851    ns/op
r.operators.OperatorSerializePerf.serializedSingleStream          1048576   avgt         5       74.788        2.946    ns/op
r.operators.OperatorSerializePerf.synchronizedSingleStream           1024   avgt         5       73.661        3.499    ns/op
r.operators.OperatorSerializePerf.synchronizedSingleStream        1048576   avgt         5       78.386        5.036    ns/op

#### Manual Benchmarks

/**
 * 0.17.3:
 *
 * Run: 10 - 9,746,505 ops/sec
 * Run: 11 - 9,956,019 ops/sec
 * Run: 12 - 10,053,770 ops/sec
 * Run: 13 - 10,076,958 ops/sec
 * Run: 14 - 9,983,319 ops/sec
 *
 * 0.17.2:
 *
 * Run: 10 - 9,851,999 ops/sec
 * Run: 11 - 9,726,975 ops/sec
 * Run: 12 - 9,719,762 ops/sec
 * Run: 13 - 9,668,141 ops/sec
 * Run: 14 - 9,799,700 ops/sec
 *
 * @param input
 */
public void serializedSingleStream(Input input) {
    for (int i = 0; i < reps; i++) {
        input.observable.serialize().subscribe(input.subscriber);
    }
}
---
 .../java/rx/observers/SerializedObserver.java | 194 ++++++++++--------
 .../OperatorSerializePerformance.java         | 114 +++++++++-
 2 files changed, 220 insertions(+), 88 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 6be8d7a23e..0d397fe73f 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -1,9 +1,6 @@
 package rx.observers;
 
-import java.util.ArrayList;
-
 import rx.Observer;
-import rx.operators.NotificationLite;
 
 /**
  * Enforce single-threaded, serialized, ordered execution of onNext, onCompleted, onError.
@@ -22,8 +19,40 @@ public class SerializedObserver<T> implements Observer<T> {
 
     private boolean emitting = false;
     private boolean terminated = false;
-    private ArrayList<Object> queue = new ArrayList<Object>();
-    private NotificationLite<T> on = NotificationLite.instance();
+    private FastList queue;
+
+    private static final int MAX_DRAIN_ITERATION = 1;
+    private static final Object NULL_SENTINEL = new Object();
+    private static final Object COMPLETE_SENTINEL = new Object();
+
+    static final class FastList {
+        Object[] array;
+        int size;
+
+        public void add(Object o) {
+            int s = size;
+            Object[] a = array;
+            if (a == null) {
+                a = new Object[16];
+                array = a;
+            } else if (s == a.length) {
+                Object[] array2 = new Object[s + (s >> 2)];
+                System.arraycopy(a, 0, array2, 0, s);
+                a = array2;
+                array = a;
+            }
+            a[s] = o;
+            size = s + 1;
+        }
+    }
+
+    private static final class ErrorSentinel {
+        final Throwable e;
+
+        ErrorSentinel(Throwable e) {
+            this.e = e;
+        }
+    }
 
     public SerializedObserver(Observer<? super T> s) {
         this.actual = s;
@@ -31,128 +60,119 @@ public SerializedObserver(Observer<? super T> s) {
 
     @Override
     public void onCompleted() {
-        boolean canEmit = false;
-        ArrayList<Object> list = null;
+        FastList list;
         synchronized (this) {
             if (terminated) {
                 return;
             }
             terminated = true;
-            if (!emitting) {
-                // emit immediately
-                emitting = true;
-                canEmit = true;
-                if (queue.size() > 0) {
-                    list = queue; // copy reference
-                    queue = new ArrayList<Object>(); // new version;
-                }
-            } else {
-                // someone else is already emitting so just queue it
-                queue.add(on.completed());
-            }
-        }
-
-        if (canEmit) {
-            // we won the right to emit
-            try {
-                drainQueue(list);
-                actual.onCompleted();
-            } finally {
-                synchronized (this) {
-                    emitting = false;
+            if (emitting) {
+                if (queue == null) {
+                    queue = new FastList();
                 }
+                queue.add(COMPLETE_SENTINEL);
+                return;
             }
+            emitting = true;
+            list = queue;
+            queue = null;
         }
+        drainQueue(list);
+        actual.onCompleted();
     }
 
     @Override
     public void onError(final Throwable e) {
-        boolean canEmit = false;
-        ArrayList<Object> list = null;
+        FastList list;
         synchronized (this) {
             if (terminated) {
                 return;
             }
             terminated = true;
-            if (!emitting) {
-                // emit immediately
-                emitting = true;
-                canEmit = true;
-                if (queue.size() > 0) {
-                    list = queue; // copy reference
-                    queue = new ArrayList<Object>(); // new version;
-                }
-            } else {
-                // someone else is already emitting so just queue it ... after eliminating the queue to shortcut
-                queue.clear();
-                queue.add(on.error(e));
-            }
-        }
-        if (canEmit) {
-            // we won the right to emit
-            try {
-                drainQueue(list);
-                actual.onError(e);
-            } finally {
-                synchronized (this) {
-                    emitting = false;
+            if (emitting) {
+                if (queue == null) {
+                    queue = new FastList();
                 }
+                queue.add(new ErrorSentinel(e));
+                return;
             }
+            emitting = true;
+            list = queue;
+            queue = null;
         }
+        drainQueue(list);
+        actual.onError(e);
     }
 
     @Override
     public void onNext(T t) {
-        boolean canEmit = false;
-        ArrayList<Object> list = null;
+        FastList list;
+
         synchronized (this) {
             if (terminated) {
                 return;
             }
-            if (!emitting) {
-                // emit immediately
-                emitting = true;
-                canEmit = true;
-                if (queue.size() > 0) {
-                    list = queue; // copy reference
-                    queue = new ArrayList<Object>(); // new version;
+            if (emitting) {
+                if (queue == null) {
+                    queue = new FastList();
                 }
-            } else {
-                // someone else is already emitting so just queue it
-                queue.add(on.next(t));
+                queue.add(t != null ? t : NULL_SENTINEL);
+                return;
             }
+            emitting = true;
+            list = queue;
+            queue = null;
         }
-        if (canEmit) {
-            // we won the right to emit
-            try {
+
+        try {
+            int iter = MAX_DRAIN_ITERATION;
+            do {
                 drainQueue(list);
-                actual.onNext(t);
-            } finally {
-                synchronized (this) {
-                    if (terminated) {
-                        list = queue; // copy reference
-                        queue = new ArrayList<Object>(); // new version;
-                    } else {
-                        // release this thread
-                        emitting = false;
-                        canEmit = false;
+                if (iter == MAX_DRAIN_ITERATION) {
+                    actual.onNext(t);
+                }
+                --iter;
+                if (iter > 0) {
+                    synchronized (this) {
+                        list = queue;
+                        queue = null;
+                    }
+                    if (list == null) {
+                        break;
                     }
                 }
+            } while (iter > 0);
+        } finally {
+            synchronized (this) {
+                if (terminated) {
+                    list = queue;
+                    queue = null;
+                } else {
+                    emitting = false;
+                    list = null;
+                }
             }
-        }
-
-        // if terminated this will still be true so let's drain the rest of the queue
-        if (canEmit) {
             drainQueue(list);
         }
     }
 
-    public void drainQueue(ArrayList<Object> list) {
-        if (list == null || list.size() == 0) {
+    void drainQueue(FastList list) {
+        if (list == null || list.size == 0) {
             return;
         }
-        for (Object v : list) {
-            on.accept(actual, v);
+        for (Object v : list.array) {
+            if (v == null) {
+                break;
+            }
+            if (v == NULL_SENTINEL) {
+                actual.onNext(null);
+            } else if (v == COMPLETE_SENTINEL) {
+                actual.onCompleted();
+            } else if (v.getClass() == ErrorSentinel.class) {
+                actual.onError(((ErrorSentinel) v).e);
+            } else {
+                actual.onNext((T) v);
+            }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
index 366d23d092..7eb94edd3b 100644
--- a/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
@@ -3,14 +3,18 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
+import org.openjdk.jmh.logic.BlackHole;
+
 import rx.Observable;
 import rx.Observable.OnSubscribe;
+import rx.Observer;
 import rx.Subscriber;
 import rx.archive.perf.AbstractPerformanceTester;
 import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
+import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
 
 public class OperatorSerializePerformance extends AbstractPerformanceTester {
@@ -26,12 +30,17 @@ public class OperatorSerializePerformance extends AbstractPerformanceTester {
     public static void main(String args[]) {
 
         final OperatorSerializePerformance spt = new OperatorSerializePerformance();
+        final Input input = new Input();
+        input.setup();
         try {
             spt.runTest(new Action0() {
 
                 @Override
                 public void call() {
-                    spt.timeTwoStreams();
+                    //                    spt.noSerializationSingleThreaded(input);
+                    spt.serializedSingleStream(input);
+                    //                    spt.synchronizedSingleStream(input);
+                    //                    spt.timeTwoStreams();
                     //                    spt.timeSingleStream();
                     //                    spt.timeTwoStreamsIntervals();
                 }
@@ -42,6 +51,61 @@ public void call() {
 
     }
 
+    /**
+     * Run: 10 - 12,186,982 ops/sec
+     * Run: 11 - 10,236,722 ops/sec
+     * Run: 12 - 11,377,690 ops/sec
+     * Run: 13 - 10,876,358 ops/sec
+     * Run: 14 - 11,383,619 ops/sec
+     * 
+     * @param input
+     */
+    public void noSerializationSingleThreaded(Input input) {
+        for (int i = 0; i < reps; i++) {
+            input.observable.subscribe(input.subscriber);
+        }
+    }
+
+    /**
+     * 0.17.3:
+     * 
+     * Run: 10 - 9,746,505 ops/sec
+     * Run: 11 - 9,956,019 ops/sec
+     * Run: 12 - 10,053,770 ops/sec
+     * Run: 13 - 10,076,958 ops/sec
+     * Run: 14 - 9,983,319 ops/sec
+     * 
+     * 0.17.2:
+     * 
+     * Run: 10 - 9,851,999 ops/sec
+     * Run: 11 - 9,726,975 ops/sec
+     * Run: 12 - 9,719,762 ops/sec
+     * Run: 13 - 9,668,141 ops/sec
+     * Run: 14 - 9,799,700 ops/sec
+     * 
+     * @param input
+     */
+    public void serializedSingleStream(Input input) {
+        for (int i = 0; i < reps; i++) {
+            input.observable.serialize().subscribe(input.subscriber);
+        }
+    }
+
+    /**
+     * Run: 10 - 9,475,925 ops/sec
+     * Run: 11 - 9,501,341 ops/sec
+     * Run: 12 - 9,550,495 ops/sec
+     * Run: 13 - 9,510,303 ops/sec
+     * Run: 14 - 9,690,300 ops/sec
+     * 
+     * @param input
+     */
+    public void synchronizedSingleStream(Input input) {
+        for (int i = 0; i < reps; i++) {
+            input.observable.synchronize().subscribe(input.subscriber);
+        }
+    }
+
     /**
      * 1 streams emitting in a tight loop. Testing for single-threaded overhead.
      * 
@@ -321,4 +385,52 @@ public void call(Integer t1) {
         return o.sum;
     }
 
+    public static class Input {
+
+        public int size = 1048576;
+
+        public Observable<Integer> observable;
+        public TestSubscriber<Integer> subscriber;
+
+        private CountDownLatch latch;
+
+        public void setup() {
+            observable = Observable.create(new OnSubscribe<Integer>() {
+                @Override
+                public void call(Subscriber<? super Integer> o) {
+                    for (int value = 0; value < size; value++) {
+                        if (o.isUnsubscribed())
+                            return;
+                        o.onNext(value);
+                    }
+                    o.onCompleted();
+                }
+            });
+
+            final BlackHole bh = new BlackHole();
+            latch = new CountDownLatch(1);
+
+            subscriber = new TestSubscriber<Integer>(new Observer<Integer>() {
+                @Override
+                public void onCompleted() {
+                    latch.countDown();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    throw new RuntimeException(e);
+                }
+
+                @Override
+                public void onNext(Integer value) {
+                    bh.consume(value);
+                }
+            });
+
+        }
+
+        public void awaitCompletion() throws InterruptedException {
+            latch.await();
+        }
+    }
 }

From 3d54a1792a0f05bfe13f64e0a876ea155f5b3222 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 27 Mar 2014 14:55:30 -0700
Subject: [PATCH 172/422] Support Custom JMH Args

---
 build.gradle | 58 +++++++++++++++++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/build.gradle b/build.gradle
index e8192208fd..ec8a06d44b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -78,31 +78,47 @@ subprojects {
         }
     }
 
+	/**
+	 * By default: Run without arguments this will execute all benchmarks that are found (can take a long time).
+	 *
+	 * Optionally pass arguments for custom execution. Example:
+	 *
+	 *  ../gradlew benchmarks '-Pjmh=-f 1 -tu ns -bm avgt -wi 5 -i 5 -r 1 .*OperatorSerializePerf.*'
+	 *
+	 * To see all options:
+	 *
+	 *  ../gradlew benchmarks '-Pjmh=-h'
+	 */ 
 	task benchmarks(type: JavaExec) {
 		main = 'org.openjdk.jmh.Main'
 		classpath = sourceSets.perf.runtimeClasspath + sourceSets.main.output
 		maxHeapSize = "512m"
-//		args '-h' // help output
-		args '-f' // fork
-		args '1' 
-		args '-tu' // time unit
-		args 'ns'
-		args '-bm' // benchmark mode
-		args 'avgt'
-		args '-wi' // warmup iterations
-		args '5' 
-		args '-i' // test iterations
-		args '5' 
-		args '-r' // time per execution in seconds
-		args '1'
-//		args '-prof' // profilers
-//		args 'HS_GC' // HotSpot (tm) memory manager (GC) profiling via implementation-specific MBeans
-//		args 'HS_RT' // HotSpot (tm) runtime profiling via implementation-specific MBeans
-//		args 'HS_THR' // HotSpot (tm) threading subsystem via implementation-specific MBeans
-//		args 'HS_COMP' // HotSpot (tm) JIT compiler profiling via implementation-specific MBeans
-//		args 'HS_CL' // HotSpot (tm) classloader profiling via implementation-specific MBeans
-//		args 'STACK' // Simple and naive Java stack profiler
-//		args '.*OperatorSerializePerf.*' // for running only a specific test
+		
+		if (project.hasProperty('jmh')) {
+		      args(jmh.split(' '))
+		} else {
+	 		//args '-h' // help output
+	 		args '-f' // fork
+	 		args '1' 
+	 		args '-tu' // time unit
+	 		args 'ns'
+	 		args '-bm' // benchmark mode
+	 		args 'avgt'
+	 		args '-wi' // warmup iterations
+	 		args '5' 
+	 		args '-i' // test iterations
+	 		args '5' 
+	 		args '-r' // time per execution in seconds
+	 		args '5'
+	 		//args '-prof' // profilers
+	 		//args 'HS_GC' // HotSpot (tm) memory manager (GC) profiling via implementation-specific MBeans
+	 		//args 'HS_RT' // HotSpot (tm) runtime profiling via implementation-specific MBeans
+	 		//args 'HS_THR' // HotSpot (tm) threading subsystem via implementation-specific MBeans
+	 		//args 'HS_COMP' // HotSpot (tm) JIT compiler profiling via implementation-specific MBeans
+	 		//args 'HS_CL' // HotSpot (tm) classloader profiling via implementation-specific MBeans
+	 		//args 'STACK' // Simple and naive Java stack profiler
+	 		args '.*OperatorSerializePerf.*' // for running only a specific test
+		}
 	}
 	
 }

From d48a3b29283b7e09cd93c698385f2d4e2a0246b5 Mon Sep 17 00:00:00 2001
From: Rob Spieldenner <rob.spieldenner@gmail.com>
Date: Thu, 27 Mar 2014 17:11:28 -0700
Subject: [PATCH 173/422] Produce a shadow'd jar for the performance benchmarks

---
 build.gradle              | 24 +++++++++++++++++++++---
 gradle/buildscript.gradle |  6 ++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index ec8a06d44b..c4af267173 100644
--- a/build.gradle
+++ b/build.gradle
@@ -13,7 +13,7 @@ buildscript {
         jcenter()
     }
 	
-    apply from: file('gradle/buildscript.gradle'), to: buildscript 
+    apply from: file('gradle/buildscript.gradle'), to: buildscript
 }
 
 allprojects {
@@ -27,6 +27,7 @@ allprojects {
 
 subprojects {
     apply plugin: 'java'
+    apply plugin: 'shadow'
     group = "com.netflix.rxjava"
 
     // make 'examples' use the same classpath
@@ -55,12 +56,19 @@ subprojects {
 		dependsOn(perfClasses)
     }
 
+    task perfJar(type: Jar, dependsOn: perfClasses) {
+        from sourceSets.perf.output + sourceSets.main.output
+    }
+
     dependencies {
         perfCompile 'org.openjdk.jmh:jmh-core:0.5.3'
         perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:0.5.3'
-
         //perfCompile project
     }
+
+    artifacts {
+        perfRuntime perfJar
+    }
     
     eclipse {  
         classpath {
@@ -120,7 +128,17 @@ subprojects {
 	 		args '.*OperatorSerializePerf.*' // for running only a specific test
 		}
 	}
-	
+
+    shadow {
+        classifier = "benchmarks"
+        includeDependenciesFor = ["runtime", "perfRuntime"]
+
+        transformer(com.github.jengelman.gradle.plugins.shadow.transformers.ManifestResourceTransformer) {
+            mainClass = "org.openjdk.jmh.Main"
+        }
+    }
+
+    shadowJar.dependsOn perfJar
 }
 
 project(':rxjava-core') {
diff --git a/gradle/buildscript.gradle b/gradle/buildscript.gradle
index 0b6da7ce84..2d8643103e 100644
--- a/gradle/buildscript.gradle
+++ b/gradle/buildscript.gradle
@@ -2,10 +2,16 @@
 repositories {
     // Repo in addition to maven central
     repositories { maven { url 'http://dl.bintray.com/content/netflixoss/external-gradle-plugins/' } } // For gradle-release
+    maven {
+        //FIXME: waiting for https://github.com/johnrengelman/shadow/pull/38 to merge
+        name 'Shadow'
+        url 'http://dl.bintray.com/content/gvsmirnov/gradle-plugins'
+    }
 }
 dependencies {
     classpath 'nl.javadude.gradle.plugins:license-gradle-plugin:0.6.1'
     classpath 'com.mapvine:gradle-cobertura-plugin:0.1'
     classpath 'gradle-release:gradle-release:1.1.5'
     classpath 'org.ajoberstar:gradle-git:0.5.0'
+    classpath 'com.github.jengelman.gradle.plugins:shadow:0.8.1'
 }

From 525af2289f6a8a32fbb3ed0bff3f9382d5aecb71 Mon Sep 17 00:00:00 2001
From: Rob Spieldenner <rob.spieldenner@gmail.com>
Date: Thu, 27 Mar 2014 17:14:18 -0700
Subject: [PATCH 174/422] tabs to spaces

---
 build.gradle | 92 ++++++++++++++++++++++++++--------------------------
 1 file changed, 46 insertions(+), 46 deletions(-)

diff --git a/build.gradle b/build.gradle
index c4af267173..750537e93b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -12,7 +12,7 @@ buildscript {
         mavenCentral()
         jcenter()
     }
-	
+
     apply from: file('gradle/buildscript.gradle'), to: buildscript
 }
 
@@ -46,14 +46,14 @@ subprojects {
     sourceSets {
         examples
         perf {
-		    compileClasspath += sourceSets.main.output
-		}
+            compileClasspath += sourceSets.main.output
+        }
     }
 
     tasks.build { 
         //include 'examples' in build task
         dependsOn(examplesClasses)
-		dependsOn(perfClasses)
+        dependsOn(perfClasses)
     }
 
     task perfJar(type: Jar, dependsOn: perfClasses) {
@@ -86,48 +86,48 @@ subprojects {
         }
     }
 
-	/**
-	 * By default: Run without arguments this will execute all benchmarks that are found (can take a long time).
-	 *
-	 * Optionally pass arguments for custom execution. Example:
-	 *
-	 *  ../gradlew benchmarks '-Pjmh=-f 1 -tu ns -bm avgt -wi 5 -i 5 -r 1 .*OperatorSerializePerf.*'
-	 *
-	 * To see all options:
-	 *
-	 *  ../gradlew benchmarks '-Pjmh=-h'
-	 */ 
-	task benchmarks(type: JavaExec) {
-		main = 'org.openjdk.jmh.Main'
-		classpath = sourceSets.perf.runtimeClasspath + sourceSets.main.output
-		maxHeapSize = "512m"
-		
-		if (project.hasProperty('jmh')) {
-		      args(jmh.split(' '))
-		} else {
-	 		//args '-h' // help output
-	 		args '-f' // fork
-	 		args '1' 
-	 		args '-tu' // time unit
-	 		args 'ns'
-	 		args '-bm' // benchmark mode
-	 		args 'avgt'
-	 		args '-wi' // warmup iterations
-	 		args '5' 
-	 		args '-i' // test iterations
-	 		args '5' 
-	 		args '-r' // time per execution in seconds
-	 		args '5'
-	 		//args '-prof' // profilers
-	 		//args 'HS_GC' // HotSpot (tm) memory manager (GC) profiling via implementation-specific MBeans
-	 		//args 'HS_RT' // HotSpot (tm) runtime profiling via implementation-specific MBeans
-	 		//args 'HS_THR' // HotSpot (tm) threading subsystem via implementation-specific MBeans
-	 		//args 'HS_COMP' // HotSpot (tm) JIT compiler profiling via implementation-specific MBeans
-	 		//args 'HS_CL' // HotSpot (tm) classloader profiling via implementation-specific MBeans
-	 		//args 'STACK' // Simple and naive Java stack profiler
-	 		args '.*OperatorSerializePerf.*' // for running only a specific test
-		}
-	}
+    /**
+     * By default: Run without arguments this will execute all benchmarks that are found (can take a long time).
+     *
+     * Optionally pass arguments for custom execution. Example:
+     *
+     *  ../gradlew benchmarks '-Pjmh=-f 1 -tu ns -bm avgt -wi 5 -i 5 -r 1 .*OperatorSerializePerf.*'
+     *
+     * To see all options:
+     *
+     *  ../gradlew benchmarks '-Pjmh=-h'
+     */
+    task benchmarks(type: JavaExec) {
+        main = 'org.openjdk.jmh.Main'
+        classpath = sourceSets.perf.runtimeClasspath + sourceSets.main.output
+        maxHeapSize = "512m"
+
+        if (project.hasProperty('jmh')) {
+            args(jmh.split(' '))
+        } else {
+            //args '-h' // help output
+            args '-f' // fork
+            args '1'
+            args '-tu' // time unit
+            args 'ns'
+            args '-bm' // benchmark mode
+            args 'avgt'
+            args '-wi' // warmup iterations
+            args '5'
+            args '-i' // test iterations
+            args '5'
+            args '-r' // time per execution in seconds
+            args '5'
+            //args '-prof' // profilers
+            //args 'HS_GC' // HotSpot (tm) memory manager (GC) profiling via implementation-specific MBeans
+            //args 'HS_RT' // HotSpot (tm) runtime profiling via implementation-specific MBeans
+            //args 'HS_THR' // HotSpot (tm) threading subsystem via implementation-specific MBeans
+            //args 'HS_COMP' // HotSpot (tm) JIT compiler profiling via implementation-specific MBeans
+            //args 'HS_CL' // HotSpot (tm) classloader profiling via implementation-specific MBeans
+            //args 'STACK' // Simple and naive Java stack profiler
+            args '.*OperatorSerializePerf.*' // for running only a specific test
+        }
+    }
 
     shadow {
         classifier = "benchmarks"

From 5b317ad827f624bed6cbf5f2e04df050ebbe01d0 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 28 Mar 2014 14:17:29 -0700
Subject: [PATCH 175/422] Update SerializedObserver to Not Allow Notification
 Delay

Unit test showing delays. Fails when MAX_DRAIN_ITERATION set to 1, passes as currently configured.
Added a thread starvation unit test and marked as ignored for now. Doesn't pass even with MAX_DRAIN_ITERATION set to 1. Probably needs backpressure solution.
---
 .../java/rx/observers/SerializedObserver.java |   2 +-
 .../rx/observers/SerializedObserverTest.java  | 149 +++++++++++++++++-
 2 files changed, 143 insertions(+), 8 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 0d397fe73f..f4a21e06f9 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -21,7 +21,7 @@ public class SerializedObserver<T> implements Observer<T> {
     private boolean terminated = false;
     private FastList queue;
 
-    private static final int MAX_DRAIN_ITERATION = 1;
+    private static final int MAX_DRAIN_ITERATION = Integer.MAX_VALUE;
     private static final Object NULL_SENTINEL = new Object();
     private static final Object COMPLETE_SENTINEL = new Object();
 
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index e6043edd39..7a82e59c06 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -15,9 +15,15 @@
  */
 package rx.observers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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.mockito.Matchers.any;
+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.ExecutorService;
@@ -28,14 +34,17 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.schedulers.Schedulers;
 
 public class SerializedObserverTest {
 
@@ -265,6 +274,111 @@ public void runConcurrencyTest() {
         }
     }
 
+    @Test
+    public void testNotificationDelay() {
+        ExecutorService tp = Executors.newFixedThreadPool(2);
+
+        TestSubscriber<String> to = new TestSubscriber<String>(new Observer<String>() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(String t) {
+                // force it to take time when delivering
+                // so the second thread will asynchronously enqueue
+                try {
+                    Thread.sleep(50);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        });
+        Observer<String> o = serializedObserver(to);
+
+        Future<?> f1 = tp.submit(new OnNextThread(o, 1));
+        Future<?> f2 = tp.submit(new OnNextThread(o, 1));
+
+        waitOnThreads(f1, f2);
+        // not completed yet
+
+        assertEquals(2, to.getOnNextEvents().size());
+        System.out.println(to.getOnNextEvents());
+        o.onCompleted();
+        System.out.println(to.getOnNextEvents());
+    }
+
+    /**
+     * Demonstrates thread starvation problem.
+     * 
+     * No solution on this for now. Trade-off in this direction as per https://github.com/Netflix/RxJava/issues/998#issuecomment-38959474
+     * Probably need backpressure for this to work
+     * 
+     * When using SynchronizedObserver we get this output:
+     * 
+     * p1: 18 p2: 68 => should be close to each other unless we have thread starvation
+     * 
+     * When using SerializedObserver we get:
+     * 
+     * p1: 1 p2: 2445261 => should be close to each other unless we have thread starvation
+     * 
+     * This demonstrates how SynchronizedObserver balances back and forth better, and blocks emission.
+     * The real issue in this example is the async buffer-bloat, so we need backpressure.
+     * 
+     * 
+     * @throws InterruptedException
+     */
+    @Ignore
+    @Test
+    public void testThreadStarvation() throws InterruptedException {
+
+        TestSubscriber<String> to = new TestSubscriber<String>(new Observer<String>() {
+
+            @Override
+            public void onCompleted() {
+
+            }
+
+            @Override
+            public void onError(Throwable e) {
+
+            }
+
+            @Override
+            public void onNext(String t) {
+                // force it to take time when delivering
+                try {
+                    Thread.sleep(1);
+                } catch (InterruptedException e) {
+                }
+            }
+
+        });
+        Observer<String> o = serializedObserver(to);
+
+        AtomicInteger p1 = new AtomicInteger();
+        AtomicInteger p2 = new AtomicInteger();
+
+        Subscription s1 = infinite(p1).subscribe(o);
+        Subscription s2 = infinite(p2).subscribe(o);
+
+        Thread.sleep(100);
+
+        System.out.println("p1: " + p1.get() + " p2: " + p2.get() + " => should be close to each other unless we have thread starvation");
+        assertEquals(p1.get(), p2.get(), 10000); // fairly distributed within 10000 of each other
+
+        s1.unsubscribe();
+        s2.unsubscribe();
+    }
+
     private static void waitOnThreads(Future<?>... futures) {
         for (Future<?> f : futures) {
             try {
@@ -276,23 +390,44 @@ private static void waitOnThreads(Future<?>... futures) {
         }
     }
 
+    private static Observable<String> infinite(final AtomicInteger produced) {
+        return Observable.create(new OnSubscribe<String>() {
+
+            @Override
+            public void call(Subscriber<? super String> s) {
+                while (!s.isUnsubscribed()) {
+                    s.onNext("onNext");
+                    produced.incrementAndGet();
+                }
+            }
+
+        }).subscribeOn(Schedulers.newThread());
+    }
+
     /**
      * A thread that will pass data to onNext
      */
     public static class OnNextThread implements Runnable {
 
-        private final Observer<String> Observer;
+        private final Observer<String> observer;
         private final int numStringsToSend;
+        final AtomicInteger produced;
 
-        OnNextThread(Observer<String> Observer, int numStringsToSend) {
-            this.Observer = Observer;
+        OnNextThread(Observer<String> observer, int numStringsToSend, AtomicInteger produced) {
+            this.observer = observer;
             this.numStringsToSend = numStringsToSend;
+            this.produced = produced;
+        }
+
+        OnNextThread(Observer<String> observer, int numStringsToSend) {
+            this(observer, numStringsToSend, new AtomicInteger());
         }
 
         @Override
         public void run() {
             for (int i = 0; i < numStringsToSend; i++) {
-                Observer.onNext(Thread.currentThread().getId() + "-" + i);
+                observer.onNext(Thread.currentThread().getId() + "-" + i);
+                produced.incrementAndGet();
             }
         }
     }

From 59ded837de3cd8347ef213cf47791f6f45cf1ab3 Mon Sep 17 00:00:00 2001
From: Rick Warren <rwarren@cs.stanford.edu>
Date: Sun, 30 Mar 2014 18:06:36 -0700
Subject: [PATCH 176/422] Func0 can transparently implement
 java.util.concurrent.Callable.

This change doesn't change the API at all for users of Func0, but it makes all Func0 objects immediately reusable with any JDK API that accepts Callables. For example, a Func0 can now be submitted directly to an ExecutorService for asynchronous execution. It also allows the elimination of a small amount of redundant code within RxJava itself.
---
 .../src/main/java/rx/util/async/Async.java    | 12 ++++-
 .../operators/OperationFromFunctionals.java   | 45 ++++++-------------
 .../OperationFromFunctionalsTest.java         | 16 ++++++-
 .../src/main/java/rx/functions/Func0.java     |  7 ++-
 4 files changed, 43 insertions(+), 37 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 4559032877..d4ca377a04 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
@@ -1596,9 +1596,13 @@ public static <R> Observable<R> fromAction(Action0 action, R result) {
      * @see #start(rx.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromfunc0">RxJava Wiki: fromFunc0()</a>
+     *
+     * @deprecated  Unnecessary now that Func0 extends Callable. Just call
+     *              {@link #fromCallable(Callable)} instead.
      */
+    @Deprecated
     public static <R> Observable<R> fromFunc0(Func0<? extends R> function) {
-        return fromFunc0(function, Schedulers.computation());
+        return fromCallable(function);
     }
 
     /**
@@ -1674,9 +1678,13 @@ public static <R> Observable<R> fromAction(Action0 action, R result, Scheduler s
      * @see #start(rx.functions.Func0) 
      * @see #fromCallable(java.util.concurrent.Callable) 
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromfunc0">RxJava Wiki: fromFunc0()</a>
+     *
+     * @deprecated  Unnecessary now that Func0 extends Callable. Just call
+     *              {@link #fromCallable(Callable, Scheduler)} instead.
      */
+    @Deprecated
     public static <R> Observable<R> fromFunc0(Func0<? extends R> function, Scheduler scheduler) {
-        return Observable.create(OperationFromFunctionals.fromFunc0(function)).subscribeOn(scheduler);
+        return fromCallable(function, scheduler);
     }
 
     /**
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 bf890c3903..57ef639a26 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
@@ -38,10 +38,16 @@ public final class OperationFromFunctionals {
     public static <R> OnSubscribeFunc<R> fromAction(Action0 action, R result) {
         return new InvokeAsync<R>(Actions.toFunc(action, result));
     }
-    
-    /** Subscriber function that invokes a function and returns its value. */
+
+    /**
+     * Subscriber function that invokes a function and returns its value.
+     *
+     * @deprecated  Unnecessary now that Func0 extends Callable. Just call
+     *              {@link #fromCallable(Callable)} instead.
+     */
+    @Deprecated
     public static <R> OnSubscribeFunc<R> fromFunc0(Func0<? extends R> function) {
-        return new InvokeAsync<R>(function);
+        return fromCallable(function);
     }
     
     /** 
@@ -49,11 +55,11 @@ public static <R> OnSubscribeFunc<R> fromFunc0(Func0<? extends R> function) {
      * propagates its checked exception.
      */
     public static <R> OnSubscribeFunc<R> fromCallable(Callable<? extends R> callable) {
-        return new InvokeAsyncCallable<R>(callable);
+        return new InvokeAsync<R>(callable);
     }
     /** Subscriber function that invokes a runnable and returns the given result. */
     public static <R> OnSubscribeFunc<R> fromRunnable(final Runnable run, final R result) {
-        return new InvokeAsync(new Func0<R>() {
+        return new InvokeAsync<R>(new Func0<R>() {
             @Override
             public R call() {
                 run.run();
@@ -62,38 +68,13 @@ public R call() {
         });
     }
     
-    /**
-     * Invokes a function when an observer subscribes.
-     * @param <R> the return type
-     */
-    static final class InvokeAsync<R> implements OnSubscribeFunc<R> {
-        final Func0<? extends R> function;
-        public InvokeAsync(Func0<? extends R> function) {
-            if (function == null) {
-                throw new NullPointerException("function");
-            }
-            this.function = function;
-        }
-        @Override
-        public Subscription onSubscribe(Observer<? super R> 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 <R> the return type
      */
-    static final class InvokeAsyncCallable<R> implements OnSubscribeFunc<R> {
+    static final class InvokeAsync<R> implements OnSubscribeFunc<R> {
         final Callable<? extends R> callable;
-        public InvokeAsyncCallable(Callable<? extends R> callable) {
+        public InvokeAsync(Callable<? extends R> callable) {
             if (callable == null) {
                 throw new NullPointerException("function");
             }
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 7580670d8a..f89d58ccc5 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
@@ -110,6 +110,13 @@ public void call() {
         
         testRunShouldThrow(source, RuntimeException.class);
     }
+
+    /**
+     * @deprecated  {@link Func0} now extends {@link Callable}, so
+     *              {@link Async#fromFunc0(Func0)} is unnecessary. Once it's
+     *              removed, this test can be removed as well.
+     */
+    @Deprecated
     @Test
     public void testFromFunc0() {
         Func0<Integer> func = new Func0<Integer>() {
@@ -139,7 +146,14 @@ public Integer call() {
             verify(observer, never()).onError(any(Throwable.class));
         }
     }
-    
+
+    /**
+     * @deprecated  {@link Func0} now extends {@link Callable}, so
+     *              {@link Async#fromFunc0(Func0, rx.Scheduler)} is
+     *              unnecessary. Once it's removed, this test can be removed
+     *              as well.
+     */
+    @Deprecated
     @Test
     public void testFromFunc0Throws() {
         Func0<Integer> func = new Func0<Integer>() {
diff --git a/rxjava-core/src/main/java/rx/functions/Func0.java b/rxjava-core/src/main/java/rx/functions/Func0.java
index ee8178bb33..d86215d101 100644
--- a/rxjava-core/src/main/java/rx/functions/Func0.java
+++ b/rxjava-core/src/main/java/rx/functions/Func0.java
@@ -15,6 +15,9 @@
  */
 package rx.functions;
 
-public interface Func0<R> extends Function {
+import java.util.concurrent.Callable;
+
+public interface Func0<R> extends Function, Callable<R> {
+    @Override
     public R call();
-}
\ No newline at end of file
+}

From 31cfd197ac0b83670b298cadb2331d4bc4046119 Mon Sep 17 00:00:00 2001
From: suncelesta <suncelesta@gmail.com>
Date: Mon, 31 Mar 2014 21:59:42 +0400
Subject: [PATCH 177/422] add toMap from Java Observable

---
 .../main/scala/rx/lang/scala/Observable.scala | 61 ++++++++++++++++++-
 1 file changed, 60 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 d185c1af8b..f0f312a2ac 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
@@ -2353,7 +2353,7 @@ trait Observable[+T]
    * 
    * @param index
    *            the zero-based index of the item to retrieve
-   * @param defaultValue
+   * @param default
    *            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
@@ -2364,6 +2364,65 @@ trait Observable[+T]
     val thisJava = asJavaObservable.asInstanceOf[rx.Observable[U]]
     toScalaObservable[U](thisJava.elementAtOrDefault(index, default))
   }
+
+  /**
+   * Return an Observable that emits a single Map containing all items emitted by the source Observable,
+   * mapped by the keys returned by a specified {@code keySelector} function.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
+   * <p>
+   * If more than one source item maps to the same key, the Map will contain the latest of those items.
+   *
+   * @param keySelector
+     * the function that extracts the key from a source item to be used in the Map
+   * @return an Observable that emits a single item: a Map containing the mapped items from the source
+   *         Observable
+   */
+
+  def toMap[K] (keySelector: T => K): Observable[Map[K, T]]= {
+    toScalaObservable[Map[K,T]](asJavaObservable.toMap(keySelector))
+  }
+
+  /**
+   * Return an Observable that emits a single Map containing values corresponding to items emitted by the
+   * source Observable, mapped by the keys returned by a specified {@code keySelector} function.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
+   * <p>
+   * If more than one source item maps to the same key, the Map 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 Map
+   * @param valueSelector
+     *            the function that extracts the value from a source item to be used in the Map
+   * @return an Observable that emits a single item: a HashMap containing the mapped items from the source
+   *         Observable
+   */
+
+  def toMap[K, V] (keySelector: T => K, valueSelector: T => V) : Observable[Map[K, V]] = {
+    toScalaObservable[Map[K,V]](asJavaObservable.toMap(keySelector, valueSelector))
+  }
+
+  /**
+   * 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.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
+   *
+   * @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
+   * @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
+   */
+  def toMap[K, V] (keySelector: T => K, valueSelector: T => V, mapFactory: () => Observable[Map[K,V]]): Observable[Map[K,V]] = {
+    toScalaObservable[Map[K,V]](asJavaObservable.toMap(keySelector, valueSelector, mapFactory))
+  }
+
 }
 
 /**

From 69e5ffddb6b259fb7a262072df61d60d94e79410 Mon Sep 17 00:00:00 2001
From: suncelesta <suncelesta@gmail.com>
Date: Tue, 1 Apr 2014 13:23:41 +0400
Subject: [PATCH 178/422] add examples of toMap to RxScalaDemo

Added examples for all three overloads and removed newlines between
methods and docs
---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 24 +++++++++++++++++++
 .../main/scala/rx/lang/scala/Observable.scala |  4 +---
 2 files changed, 25 insertions(+), 3 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 d0ee67838e..5de6a09d62 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
@@ -573,4 +573,28 @@ class RxScalaDemo extends JUnitSuite {
     val o : Observable[Seq[Char]] = List("red".toList, "green".toList, "blue".toList).toObservable.elementAtOrDefault(3, "black".toSeq)
     println(o.toBlockingObservable.single)
   }
+
+  @Test def toMapExample1(): Unit = {
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable
+    val keySelector = (s: String) => s.head
+    val m = o.toMap(keySelector)
+    println(m.toBlockingObservable.single)
+  }
+
+  @Test def toMapExample2(): Unit = {
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable
+    val keySelector = (s: String) => s.head
+    val valueSelector = (s: String) => s.tail
+    val m = o.toMap(keySelector, valueSelector)
+    println(m.toBlockingObservable.single)
+  }
+
+  @Test def toMapExample3(): Unit = {
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable
+    val keySelector = (s: String) => s.head
+    val valueSelector = (s: String) => s.tail
+    val mapFactory = () => Map('s'->"tart")
+    val m = o.toMap(keySelector, valueSelector, mapFactory)
+    println(m.toBlockingObservable.single)
+  }
 }
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 f0f312a2ac..5f3938d38a 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
@@ -2378,7 +2378,6 @@ trait Observable[+T]
    * @return an Observable that emits a single item: a Map containing the mapped items from the source
    *         Observable
    */
-
   def toMap[K] (keySelector: T => K): Observable[Map[K, T]]= {
     toScalaObservable[Map[K,T]](asJavaObservable.toMap(keySelector))
   }
@@ -2399,7 +2398,6 @@ trait Observable[+T]
    * @return an Observable that emits a single item: a HashMap containing the mapped items from the source
    *         Observable
    */
-
   def toMap[K, V] (keySelector: T => K, valueSelector: T => V) : Observable[Map[K, V]] = {
     toScalaObservable[Map[K,V]](asJavaObservable.toMap(keySelector, valueSelector))
   }
@@ -2419,7 +2417,7 @@ trait Observable[+T]
    * @return an Observable that emits a single item: a Map that contains the mapped items emitted by the
    *         source Observable
    */
-  def toMap[K, V] (keySelector: T => K, valueSelector: T => V, mapFactory: () => Observable[Map[K,V]]): Observable[Map[K,V]] = {
+  def toMap[K, V] (keySelector: T => K, valueSelector: T => V, mapFactory: () => Map[K,V]): Observable[Map[K,V]] = {
     toScalaObservable[Map[K,V]](asJavaObservable.toMap(keySelector, valueSelector, mapFactory))
   }
 

From 16b0417ca11081d3f39546968dbaa696d7673f04 Mon Sep 17 00:00:00 2001
From: suncelesta <suncelesta@gmail.com>
Date: Tue, 1 Apr 2014 21:51:54 +0400
Subject: [PATCH 179/422] corrected implementation

Implementation corrected to not raise exceptions
---
 .../rx/lang/scala/examples/RxScalaDemo.scala     |  2 +-
 .../main/scala/rx/lang/scala/Observable.scala    | 16 ++++++++++++----
 2 files changed, 13 insertions(+), 5 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 5de6a09d62..681d5df690 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
@@ -593,7 +593,7 @@ class RxScalaDemo extends JUnitSuite {
     val o : Observable[String] = List("alice", "bob", "carol").toObservable
     val keySelector = (s: String) => s.head
     val valueSelector = (s: String) => s.tail
-    val mapFactory = () => Map('s'->"tart")
+    val mapFactory = () => Map(('s',"tart"))
     val m = o.toMap(keySelector, valueSelector, mapFactory)
     println(m.toBlockingObservable.single)
   }
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 5f3938d38a..88eeac4bae 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
@@ -20,6 +20,8 @@ import rx.functions.FuncN
 import rx.Observable.OnSubscribeFunc
 import rx.lang.scala.observables.ConnectableObservable
 import scala.concurrent.duration
+import java.util
+import collection.JavaConversions._
 
 
 /**
@@ -2379,7 +2381,9 @@ trait Observable[+T]
    *         Observable
    */
   def toMap[K] (keySelector: T => K): Observable[Map[K, T]]= {
-    toScalaObservable[Map[K,T]](asJavaObservable.toMap(keySelector))
+    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
+    val o: rx.Observable[util.Map[K, T]] = thisJava.toMap[K](keySelector)
+    toScalaObservable[util.Map[K,T]](o).map(m => m.toMap)
   }
 
   /**
@@ -2399,7 +2403,9 @@ trait Observable[+T]
    *         Observable
    */
   def toMap[K, V] (keySelector: T => K, valueSelector: T => V) : Observable[Map[K, V]] = {
-    toScalaObservable[Map[K,V]](asJavaObservable.toMap(keySelector, valueSelector))
+    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
+    val o: rx.Observable[util.Map[K, V]] = thisJava.toMap[K, V](keySelector, valueSelector)
+    toScalaObservable[util.Map[K, V]](o).map(m => m.toMap)
   }
 
   /**
@@ -2417,8 +2423,10 @@ trait Observable[+T]
    * @return an Observable that emits a single item: a Map that contains the mapped items emitted by the
    *         source Observable
    */
-  def toMap[K, V] (keySelector: T => K, valueSelector: T => V, mapFactory: () => Map[K,V]): Observable[Map[K,V]] = {
-    toScalaObservable[Map[K,V]](asJavaObservable.toMap(keySelector, valueSelector, mapFactory))
+  def toMap[K, V] (keySelector: T => K, valueSelector: T => V, mapFactory: () => Map[K, V]): Observable[Map[K, V]] = {
+    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
+    val o: rx.Observable[util.Map[K, V]] = thisJava.toMap[K, V](keySelector, valueSelector)
+    toScalaObservable[util.Map[K, V]](o).map(m => mapFactory() ++ m.toMap)
   }
 
 }

From 9791c2d1e3ad84808d470f584eb4a45abf4c5cb9 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 1 Apr 2014 13:18:25 -0700
Subject: [PATCH 180/422] Use latches instead of sleep for unit test

As per suggestion at https://github.com/benjchristensen/RxJava/commit/5b317ad827f624bed6cbf5f2e04df050ebbe01d0#commitcomment-5839773
---
 .../rx/observers/SerializedObserverTest.java  | 32 ++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index 7a82e59c06..172c996ee0 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -17,6 +17,7 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Matchers.any;
@@ -274,10 +275,18 @@ public void runConcurrencyTest() {
         }
     }
 
+    /**
+     * Test that a notification does not get delayed in the queue waiting for the next event to push it through.
+     * 
+     * @throws InterruptedException
+     */
     @Test
-    public void testNotificationDelay() {
+    public void testNotificationDelay() throws InterruptedException {
         ExecutorService tp = Executors.newFixedThreadPool(2);
 
+        final CountDownLatch onNextCount = new CountDownLatch(1);
+        final CountDownLatch latch = new CountDownLatch(1);
+
         TestSubscriber<String> to = new TestSubscriber<String>(new Observer<String>() {
 
             @Override
@@ -292,12 +301,12 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(String t) {
-                // force it to take time when delivering
-                // so the second thread will asynchronously enqueue
+                // know when the first thread gets in
+                onNextCount.countDown();
+                // force it to take time when delivering so the second one is enqueued
                 try {
-                    Thread.sleep(50);
+                    latch.await();
                 } catch (InterruptedException e) {
-                    e.printStackTrace();
                 }
             }
 
@@ -307,10 +316,23 @@ public void onNext(String t) {
         Future<?> f1 = tp.submit(new OnNextThread(o, 1));
         Future<?> f2 = tp.submit(new OnNextThread(o, 1));
 
+        onNextCount.await();
+
+        Thread t1 = to.getLastSeenThread();
+        System.out.println("first onNext on thread: " + t1);
+
+        latch.countDown();
+
         waitOnThreads(f1, f2);
         // not completed yet
 
         assertEquals(2, to.getOnNextEvents().size());
+
+        Thread t2 = to.getLastSeenThread();
+        System.out.println("second onNext on thread: " + t2);
+
+        assertSame(t1, t2);
+
         System.out.println(to.getOnNextEvents());
         o.onCompleted();
         System.out.println(to.getOnNextEvents());

From abee009981a0610a6ee84c723bf96a59c247c27b Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 1 Apr 2014 13:50:44 -0700
Subject: [PATCH 181/422] comments to walk through logic

---
 .../src/main/java/rx/observers/SerializedObserver.java      | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index f4a21e06f9..94a7845bcb 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -117,18 +117,23 @@ public void onNext(T t) {
                     queue = new FastList();
                 }
                 queue.add(t != null ? t : NULL_SENTINEL);
+                // another thread is emitting so we add to the queue and return
                 return;
             }
+            // we can emit
             emitting = true;
+            // reference to the list to drain before emitting our value
             list = queue;
             queue = null;
         }
 
+        // we only get here if we won the right to emit, otherwise we returned in the if(emitting) block above
         try {
             int iter = MAX_DRAIN_ITERATION;
             do {
                 drainQueue(list);
                 if (iter == MAX_DRAIN_ITERATION) {
+                    // after the first draining we emit our own value
                     actual.onNext(t);
                 }
                 --iter;
@@ -152,6 +157,7 @@ public void onNext(T t) {
                     list = null;
                 }
             }
+            // this will only drain if terminated (done here outside of synchronized block)
             drainQueue(list);
         }
     }

From d6afe1a9e0f0fe31c52372efa12796724620a4d6 Mon Sep 17 00:00:00 2001
From: Zachary Siegel <zsiegel87@gmail.com>
Date: Tue, 1 Apr 2014 15:54:23 -0500
Subject: [PATCH 182/422] Adding a new RetainedFragment example

---
 .../samples/src/main/AndroidManifest.xml      |  11 +-
 .../samples/RetainedFragmentActivityV2.java   | 142 ++++++++++++++++++
 .../layout/retained_fragment_activity_v2.xml  |  14 ++
 .../main/res/layout/retained_fragment_v2.xml  |  19 +++
 4 files changed, 185 insertions(+), 1 deletion(-)
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivityV2.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity_v2.xml
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_v2.xml

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
index f307d55bb0..bc5af1ecb8 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
@@ -9,7 +9,16 @@
         android:theme="@style/AppTheme"
         android:label="@string/app_name">
         <activity
-            android:name=".RetainedFragmentActivity">
+                android:name=".RetainedFragmentActivityV2">
+
+            <intent-filter>
+                <category android:name="android.intent.category.LAUNCHER"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+        </activity>
+        <activity
+                android:name=".RetainedFragmentActivity">
 
             <intent-filter>
                 <category android:name="android.intent.category.LAUNCHER"/>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivityV2.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivityV2.java
new file mode 100644
index 0000000000..25736d12fc
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivityV2.java
@@ -0,0 +1,142 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.widget.Button;
+import android.widget.TextView;
+import org.json.JSONException;
+import org.json.JSONObject;
+import rx.Observable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * A retained fragment whose goals are below
+ *
+ * 1) gracefully handle rotation - not losing any data
+ * 2) gracefully handle the user moving in and out of the app
+ * 3) use a button or trigger of some sort to start the observable, something more in line with typical use
+ * 4) ensure that the callbacks are not called if the user moves away from the fragment
+ *
+ * @author zsiegel (zsiegel87@gmail.com)
+ */
+public class RetainedFragmentActivityV2 extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+        setTitle("Fake API call V2");
+        setContentView(R.layout.retained_fragment_activity_v2);
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    public static class RetainedFragmentV2 extends Fragment {
+
+        private Observable<String> observable;
+        private Subscription subscription = Subscriptions.empty();
+        private Button startButton;
+        private boolean progressVisiblity;
+
+        // in a production app, you don't want to have JSON parser code in your fragment,
+        // but we'll simplify a little here
+        private static final Func1<String, String> PARSE_JSON = new Func1<String, String>() {
+            @Override
+            public String call(String json) {
+                try {
+                    JSONObject jsonObject = new JSONObject(json);
+                    return String.valueOf(jsonObject.getInt("result"));
+                } catch (JSONException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        };
+
+        public RetainedFragmentV2() {
+            setRetainInstance(true);
+        }
+
+        /**
+         * We un-subscribe whenever we are paused
+         */
+        @Override
+        public void onPause() {
+            subscription.unsubscribe();
+            super.onPause();
+        }
+
+        /**
+         * We re-subscribe whenever we are resumed
+         */
+        @Override
+        public void onResume() {
+            super.onResume();
+            subscribe();
+        }
+
+        @Override
+        public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+            return inflater.inflate(R.layout.retained_fragment_v2, container, false);
+        }
+
+        @Override
+        public void onViewCreated(final View view, Bundle savedInstanceState) {
+            super.onViewCreated(view, savedInstanceState);
+
+            final TextView textView = (TextView)getView().findViewById(android.R.id.text1);
+
+            startButton = (Button) view.findViewById(R.id.button);
+            startButton.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    textView.setText("");
+                    start();
+                    startButton.setEnabled(false);
+                }
+            });
+        }
+
+        private void start() {
+
+            progressVisiblity = true;
+
+            observable = SampleObservables
+                    .fakeApiCall(5000)
+                    .map(PARSE_JSON)
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .cache();
+
+            subscribe();
+        }
+
+        /**
+         * We subscribe/re-subscribe here
+         */
+        private void subscribe() {
+            if (observable != null) {
+
+                getActivity().setProgressBarIndeterminateVisibility(progressVisiblity);
+
+                final TextView textView = (TextView)getView().findViewById(android.R.id.text1);
+
+                subscription = observable.subscribe(new Action1<String>() {
+                    @Override
+                    public void call(String result) {
+                        textView.setText(result);
+                        progressVisiblity = false;
+                        getActivity().setProgressBarIndeterminateVisibility(progressVisiblity);
+                        startButton.setEnabled(true);
+                    }
+                });
+            }
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity_v2.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity_v2.xml
new file mode 100644
index 0000000000..a6fe72f624
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity_v2.xml
@@ -0,0 +1,14 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                xmlns:tools="http://schemas.android.com/tools"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                tools:context="com.netflix.rxjava.android.samples.RetainedFragmentActivity">
+
+    <fragment
+            android:tag="retained_fragment_v2"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:name="com.netflix.rxjava.android.samples.RetainedFragmentActivityV2$RetainedFragmentV2"
+            tools:layout="@layout/retained_fragment" />
+
+</RelativeLayout>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_v2.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_v2.xml
new file mode 100644
index 0000000000..aa5e2792c7
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_v2.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent">
+
+    <TextView
+            android:id="@android:id/text1"
+            android:layout_centerInParent="true"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content" />
+
+    <Button
+            android:id="@+id/button"
+            android:text="start!"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"/>
+
+</LinearLayout>
\ No newline at end of file

From 9f6e9a4845cbb079584a634d1856bd0b6e4303da Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 1 Apr 2014 13:59:52 -0700
Subject: [PATCH 183/422] Fix unit test determinism

---
 .../rx/observers/SerializedObserverTest.java  | 25 ++++++++++++++-----
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index 172c996ee0..32f9f359e7 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -284,7 +284,8 @@ public void runConcurrencyTest() {
     public void testNotificationDelay() throws InterruptedException {
         ExecutorService tp = Executors.newFixedThreadPool(2);
 
-        final CountDownLatch onNextCount = new CountDownLatch(1);
+        final CountDownLatch firstOnNext = new CountDownLatch(1);
+        final CountDownLatch onNextCount = new CountDownLatch(2);
         final CountDownLatch latch = new CountDownLatch(1);
 
         TestSubscriber<String> to = new TestSubscriber<String>(new Observer<String>() {
@@ -301,8 +302,7 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(String t) {
-                // know when the first thread gets in
-                onNextCount.countDown();
+                firstOnNext.countDown();
                 // force it to take time when delivering so the second one is enqueued
                 try {
                     latch.await();
@@ -313,10 +313,10 @@ public void onNext(String t) {
         });
         Observer<String> o = serializedObserver(to);
 
-        Future<?> f1 = tp.submit(new OnNextThread(o, 1));
-        Future<?> f2 = tp.submit(new OnNextThread(o, 1));
+        Future<?> f1 = tp.submit(new OnNextThread(o, 1, onNextCount));
+        Future<?> f2 = tp.submit(new OnNextThread(o, 1, onNextCount));
 
-        onNextCount.await();
+        firstOnNext.await();
 
         Thread t1 = to.getLastSeenThread();
         System.out.println("first onNext on thread: " + t1);
@@ -431,14 +431,24 @@ public void call(Subscriber<? super String> s) {
      */
     public static class OnNextThread implements Runnable {
 
+        private final CountDownLatch latch;
         private final Observer<String> observer;
         private final int numStringsToSend;
         final AtomicInteger produced;
 
+        OnNextThread(Observer<String> observer, int numStringsToSend, CountDownLatch latch) {
+            this(observer, numStringsToSend, new AtomicInteger(), latch);
+        }
+
         OnNextThread(Observer<String> observer, int numStringsToSend, AtomicInteger produced) {
+            this(observer, numStringsToSend, produced, null);
+        }
+
+        OnNextThread(Observer<String> observer, int numStringsToSend, AtomicInteger produced, CountDownLatch latch) {
             this.observer = observer;
             this.numStringsToSend = numStringsToSend;
             this.produced = produced;
+            this.latch = latch;
         }
 
         OnNextThread(Observer<String> observer, int numStringsToSend) {
@@ -449,6 +459,9 @@ public static class OnNextThread implements Runnable {
         public void run() {
             for (int i = 0; i < numStringsToSend; i++) {
                 observer.onNext(Thread.currentThread().getId() + "-" + i);
+                if (latch != null) {
+                    latch.countDown();
+                }
                 produced.incrementAndGet();
             }
         }

From d803bea70be00e17bf00694fce8bb44be821d599 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 2 Apr 2014 04:21:29 +0000
Subject: [PATCH 184/422] [Gradle Release Plugin] - pre tag commit:  '0.17.3'.

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

diff --git a/gradle.properties b/gradle.properties
index 6d1856974e..c00a70af5e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.3-SNAPSHOT
+version=0.17.3

From 10d5aa0c01a5b0e21d35fbb2d243a680e95ff6b8 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 2 Apr 2014 04:21:33 +0000
Subject: [PATCH 185/422] [Gradle Release Plugin] - new version commit: 
 '0.17.4-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index c00a70af5e..ba3ab22d56 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.3
+version=0.17.4-SNAPSHOT

From 14dda8bdc9dacbe4a5b75df71ff75d07e80673ad Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Tue, 1 Apr 2014 21:27:26 -0700
Subject: [PATCH 186/422] Version 0.17.3

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

diff --git a/CHANGES.md b/CHANGES.md
index c510b7abab..731fc21557 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,14 @@
 # RxJava Releases #
 
+### Version 0.17.3 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.3%22)) ###
+
+* [Pull 991] (https://github.com/Netflix/RxJava/pull/991) JMH Benchmark Build Config
+* [Pull 993] (https://github.com/Netflix/RxJava/pull/993) JMH Perf Tests
+* [Pull 995] (https://github.com/Netflix/RxJava/pull/995) Support Custom JMH Args
+* [Pull 996] (https://github.com/Netflix/RxJava/pull/996) JMH Perfshadowjar
+* [Pull 1003] (https://github.com/Netflix/RxJava/pull/1003) Func0 can transparently implement java.util.concurrent.Callable
+* [Pull 999] (https://github.com/Netflix/RxJava/pull/999) New Implementation of SerializedObserver
+
 ### Version 0.17.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.2%22)) ###
 
 * [Pull 963](https://github.com/Netflix/RxJava/pull/963) A more robust JMH benchmarking set-up 

From 8525f6f43577713101e08d03baaf8e203d75ae78 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 1 Apr 2014 23:02:42 -0700
Subject: [PATCH 187/422] UnsafeSubscribe

Migrate from reflection to unsafeSubscribe as per discussion at https://github.com/Netflix/RxJava/issues/676
---
 rxjava-core/src/main/java/rx/Observable.java  | 549 +++++++-----------
 .../src/main/java/rx/joins/JoinObserver1.java |   2 +-
 .../rx/observables/BlockingObservable.java    |   2 +-
 .../rx/observables/GroupedObservable.java     |   2 +-
 .../rx/operators/BufferUntilSubscriber.java   |   4 +-
 .../java/rx/operators/ChunkedOperation.java   |  62 +-
 .../java/rx/operators/NotificationLite.java   |   1 -
 .../main/java/rx/operators/OperationAll.java  |   9 +-
 .../main/java/rx/operators/OperationAny.java  |   5 +-
 .../rx/operators/OperationAsObservable.java   |   5 +-
 .../java/rx/operators/OperationAverage.java   |  17 +-
 .../java/rx/operators/OperationBuffer.java    |  21 +-
 .../java/rx/operators/OperationCache.java     |   5 +-
 .../rx/operators/OperationCombineLatest.java  |   6 +-
 .../java/rx/operators/OperationConcat.java    |   8 +-
 .../java/rx/operators/OperationDebounce.java  |  14 +-
 .../rx/operators/OperationDefaultIfEmpty.java |   3 +-
 .../java/rx/operators/OperationDefer.java     |   3 +-
 .../java/rx/operators/OperationDelay.java     |  18 +-
 .../rx/operators/OperationDematerialize.java  |   3 +-
 .../java/rx/operators/OperationDistinct.java  |   5 +-
 .../OperationDistinctUntilChanged.java        |   3 +-
 .../java/rx/operators/OperationFinally.java   |   5 +-
 .../java/rx/operators/OperationFlatMap.java   |  17 +-
 .../rx/operators/OperationGroupByUntil.java   |  12 +-
 .../java/rx/operators/OperationGroupJoin.java |  21 +-
 .../main/java/rx/operators/OperationJoin.java |  17 +-
 .../rx/operators/OperationJoinPatterns.java   |   3 +-
 .../java/rx/operators/OperationLatest.java    |   6 +-
 .../rx/operators/OperationMaterialize.java    |   3 +-
 .../operators/OperationMergeDelayError.java   |   9 +-
 .../OperationMergeMaxConcurrent.java          |  11 +-
 .../rx/operators/OperationMostRecent.java     |   6 +-
 .../java/rx/operators/OperationMulticast.java |   6 +-
 .../main/java/rx/operators/OperationNext.java |   6 +-
 ...erationOnErrorResumeNextViaObservable.java |   6 +-
 .../rx/operators/OperationOnErrorReturn.java  |   3 +-
 ...ionOnExceptionResumeNextViaObservable.java |   6 +-
 .../java/rx/operators/OperationRefCount.java  |   3 +-
 .../java/rx/operators/OperationReplay.java    |   3 +-
 .../java/rx/operators/OperationSample.java    |  13 +-
 .../rx/operators/OperationSequenceEqual.java  |   4 +-
 .../java/rx/operators/OperationSingle.java    |   3 +-
 .../main/java/rx/operators/OperationSkip.java |   6 +-
 .../java/rx/operators/OperationSkipLast.java  |   7 +-
 .../java/rx/operators/OperationSkipUntil.java |   8 +-
 .../java/rx/operators/OperationSwitch.java    |   7 +-
 .../java/rx/operators/OperationTakeLast.java  |   9 +-
 .../java/rx/operators/OperationTakeTimed.java |  11 +-
 .../java/rx/operators/OperationTakeUntil.java |   5 +-
 .../java/rx/operators/OperationTakeWhile.java |   5 +-
 .../rx/operators/OperationThrottleFirst.java  |   3 +-
 .../rx/operators/OperationTimeInterval.java   |   5 +-
 .../java/rx/operators/OperationToFuture.java  |   4 +-
 .../rx/operators/OperationToIterator.java     |   4 +-
 .../java/rx/operators/OperationToMap.java     |   5 +-
 .../rx/operators/OperationToMultimap.java     |   5 +-
 .../OperationToObservableFuture.java          |   2 +-
 .../java/rx/operators/OperationUsing.java     |   5 +-
 .../java/rx/operators/OperationWindow.java    |  21 +-
 .../main/java/rx/operators/OperatorAmb.java   |   2 +-
 .../main/java/rx/operators/OperatorCast.java  |   1 -
 .../java/rx/operators/OperatorGroupBy.java    |   2 +-
 .../main/java/rx/operators/OperatorMerge.java |   2 +-
 .../rx/operators/OperatorOnErrorFlatMap.java  |   2 +-
 .../OperatorOnErrorResumeNextViaFunction.java |   2 +-
 .../main/java/rx/operators/OperatorPivot.java |   8 +-
 .../java/rx/operators/OperatorRepeat.java     |   2 +-
 .../main/java/rx/operators/OperatorRetry.java |   2 +-
 .../java/rx/operators/OperatorSkipWhile.java  |   7 -
 .../rx/operators/OperatorSubscribeOn.java     |   2 +-
 .../rx/operators/OperatorTimeoutBase.java     |   3 +-
 .../OperatorTimeoutWithSelector.java          |   4 +-
 .../main/java/rx/operators/OperatorZip.java   |   2 +-
 .../main/java/rx/operators/SafeObserver.java  |   3 +-
 .../java/rx/plugins/RxJavaPluginsTest.java    |   2 +
 settings.gradle                               |   2 +-
 77 files changed, 510 insertions(+), 560 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 6ccbd7965e..d1e46e6213 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -186,8 +186,7 @@ protected Observable(OnSubscribe<T> f) {
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/create.png">
      * <p>
      * 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.
+     * Subscriber's {@link Subscriber#onNext onNext}, {@link Subscriber#onError onError}, and {@link Subscriber#onCompleted onCompleted} methods appropriately.
      * <p>
      * A well-formed Observable must invoke either the Subscriber's {@code onCompleted} method exactly once or
      * its {@code onError} method exactly once.
@@ -198,8 +197,7 @@ protected Observable(OnSubscribe<T> f) {
      * @param <T>
      *            the type of the items that this Observable emits
      * @param f
-     *            a function that accepts an {@code Subscriber<T>}, and invokes its {@code onNext},
-     *            {@code onError}, and {@code onCompleted} methods as appropriate
+     *            a function that accepts an {@code Subscriber<T>}, 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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-create">RxJava Wiki: create()</a>
@@ -210,12 +208,12 @@ public final static <T> Observable<T> create(OnSubscribe<T> f) {
     }
 
     /**
-     * Invoked when Obserable.subscribe is called. 
+     * Invoked when Obserable.subscribe is called.
      */
     public static interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
         // cover for generics insanity
     }
-    
+
     /**
      * Operator function for lifting into an Observable.
      */
@@ -223,7 +221,6 @@ public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<
         // cover for generics insanity
     }
 
-
     /**
      * @deprecated use {@link #create(OnSubscribe)}
      */
@@ -822,8 +819,7 @@ public final static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combin
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
@@ -1080,15 +1076,13 @@ public final static <T> Observable<T> defer(Func0<? extends Observable<? extends
     }
 
     /**
-     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its
-     * {@link Observer#onCompleted onCompleted} method.
+     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its {@link Observer#onCompleted onCompleted} method.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/empty.png">
      * 
      * @param <T>
      *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: empty()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229670.aspx">MSDN: Observable.Empty</a>
      */
@@ -1097,8 +1091,7 @@ public final static <T> Observable<T> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/empty.s.png">
      * 
@@ -1106,8 +1099,7 @@ public final static <T> Observable<T> empty() {
      *            the Scheduler to use to call the {@link Observer#onCompleted onCompleted} method
      * @param <T>
      *            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
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: empty()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229066.aspx">MSDN: Observable.Empty Method (IScheduler)</a>
@@ -1162,8 +1154,7 @@ public final static <T> Observable<T> error(Throwable exception, Scheduler sched
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.png">
      * <p>
      * 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.
+     * return value of the {@link Future#get} method of that object, by passing the object into the {@code from} method.
      * <p>
      * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
      * 
@@ -1185,8 +1176,7 @@ public final static <T> Observable<T> from(Future<? extends T> future) {
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.png">
      * <p>
      * 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.
+     * return value of the {@link Future#get} method of that object, by passing the object into the {@code from} method.
      * <p>
      * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
      * 
@@ -1212,15 +1202,13 @@ public final static <T> Observable<T> from(Future<? extends T> future, long time
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.s.png">
      * <p>
      * 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.
+     * return value of the {@link Future#get} method of that object, by passing the object into the {@code from} method.
      * <p>
      * 
      * @param future
      *            the source {@link Future}
      * @param scheduler
-     *            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
+     *            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 <T>
      *            the type of object that the {@link Future} returns, and also the type of item to be emitted by
      *            the resulting Observable
@@ -1626,8 +1614,7 @@ public final static Observable<Long> interval(long interval, TimeUnit unit, Sche
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/just.png">
      * <p>
-     * 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.
      * <p>
      * 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
@@ -1654,7 +1641,7 @@ public void call(Subscriber<? super T> s) {
 
         });
     }
-    
+
     /**
      * Returns an Observable that emits a single item and then completes, on a specified Scheduler.
      * <p>
@@ -1733,7 +1720,7 @@ public final static <T> Observable<T> merge(Iterable<? extends Observable<? exte
      * @return an Observable that emits items that are the result of flattening the items emitted by the
      *         Observables in the Iterable
      * @throws IllegalArgumentException
-     *            if {@code maxConcurrent} is less than or equal to 0
+     *             if {@code maxConcurrent} is less than or equal to 0
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229923.aspx">MSDN: Observable.Merge</a>
      */
@@ -1760,7 +1747,7 @@ public final static <T> Observable<T> merge(Iterable<? extends Observable<? exte
      * @return an Observable that emits items that are the result of flattening the items emitted by the
      *         Observables in the Iterable
      * @throws IllegalArgumentException
-     *            if {@code maxConcurrent} is less than or equal to 0
+     *             if {@code maxConcurrent} is less than or equal to 0
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh244329.aspx">MSDN: Observable.Merge</a>
      */
@@ -1801,8 +1788,7 @@ public final static <T> Observable<T> merge(Iterable<? extends Observable<? exte
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
@@ -1824,10 +1810,9 @@ public final static <T> Observable<T> merge(Observable<? extends Observable<? ex
      *            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
+     * @return an Observable that emits items that are the result of flattening the Observables emitted by the {@code source} Observable
      * @throws IllegalArgumentException
-     *            if {@code maxConcurrent} is less than or equal to 0
+     *             if {@code maxConcurrent} is less than or equal to 0
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211914.aspx">MSDN: Observable.Merge</a>
      */
@@ -2107,8 +2092,7 @@ public final static <T> Observable<T> merge(Observable<? extends T>[] sequences,
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
@@ -2178,8 +2162,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * source Observables without being interrupted by an error notification from one of them.
      * <p>
      * 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
@@ -2210,8 +2194,7 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * source Observables without being interrupted by an error notification from one of them.
      * <p>
      * 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
@@ -2243,9 +2226,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * 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.
      * <p>
-     * 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
@@ -2279,9 +2261,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * 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.
      * <p>
-     * 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
@@ -2317,9 +2298,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * 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.
      * <p>
-     * 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
@@ -2357,9 +2337,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * 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.
      * <p>
-     * 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
@@ -2423,7 +2402,7 @@ public final static <T extends Comparable<? super T>> Observable<T> min(Observab
     public final Observable<Observable<T>> nest() {
         return just(this);
     }
-    
+
     /**
      * Returns an Observable that never sends any items or notifications to an {@link Observer}.
      * <p>
@@ -2442,11 +2421,9 @@ public final static <T> Observable<T> never() {
 
     /**
      * Converts an {@code Observable<Observable<T>>} into another {@code Observable<Observable<T>>} whose
-     * emitted Observables emit the same items, but the number of such Observables is restricted by
-     * {@code parallelObservables}.
+     * emitted Observables emit the same items, but the number of such Observables is restricted by {@code parallelObservables}.
      * <p>
-     * For example, if the original {@code Observable<Observable<T>>} emits 100 Observables and
-     * {@code parallelObservables} is 8, the items emitted by the 100 original Observables will be distributed
+     * For example, if the original {@code Observable<Observable<T>>} 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallelMerge.png">
@@ -2465,11 +2442,9 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
 
     /**
      * Converts an {@code Observable<Observable<T>>} into another {@code Observable<Observable<T>>} 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.
+     * emitted Observables emit the same items, but the number of such Observables is restricted by {@code parallelObservables}, and each runs on a defined Scheduler.
      * <p>
-     * For example, if the original {@code Observable<Observable<T>>} emits 100 Observables and
-     * {@code parallelObservables} is 8, the items emitted by the 100 original Observables will be distributed
+     * For example, if the original {@code Observable<Observable<T>>} 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallelMerge.png">
@@ -2518,9 +2493,9 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
      * @return
      */
     public static final <K1, K2, T> Observable<GroupedObservable<K2, GroupedObservable<K1, T>>> pivot(Observable<GroupedObservable<K1, GroupedObservable<K2, T>>> groups) {
-        return groups.lift(new OperatorPivot<K1, K2, T>());        
+        return groups.lift(new OperatorPivot<K1, K2, T>());
     }
-    
+
     /**
      * Returns an Observable that emits a sequence of Integers within a specified range.
      * <p>
@@ -2617,7 +2592,7 @@ public final Boolean call(T first, T second) {
     public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
         return OperationSequenceEqual.sequenceEqual(first, second, equality);
     }
-    
+
     /**
      * Returns an Observable that emits the sum of all the Doubles emitted by the source Observable.
      * <p>
@@ -2691,8 +2666,7 @@ public final static Observable<Long> sumLong(Observable<Long> source) {
      * most recently emitted of those Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchDo.png">
-     * <p>
-     * {@code switchDo()} subscribes to an Observable that emits Observables. Each time it observes one of these
+     * <p> {@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.
@@ -2714,8 +2688,7 @@ public final static <T> Observable<T> switchDo(Observable<? extends Observable<?
      * most recently emitted of those Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchLatest.png">
-     * <p>
-     * {@code switchLatest()} subscribes to an Observable that emits Observables. Each time it observes one of
+     * <p> {@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.
@@ -2736,8 +2709,7 @@ public final static <T> Observable<T> switchLatest(Observable<? extends Observab
      * most recently emitted of those Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchDo.png">
-     * <p>
-     * {@code switchOnNext()} subscribes to an Observable that emits Observables. Each time it observes one of
+     * <p> {@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.
@@ -3110,8 +3082,7 @@ public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3
     /**
      * 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.
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
@@ -3140,8 +3111,7 @@ public final static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws,
     /**
      * Returns an Observable that emits the results of a function of your choosing applied to combinations of
      * <i>n</i> items emitted, in sequence, by the <i>n</i> Observables emitted by a specified Observable.
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
@@ -3154,8 +3124,7 @@ public final static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws,
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
      */
@@ -3175,14 +3144,13 @@ public Observable<?>[] call(List<? extends Observable<?>> o) {
      * two items emitted, in sequence, by two other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3204,15 +3172,14 @@ public final static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, O
      * three items emitted, in sequence, by three other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3236,15 +3203,14 @@ public final static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o
      * four items emitted, in sequence, by four other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3270,15 +3236,14 @@ public final static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T
      * five items emitted, in sequence, by five other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3306,14 +3271,13 @@ public final static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? exten
      * six items emitted, in sequence, by six other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3344,14 +3308,13 @@ public final static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? e
      * seven items emitted, in sequence, by seven other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3384,14 +3347,13 @@ public final static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable
      * eight items emitted, in sequence, by eight other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3426,14 +3388,13 @@ public final static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observ
      * nine items emitted, in sequence, by nine other Observables.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p>
-     * {@code zip} applies this function in strict sequence, so the first item emitted by the new Observable
+     * <p> {@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.
      * <p>
-     * The resulting {@code Observable<R>} 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
+     * The resulting {@code Observable<R>} 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
@@ -3619,8 +3580,7 @@ public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor)
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer1.png">
      * 
      * @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
+     *            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
@@ -3641,8 +3601,7 @@ public final <TClosing> Observable<List<T>> buffer(Func0<? extends Observable<?
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(int count) {
@@ -3661,8 +3620,7 @@ public final Observable<List<T>> buffer(int 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)}.
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
@@ -3697,8 +3655,7 @@ public final Observable<List<T>> 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer7.s.png">
@@ -3721,8 +3678,8 @@ public final Observable<List<T>> 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 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer5.png">
@@ -3742,8 +3699,8 @@ public final Observable<List<T>> 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
+     * 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.
      * <p>
@@ -3767,8 +3724,8 @@ public final Observable<List<T>> 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
+     * 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.
@@ -3795,8 +3752,8 @@ public final Observable<List<T>> 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
+     * 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.
      * <p>
@@ -3892,14 +3849,14 @@ public final <B> Observable<List<T>> buffer(Observable<B> 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 Subscriber}s.
      * <p>
-     * 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()}.
      * <p>
      *
-     *                           <!-- IS THE FOLLOWING NOTE STILL VALID??? -->
+     * <!-- IS THE FOLLOWING NOTE STILL VALID??? -->
      *
-     * <em>Note:</em> 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
+     * <em>Note:</em> 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
@@ -4235,8 +4192,8 @@ public final Observable<T> 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
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/dematerialize.png">
@@ -4457,7 +4414,7 @@ public final void onNext(T args) {
 
         return lift(new OperatorDoOnEach<T>(observer));
     }
-    
+
     /**
      * Modifies an Observable so that it invokes an action when it calls {@code onCompleted} or {@code onError}.
      * <p>
@@ -4560,8 +4517,7 @@ public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/filter.png">
      * 
      * @param predicate
-     *            a function that evaluates the items emitted by the source Observable, returning {@code true}
-     *            if they pass 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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-filter-or-where">RxJava Wiki: filter()</a>
@@ -4571,15 +4527,13 @@ public final Observable<T> filter(Func1<? super T, Boolean> 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}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/finallyDo.png">
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-finallydo">RxJava Wiki: finallyDo()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212133.aspx">MSDN: Observable.Finally</a>
      */
@@ -4588,13 +4542,11 @@ public final Observable<T> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
      * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
      * @see "MSDN: Observable.firstAsync()"
      */
@@ -4645,8 +4597,7 @@ public final Observable<T> firstOrDefault(T defaultValue) {
      * @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}
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-firstordefault">RxJava Wiki: firstOrDefault()</a>
@@ -4843,8 +4794,7 @@ public final Observable<T> last() {
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
@@ -5107,8 +5057,7 @@ public final <U, R> Observable<R> mergeMap(Func1<? super T, ? extends Observable
      *            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}
+     *         the values in the Iterables corresponding to those items, as generated by {@code collectionSelector}
      */
     public final <R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector) {
         return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
@@ -5226,7 +5175,8 @@ public final <TIntermediate, TResult> Observable<TResult> multicast(
      *            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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: Observable.publish() and Observable.multicast()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: Observable.publish() and
+     *      Observable.multicast()</a>
      */
     public final <R> ConnectableObservable<R> multicast(Subject<? super T, ? extends R> subject) {
         return OperationMulticast.multicast(this, subject);
@@ -5239,8 +5189,7 @@ public final <R> ConnectableObservable<R> multicast(Subject<? super T, ? extends
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-observeon">RxJava Wiki: observeOn()</a>
      */
     public final Observable<T> observeOn(Scheduler scheduler) {
@@ -5267,18 +5216,16 @@ 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorResumeNext.png">
      * <p>
      * 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
+     * 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.
      * <p>
@@ -5296,16 +5243,14 @@ public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Ob
     }
 
     /**
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorResumeNext.png">
      * <p>
      * 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
+     * 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
@@ -5325,16 +5270,14 @@ public final Observable<T> onErrorResumeNext(final Observable<? extends T> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorReturn.png">
      * <p>
      * 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
+     * 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}.
      * <p>
      * You can use this to prevent errors from propagating or to supply fallback data should errors be
@@ -5360,21 +5303,17 @@ public final Observable<T> onErrorFlatMap(final Func1<OnErrorThrowable, ? extend
     }
 
     /**
-     * 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}.
      * <p>
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onExceptionResumeNextViaObservable.png">
      * <p>
      * 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
+     * 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.
      * <p>
@@ -5392,8 +5331,7 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
     }
 
     /**
-     * Perform work on the source {@code Observable<T>} in parallel by sharding it on a
-     * {@link Schedulers#computation()} {@link Scheduler}, and return the resulting {@code Observable<R>}.
+     * Perform work on the source {@code Observable<T>} in parallel by sharding it on a {@link Schedulers#computation()} {@link Scheduler}, and return the resulting {@code Observable<R>}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallel.png">
      * 
@@ -5441,9 +5379,8 @@ private Subscription protectivelyWrapAndSubscribe(Subscriber<? super T> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.png">
      * 
@@ -5456,8 +5393,7 @@ public final ConnectableObservable<T> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.f.png">
      * 
@@ -5467,8 +5403,7 @@ public final ConnectableObservable<T> publish() {
      *            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
+     * @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 <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
         return multicast(new Func0<Subject<T, T>>() {
@@ -5507,8 +5442,7 @@ public final Subject<T, T> call() {
     }
 
     /**
-     * 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.
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.i.png">
      * 
@@ -5545,8 +5479,7 @@ public final ConnectableObservable<T> publishLast() {
      *            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
+     * @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 <R> Observable<R> publishLast(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
         return multicast(new Func0<Subject<T, T>>() {
@@ -5566,8 +5499,7 @@ public final Subject<T, T> call() {
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/reduce.png">
      * <p>
      * 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.
+     * "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
@@ -5599,8 +5531,7 @@ public final Observable<T> reduce(Func2<T, T, T> accumulator) {
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/reduceSeed.png">
      * <p>
      * 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.
+     * "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
@@ -5647,16 +5578,14 @@ public final Observable<T> repeat(Scheduler scheduler) {
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most
-     * {@code count} times.
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most {@code count} times.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.on.png">
      * 
      * @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
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
@@ -5670,8 +5599,7 @@ public final Observable<T> repeat(long count) {
     }
 
     /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most
-     * {@code 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.ons.png">
      * 
@@ -5680,8 +5608,7 @@ public final Observable<T> repeat(long count) {
      *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
      */
@@ -5714,8 +5641,7 @@ public final ConnectableObservable<T> replay() {
      * @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 source 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229653.aspx">MSDN: Observable.Replay</a>
      */
@@ -5777,8 +5703,7 @@ public final Subject<T, T> call() {
      *            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 source Observable, and
-     *         replays no more than {@code bufferSize} items that were emitted within the window defined by
-     *         {@code time}
+     *         replays no more than {@code bufferSize} items that were emitted within the window defined by {@code time}
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh228952.aspx">MSDN: Observable.Replay</a>
      */
@@ -5808,8 +5733,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      *            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}
+     *         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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
@@ -5975,8 +5899,7 @@ public final ConnectableObservable<T> replay(int bufferSize) {
      * @param unit
      *            the time unit of {@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}
+     *         replays at most {@code bufferSize} items that were emitted during the window defined by {@code time}
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229874.aspx">MSDN: Observable.Replay</a>
      */
@@ -5999,8 +5922,7 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
      * @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 source Observable and
-     *         replays at most {@code bufferSize} items that were emitted during the window defined by
-     *         {@code time}
+     *         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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
@@ -6076,16 +5998,14 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit, 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}.
+     * will replay all of its items and notifications to any future {@link Observer} on the given {@link Scheduler}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.s.png">
      * 
      * @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}
+     *         will replay all of its items and notifications to any future {@link Observer} on the given {@link Scheduler}
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211699.aspx">MSDN: Observable.Replay</a>
      */
@@ -6094,8 +6014,7 @@ public final ConnectableObservable<T> 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).
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/retry.png">
      * <p>
@@ -6103,8 +6022,8 @@ public final ConnectableObservable<T> replay(Scheduler scheduler) {
      * Observable rather than propagating the {@code onError} call.
      * <p>
      * 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
+     * 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
@@ -6115,18 +6034,16 @@ public final Observable<T> retry() {
     }
 
     /**
-     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError}
-     * up to a specified 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/retry.png">
      * <p>
      * 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.
+     * Observable for a maximum of {@code retryCount} resubscriptions rather than propagating the {@code onError} call.
      * <p>
      * 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
+     * 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
@@ -6245,11 +6162,10 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
     public final Observable<T> serialize() {
         return lift(new OperatorSerialize<T>());
     }
-    
+
     /**
      * 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}.
+     * item. If the source Observable emits more than one item or no items, throw an {@code IllegalArgumentException}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.png">
      * 
@@ -6287,8 +6203,7 @@ public final Observable<T> single(Func1<? super T, Boolean> 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.}
-     * <p>
+     * Observable emits more than one item, throw an {@code IllegalArgumentException.} <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/singleOrDefault.png">
      * 
      * @param defaultValue
@@ -6307,8 +6222,7 @@ public final Observable<T> 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}.
+     * default item. If the source Observable emits more than one such item, throw an {@code IllegalArgumentException}.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/singleOrDefault.p.png">
      * 
@@ -6335,8 +6249,7 @@ public final Observable<T> singleOrDefault(T defaultValue, Func1<? super T, Bool
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
      */
     public final Observable<T> skip(int num) {
@@ -6499,7 +6412,7 @@ public final Observable<T> skipWhileWithIndex(Func2<? super T, Integer, Boolean>
 
     /**
      * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit
-     * items emitted by the source Observable. 
+     * items emitted by the source Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.o.png">
      * 
@@ -6530,8 +6443,7 @@ public final Observable<T> startWith(Iterable<T> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.s.png">
      * 
@@ -7064,14 +6976,29 @@ public void onNext(T t) {
         });
     }
 
+    /**
+     * Subscribe to Observable and invoke {@link OnSubscribe} function without any
+     * contract protection, error handling, unsubscribe, or execution hooks.
+     * <p>
+     * This should only be used for implementing an {@link Operator} that requires nested subscriptions.
+     * <p>
+     * Normal use should use {@link #subscribe(Subscriber)} which ensures the Rx contract and other functionality.
+     * 
+     * @param subscriber
+     * @return Subscription which is the Subscriber passed in
+     */
+    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
+        onSubscribe.call(subscriber);
+        return subscriber;
+    }
+
     /**
      * A {@link Subscriber} must call an Observable's {@code subscribe} method in order to receive items and
      * notifications from the Observable.
      * <p>
      * A typical implementation of {@code subscribe} does the following:
      * <ol>
-     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>}
-     * object.</li>
+     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>} object.</li>
      * <li>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.</li>
@@ -7086,7 +7013,7 @@ public void onNext(T t) {
      * 
      * @param observer
      *            the {@link Subscriber}
-     * @return a {@link Subscription} reference with which Subscribers that are {@link Observer}s can 
+     * @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
@@ -7116,13 +7043,12 @@ public final Subscription subscribe(Subscriber<? super T> 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);
-            } else {
+            // if not already wrapped
+            if (!(observer instanceof SafeSubscriber)) {
                 // assign to `observer` so we return the protected version
                 observer = new SafeSubscriber<T>(observer);
-                onSubscribeFunction.call(observer);
             }
+            onSubscribeFunction.call(observer);
             final Subscription returnSubscription = hook.onSubscribeReturn(observer);
             // we return it inside a Subscription so it can't be cast back to Subscriber
             return Subscriptions.create(new Action0() {
@@ -7161,8 +7087,7 @@ public void call() {
      * <p>
      * A typical implementation of {@code subscribe} does the following:
      * <ol>
-     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>}
-     * object.</li>
+     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>} object.</li>
      * <li>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.</li>
@@ -7202,7 +7127,7 @@ public final Subscription subscribe(Subscriber<? super T> observer, Scheduler sc
     public final Observable<T> subscribeOn(Scheduler scheduler) {
         return nest().lift(new OperatorSubscribeOn<T>(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.
@@ -7285,8 +7210,7 @@ public final Observable<Long> sumLong(Func1<? super T, Long> valueExtractor) {
      * @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
+     * @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 <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<? extends R>> func) {
         return switchOnNext(map(func));
@@ -7298,12 +7222,10 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/synchronize.png">
      * <p>
-     * 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
@@ -7316,17 +7238,14 @@ public final Observable<T> 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.
+     * chronologically well-behaved by acquiring a mutual-exclusion lock for the object provided as the {@code lock} parameter.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/synchronize.png">
      * <p>
-     * 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
@@ -7344,8 +7263,7 @@ public final Observable<T> synchronize(Object lock) {
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.png">
      * <p>
-     * 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
@@ -7636,8 +7554,7 @@ public final Observable<List<T>> takeLastBuffer(long time, TimeUnit unit, Schedu
      *            from the source Observable
      * @param <E>
      *            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 <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takeuntil">RxJava Wiki: takeUntil()</a>
      */
     public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
@@ -7687,8 +7604,7 @@ public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Int
      * 
      * @param selector
      *            selector that will be invoked for items emitted by the source Observable
-     * @return a {@link Plan0} that produces the projected results, to be fed (with other Plans) to the
-     *         {@link #when} Observer
+     * @return a {@link Plan0} that produces the projected results, to be fed (with other Plans) to the {@link #when} Observer
      * @throws NullPointerException
      *             if {@code selector} is null
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: then()</a>
@@ -7702,8 +7618,7 @@ public final <R> Plan0<R> then(Func1<T, R> selector) {
      * Returns an Observable that emits only the first item emitted by the source Observable during sequential
      * time windows of a specified duration.
      * <p>
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleFirst.png">
      * 
@@ -7722,8 +7637,7 @@ public final Observable<T> 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.
      * <p>
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleFirst.s.png">
      * 
@@ -7745,8 +7659,7 @@ public final Observable<T> 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.
      * <p>
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleLast.png">
      * 
@@ -7767,8 +7680,7 @@ public final Observable<T> 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.
      * <p>
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleLast.s.png">
      * 
@@ -7937,7 +7849,7 @@ public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTi
      *             if {@code timeoutSelector} is null
      */
     public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> other) {
-        if(timeoutSelector == null) {
+        if (timeoutSelector == null) {
             throw new NullPointerException("timeoutSelector is null");
         }
         return lift(new OperatorTimeoutWithSelector<T, U, V>(firstTimeoutSelector, timeoutSelector, other));
@@ -8080,8 +7992,7 @@ public final Observable<T> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timestamp.png">
      * 
@@ -8094,8 +8005,7 @@ public final Observable<Timestamped<T>> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timestamp.s.png">
      * 
@@ -8126,14 +8036,14 @@ public final BlockingObservable<T> toBlockingObservable() {
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toList.png">
      * <p>
-     * 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
+     * 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.
      * <p>
      *
-     *                              <!-- IS THE FOLLOWING NOTE STILL VALID? -->
+     * <!-- IS THE FOLLOWING NOTE STILL VALID? -->
      *
      * 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.
@@ -8333,7 +8243,7 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
     public final Observable<T> unsubscribeOn(Scheduler scheduler) {
         return lift(new OperatorUnsubscribeOn<T>(scheduler));
     }
-    
+
     /**
      * Returns an Observable that represents a filtered version of the source Observable.
      * <p>
@@ -8356,8 +8266,7 @@ public final Observable<T> where(Func1<? super T, Boolean> 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.
+     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window1.png">
      * 
@@ -8382,8 +8291,7 @@ public final <TClosing> Observable<Observable<T>> window(Func0<? extends Observa
      * 
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(int count) {
@@ -8401,8 +8309,7 @@ public final Observable<Observable<T>> 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 {@code skip} and
-     *            {@code count} are equal this is the same operation as {@link #window(int)}.
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
@@ -8459,8 +8366,8 @@ public final Observable<Observable<T>> 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 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window5.png">
@@ -8480,8 +8387,8 @@ public final Observable<Observable<T>> 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
+     * 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.
      * <p>
@@ -8505,8 +8412,8 @@ public final Observable<Observable<T>> 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
+     * 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.
      * <p>
@@ -8532,8 +8439,8 @@ public final Observable<Observable<T>> 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 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window5.s.png">
@@ -8556,8 +8463,7 @@ public final Observable<Observable<T>> 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.
+     * the {@code windowOpenings} Observable emits an item and when the Observable returned by {@code closingSelector} emits an item.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window2.png">
      * 
@@ -8586,8 +8492,7 @@ public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<?
      * @param boundary
      *            an Observable whose emitted items close and open windows
      * @return an Observable that 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 {@code boundary}
-     *         Observable
+     *         where the boundary of each window is determined by the items emitted from the {@code boundary} Observable
      */
     public final <U> Observable<Observable<T>> window(Observable<U> boundary) {
         return create(OperationWindow.window(this, boundary));
@@ -8687,40 +8592,4 @@ public void call(Subscriber<? super T> observer) {
             });
         }
     }
-
-    @SuppressWarnings("rawtypes")
-    private final static ConcurrentHashMap<Class, Boolean> internalClassMap = new ConcurrentHashMap<Class, Boolean>();
-
-    /**
-     * Whether a given {@link Function} is an internal implementation inside rx.* packages or not.
-     * <p>
-     * 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"
-     * <p>
-     * 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.
-     * 
-     * @return {@code true} if the given function is an internal implementation, and {@code false} otherwise
-     */
-    private boolean isInternalImplementation(Object o) {
-        if (o == null) {
-            return true;
-        }
-        // prevent double-wrapping (yeah it happens)
-        if (o instanceof SafeSubscriber) {
-            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;
-        }
-    }
 }
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
index 2937b3e0e2..c4cf5d3e25 100644
--- a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
+++ b/rxjava-core/src/main/java/rx/joins/JoinObserver1.java
@@ -61,7 +61,7 @@ public void addActivePlan(ActivePlan0 activePlan) {
     public void subscribe(Object gate) {
         if (subscribed.compareAndSet(false, true)) {
             this.gate = gate;
-            source.materialize().subscribe(this);
+            source.materialize().unsafeSubscribe(this);
         } else {
             throw new IllegalStateException("Can only be subscribed to once.");
         }
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index fdd8db73ed..916fca423a 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -72,7 +72,7 @@ public static <T> BlockingObservable<T> from(final Observable<? extends T> o) {
      * "Guideline 6.4: Protect calls to user code from within an operator"
      */
     private Subscription protectivelyWrapAndSubscribe(Subscriber<? super T> observer) {
-        return o.subscribe(new SafeSubscriber<T>(observer));
+        return o.unsafeSubscribe(new SafeSubscriber<T>(observer));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
index 13b36edd82..9e3984e39c 100644
--- a/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/GroupedObservable.java
@@ -37,7 +37,7 @@ public static <K, T> GroupedObservable<K, T> from(K key, final Observable<T> o)
 
             @Override
             public void call(Subscriber<? super T> s) {
-                o.subscribe(s);
+                o.unsafeSubscribe(s);
             }
         });
     }
diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index d26f84debc..f5679959d2 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -91,7 +91,7 @@ public void onNext(T t) {
      * It will then immediately swap itself out for the actual (after a single notification), but since this is now
      * being done on the same producer thread no further buffering will occur.
      */
-    private static class PassThruObserver<T> implements Observer<T> {
+    private static class PassThruObserver<T> extends Subscriber<T> {
 
         private final Observer<? super T> actual;
         // this assumes single threaded synchronous notifications (the Rx contract for a single Observer)
@@ -133,7 +133,7 @@ private void drainIfNeededAndSwitchToActual() {
 
     }
 
-    private static class BufferedObserver<T> implements Observer<T> {
+    private static class BufferedObserver<T> extends Subscriber<T> {
         private final ConcurrentLinkedQueue<Object> buffer = new ConcurrentLinkedQueue<Object>();
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 74fea62687..46e1ea0846 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -28,10 +28,12 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.functions.Func0;
 import rx.functions.Func1;
+import rx.subscriptions.CompositeSubscription;
 
 /**
  * The base class for operations that break observables into "chunks". Currently buffers and windows.
@@ -408,7 +410,7 @@ public void pushValue(T value) {
      *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
      *            <C> The type of object being tracked by the {@link Chunk}
      */
-    protected static class ChunkObserver<T, C> implements Observer<T> {
+    protected static class ChunkObserver<T, C> extends Subscriber<T> {
 
         private final Chunks<T, C> chunks;
         private final Observer<? super C> observer;
@@ -492,12 +494,24 @@ public ObservableBasedSingleChunkCreator(NonOverlappingChunks<T, C> chunks, Func
 
         private void listenForChunkEnd() {
             Observable<? extends TClosing> closingObservable = chunkClosingSelector.call();
-            closingObservable.subscribe(new Action1<TClosing>() {
+            closingObservable.unsafeSubscribe(new Subscriber<TClosing>() {
+
+                @Override
+                public void onCompleted() {
+                    
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    
+                }
+
                 @Override
-                public void call(TClosing closing) {
+                public void onNext(TClosing t) {
                     chunks.emitAndReplaceChunk();
-                    listenForChunkEnd();
+                    listenForChunkEnd();                    
                 }
+                
             });
         }
 
@@ -524,23 +538,47 @@ public void stop() {
      */
     protected static class ObservableBasedMultiChunkCreator<T, C, TOpening, TClosing> implements ChunkCreator {
 
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
+        private final CompositeSubscription subscription = new CompositeSubscription();
 
         public ObservableBasedMultiChunkCreator(final OverlappingChunks<T, C> chunks, Observable<? extends TOpening> openings, final Func1<? super TOpening, ? extends Observable<? extends TClosing>> chunkClosingSelector) {
-            subscription.wrap(openings.subscribe(new Action1<TOpening>() {
+            openings.unsafeSubscribe(new Subscriber<TOpening>(subscription) {
+
+                @Override
+                public void onCompleted() {
+                    
+                }
+
                 @Override
-                public void call(TOpening opening) {
+                public void onError(Throwable e) {
+                    
+                }
+
+                @Override
+                public void onNext(TOpening opening) {
                     final Chunk<T, C> chunk = chunks.createChunk();
                     Observable<? extends TClosing> closingObservable = chunkClosingSelector.call(opening);
 
-                    closingObservable.subscribe(new Action1<TClosing>() {
+                    closingObservable.unsafeSubscribe(new Subscriber<TClosing>() {
+
                         @Override
-                        public void call(TClosing closing) {
-                            chunks.emitChunk(chunk);
+                        public void onCompleted() {
+                            
                         }
-                    });
+
+                        @Override
+                        public void onError(Throwable e) {
+                            
+                        }
+
+                        @Override
+                        public void onNext(TClosing t) {
+                            chunks.emitChunk(chunk);                            
+                        }
+                        
+                    });                    
                 }
-            }));
+                
+            });
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/NotificationLite.java b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
index 54e807855e..f4779916fc 100644
--- a/rxjava-core/src/main/java/rx/operators/NotificationLite.java
+++ b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
@@ -1,6 +1,5 @@
 package rx.operators;
 
-import java.io.ObjectStreamException;
 import java.io.Serializable;
 
 import rx.Notification;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAll.java b/rxjava-core/src/main/java/rx/operators/OperationAll.java
index 681486f13c..9ad2d942ad 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAll.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAll.java
@@ -20,6 +20,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 
@@ -39,8 +40,6 @@ private static class AllObservable<T> implements OnSubscribeFunc<Boolean> {
         private final Observable<? extends T> sequence;
         private final Func1<? super T, Boolean> predicate;
 
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
         private AllObservable(Observable<? extends T> sequence, Func1<? super T, Boolean> predicate) {
             this.sequence = sequence;
             this.predicate = predicate;
@@ -48,11 +47,11 @@ private AllObservable(Observable<? extends T> sequence, Func1<? super T, Boolean
 
         @Override
         public Subscription onSubscribe(final Observer<? super Boolean> observer) {
-            return subscription.wrap(sequence.subscribe(new AllObserver(observer)));
+            return sequence.unsafeSubscribe(new AllObserver(observer));
 
         }
 
-        private class AllObserver implements Observer<T> {
+        private class AllObserver extends Subscriber<T> {
             private final Observer<? super Boolean> underlying;
 
             private final AtomicBoolean status = new AtomicBoolean(true);
@@ -82,7 +81,7 @@ public void onNext(T args) {
                 if (changed && !result) {
                     underlying.onNext(false);
                     underlying.onCompleted();
-                    subscription.unsubscribe();
+                    unsubscribe();
                 }
             }
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAny.java b/rxjava-core/src/main/java/rx/operators/OperationAny.java
index 117e1a5437..b64bf419c7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAny.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAny.java
@@ -15,13 +15,14 @@
  */
 package rx.operators;
 
-import static rx.functions.Functions.*;
+import static rx.functions.Functions.alwaysTrue;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 
@@ -81,7 +82,7 @@ private Any(Observable<? extends T> source, Func1<? super T, Boolean> predicate,
         @Override
         public Subscription onSubscribe(final Observer<? super Boolean> observer) {
             final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(source.subscribe(new Observer<T>() {
+            return subscription.wrap(source.unsafeSubscribe(new Subscriber<T>() {
 
                 private final AtomicBoolean hasEmitted = new AtomicBoolean(false);
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
index b266345984..d5c907ff5d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
@@ -19,6 +19,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.observers.Subscribers;
 
 /**
  * Hides the identity of another observable.
@@ -34,7 +35,7 @@ public OperationAsObservable(Observable<? extends T> source) {
     }
 
     @Override
-    public Subscription onSubscribe(Observer<? super T> t1) {
-        return source.subscribe(t1);
+    public Subscription onSubscribe(final Observer<? super T> t1) {
+        return source.unsafeSubscribe(Subscribers.from(t1));
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAverage.java b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
index 1017df4524..0b9c5e14e9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAverage.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -124,11 +125,11 @@ public AverageIntegerExtractor(Observable<? extends T> source, Func1<? super T,
 
         @Override
         public Subscription onSubscribe(Observer<? super Integer> t1) {
-            return source.subscribe(new AverageObserver(t1));
+            return source.unsafeSubscribe(new AverageObserver(t1));
         }
 
         /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
+        private final class AverageObserver extends Subscriber<T> {
             final Observer<? super Integer> observer;
             int sum;
             int count;
@@ -184,11 +185,11 @@ public AverageLongExtractor(Observable<? extends T> source, Func1<? super T, Lon
 
         @Override
         public Subscription onSubscribe(Observer<? super Long> t1) {
-            return source.subscribe(new AverageObserver(t1));
+            return source.unsafeSubscribe(new AverageObserver(t1));
         }
 
         /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
+        private final class AverageObserver extends Subscriber<T> {
             final Observer<? super Long> observer;
             long sum;
             int count;
@@ -244,11 +245,11 @@ public AverageFloatExtractor(Observable<? extends T> source, Func1<? super T, Fl
 
         @Override
         public Subscription onSubscribe(Observer<? super Float> t1) {
-            return source.subscribe(new AverageObserver(t1));
+            return source.unsafeSubscribe(new AverageObserver(t1));
         }
 
         /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
+        private final class AverageObserver extends Subscriber<T> {
             final Observer<? super Float> observer;
             float sum;
             int count;
@@ -304,11 +305,11 @@ public AverageDoubleExtractor(Observable<? extends T> source, Func1<? super T, D
 
         @Override
         public Subscription onSubscribe(Observer<? super Double> t1) {
-            return source.subscribe(new AverageObserver(t1));
+            return source.unsafeSubscribe(new AverageObserver(t1));
         }
 
         /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
+        private final class AverageObserver extends Subscriber<T> {
             final Observer<? super Double> observer;
             double sum;
             int count;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index d4181504ba..eaad7ca545 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -24,6 +24,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -71,7 +72,7 @@ public Subscription onSubscribe(Observer<? super List<T>> observer) {
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, List<T>, TClosing>(buffers, bufferClosingSelector);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
+                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
             }
         };
     }
@@ -111,7 +112,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, List<T>, TOpening, TClosing>(buffers, bufferOpenings, bufferClosingSelector);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
+                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
             }
         };
     }
@@ -170,7 +171,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 ChunkCreator creator = new SkippingChunkCreator<T, List<T>>(chunks, skip);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator)));
+                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator)));
             }
         };
     }
@@ -229,7 +230,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timespan, unit, scheduler);
                 return new CompositeSubscription(
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
+                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
             }
         };
     }
@@ -295,7 +296,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 return new CompositeSubscription(
                         chunks,
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator)));
+                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(chunks, observer, creator)));
             }
         };
     }
@@ -361,7 +362,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
                 return new CompositeSubscription(
                         buffers,
                         new ChunkToSubscription(creator),
-                        source.subscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
+                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
             }
         };
     }
@@ -460,8 +461,8 @@ public Subscription onSubscribe(Observer<? super List<T>> t1) {
             CompositeSubscription csub = new CompositeSubscription();
 
             SourceObserver<T> so = new SourceObserver<T>(t1, initialCapacity, csub);
-            csub.add(source.subscribe(so));
-            csub.add(boundary.subscribe(new BoundaryObserver<B>(so)));
+            csub.add(source.unsafeSubscribe(so));
+            csub.add(boundary.unsafeSubscribe(new BoundaryObserver<B>(so)));
 
             return csub;
         }
@@ -469,7 +470,7 @@ public Subscription onSubscribe(Observer<? super List<T>> t1) {
         /**
          * Observes the source.
          */
-        private static final class SourceObserver<T> implements Observer<T> {
+        private static final class SourceObserver<T> extends Subscriber<T> {
             final Observer<? super List<T>> observer;
             /** The buffer, if null, that indicates a terminal state. */
             List<T> buffer;
@@ -539,7 +540,7 @@ void emitAndComplete() {
         /**
          * Observes the boundary.
          */
-        private static final class BoundaryObserver<T> implements Observer<T> {
+        private static final class BoundaryObserver<T> extends Subscriber<T> {
             final SourceObserver so;
 
             public BoundaryObserver(SourceObserver so) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCache.java b/rxjava-core/src/main/java/rx/operators/OperationCache.java
index eb10bc9ab6..dbb15354f8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCache.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCache.java
@@ -21,6 +21,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscription;
+import rx.observers.Subscribers;
 import rx.subjects.ReplaySubject;
 
 /**
@@ -48,7 +49,7 @@ public static <T> OnSubscribeFunc<T> cache(final Observable<? extends T> source)
             public Subscription onSubscribe(Observer<? super T> observer) {
                 if (subscribed.compareAndSet(false, true)) {
                     // subscribe to the source once
-                    source.subscribe(cache);
+                    source.unsafeSubscribe(Subscribers.from(cache));
                     /*
                      * Note that we will never unsubscribe from 'source' as we want to receive and cache all of its values.
                      * 
@@ -56,7 +57,7 @@ public Subscription onSubscribe(Observer<? super T> observer) {
                      */
                 }
 
-                return cache.subscribe(observer);
+                return cache.unsafeSubscribe(Subscribers.from(observer));
             }
 
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
index b423045c60..5296b31ff9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
@@ -25,6 +25,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func2;
 import rx.functions.Func3;
@@ -36,6 +37,7 @@
 import rx.functions.Func9;
 import rx.functions.FuncN;
 import rx.functions.Functions;
+import rx.observers.Subscribers;
 import rx.subscriptions.CompositeSubscription;
 
 /**
@@ -275,7 +277,7 @@ public void completed(int index) {
         /**
          * Observes a specific source and communicates with the collector.
          */
-        final class SourceObserver implements Observer<T> {
+        final class SourceObserver extends Subscriber<T> {
             final SafeObservableSubscription self;
             final Collector collector;
             final int index;
@@ -308,7 +310,7 @@ public void onCompleted() {
 
             /** Connect to the source. */
             void connect() {
-                self.wrap(source.subscribe(this));
+                self.wrap(source.unsafeSubscribe(Subscribers.from(this)));
                 source = null;
             }
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationConcat.java b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
index 6ab68f27a2..8c39379a3e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationConcat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
@@ -22,8 +22,10 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
+import rx.observers.Subscribers;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -104,20 +106,20 @@ public void onCompleted() {
                         } else {
                             // Continue on to the next sequence
                             innerSubscription = new SafeObservableSubscription();
-                            innerSubscription.wrap(nextSequences.poll().subscribe(this));
+                            innerSubscription.wrap(nextSequences.poll().unsafeSubscribe(Subscribers.from(this)));
                         }
                     }
                 }
             };
 
-            outerSubscription.wrap(sequences.subscribe(new Observer<Observable<? extends T>>() {
+            outerSubscription.wrap(sequences.unsafeSubscribe(new Subscriber<Observable<? extends T>>() {
                 @Override
                 public void onNext(Observable<? extends T> nextSequence) {
                     synchronized (nextSequences) {
                         if (innerSubscription == null) {
                             // We are currently not subscribed to any sequence
                             innerSubscription = new SafeObservableSubscription();
-                            innerSubscription.wrap(nextSequence.subscribe(reusableObserver));
+                            innerSubscription.wrap(nextSequence.unsafeSubscribe(Subscribers.from(reusableObserver)));
                         } else {
                             // Put this sequence at the end of the queue
                             nextSequences.add(nextSequence);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index e970176c8b..48c502d0b5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -23,11 +23,11 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.observers.SerializedObserver;
-import rx.observers.SynchronizedObserver;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
@@ -96,11 +96,11 @@ public Debounce(Observable<T> items, long timeout, TimeUnit unit, Scheduler sche
 
         @Override
         public Subscription onSubscribe(Observer<? super T> observer) {
-            return items.subscribe(new DebounceObserver<T>(observer, timeout, unit, scheduler));
+            return items.unsafeSubscribe(new DebounceObserver<T>(observer, timeout, unit, scheduler));
         }
     }
 
-    private static class DebounceObserver<T> implements Observer<T> {
+    private static class DebounceObserver<T> extends Subscriber<T> {
 
         private final Observer<? super T> observer;
         private final long timeout;
@@ -183,13 +183,13 @@ public DebounceSelector(Observable<? extends T> source, Func1<? super T, ? exten
         public Subscription onSubscribe(Observer<? super T> t1) {
             CompositeSubscription csub = new CompositeSubscription();
 
-            csub.add(source.subscribe(new SourceObserver<T, U>(t1, debounceSelector, csub)));
+            csub.add(source.unsafeSubscribe(new SourceObserver<T, U>(t1, debounceSelector, csub)));
 
             return csub;
         }
 
         /** Observe the source. */
-        private static final class SourceObserver<T, U> implements Observer<T> {
+        private static final class SourceObserver<T, U> extends Subscriber<T> {
             final Observer<? super T> observer;
             final Func1<? super T, ? extends Observable<U>> debounceSelector;
             final CompositeSubscription cancel;
@@ -232,7 +232,7 @@ public void onNext(T args) {
                 SerialSubscription osub = new SerialSubscription();
                 ssub.set(osub);
 
-                osub.set(o.subscribe(new DebounceObserver<T, U>(this, osub, args, currentIndex)));
+                osub.set(o.unsafeSubscribe(new DebounceObserver<T, U>(this, osub, args, currentIndex)));
             }
 
             @Override
@@ -277,7 +277,7 @@ public void onCompleted() {
         /**
          * The debounce observer.
          */
-        private static final class DebounceObserver<T, U> implements Observer<U> {
+        private static final class DebounceObserver<T, U> extends Subscriber<U> {
             final SourceObserver<T, U> parent;
             final Subscription cancel;
             final T value;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java b/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
index 924a508500..6f08f831f2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 
 /**
@@ -56,7 +57,7 @@ private DefaultIfEmpty(Observable<? extends T> source, T defaultValue) {
         @Override
         public Subscription onSubscribe(final Observer<? super T> observer) {
             final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(source.subscribe(new Observer<T>() {
+            return subscription.wrap(source.unsafeSubscribe(new Subscriber<T>() {
 
                 private volatile boolean hasEmitted = false;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefer.java b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
index 95835b6b79..734f6bbf19 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDefer.java
@@ -20,6 +20,7 @@
 import rx.Observer;
 import rx.Subscription;
 import rx.functions.Func0;
+import rx.observers.Subscribers;
 
 /**
  * Do not create the Observable until an Observer subscribes; create a fresh Observable on each
@@ -39,7 +40,7 @@ public static <T> OnSubscribeFunc<T> defer(final Func0<? extends Observable<? ex
             @Override
             public Subscription onSubscribe(Observer<? super T> observer) {
                 Observable<? extends T> obs = observableFactory.call();
-                return obs.subscribe(observer);
+                return obs.unsafeSubscribe(Subscribers.from(observer));
             }
         };
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index 56605429d8..b996197a54 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -22,11 +22,13 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
+import rx.observers.Subscribers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
 import rx.subscriptions.Subscriptions;
@@ -79,7 +81,7 @@ public Subscription onSubscribe(final Observer<? super T> t1) {
                 @Override
                 public void call(Inner inner) {
                     if (!ssub.isUnsubscribed()) {
-                        ssub.set(source.subscribe(t1));
+                        ssub.set(source.unsafeSubscribe(Subscribers.from(t1)));
                     }
                 }
             }, time, unit));
@@ -129,7 +131,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
             csub.add(sosub);
             SourceObserver<T, V> so = new SourceObserver<T, V>(t1, itemDelay, csub, sosub);
             if (subscriptionDelay == null) {
-                sosub.set(source.subscribe(so));
+                sosub.set(source.unsafeSubscribe(so));
             } else {
                 Observable<U> subscriptionSource;
                 try {
@@ -140,14 +142,14 @@ public Subscription onSubscribe(Observer<? super T> t1) {
                 }
                 SerialSubscription ssub = new SerialSubscription();
                 csub.add(ssub);
-                ssub.set(subscriptionSource.subscribe(new SubscribeDelay<T, U, V>(source, so, csub, ssub)));
+                ssub.set(subscriptionSource.unsafeSubscribe(new SubscribeDelay<T, U, V>(source, so, csub, ssub)));
             }
 
             return csub;
         }
 
         /** Subscribe delay observer. */
-        private static final class SubscribeDelay<T, U, V> implements Observer<U> {
+        private static final class SubscribeDelay<T, U, V> extends Subscriber<U> {
             final Observable<? extends T> source;
             final SourceObserver<T, V> so;
             final CompositeSubscription csub;
@@ -182,12 +184,12 @@ public void onError(Throwable e) {
             public void onCompleted() {
                 subscribed = true;
                 csub.remove(self);
-                so.self.set(source.subscribe(so));
+                so.self.set(source.unsafeSubscribe(so));
             }
         }
 
         /** The source observer. */
-        private static final class SourceObserver<T, U> implements Observer<T> {
+        private static final class SourceObserver<T, U> extends Subscriber<T> {
             final Observer<? super T> observer;
             final Func1<? super T, ? extends Observable<U>> itemDelay;
             final CompositeSubscription csub;
@@ -224,7 +226,7 @@ public void onNext(T args) {
 
                 SerialSubscription ssub = new SerialSubscription();
                 csub.add(ssub);
-                ssub.set(delayer.subscribe(new DelayObserver<T, U>(args, this, ssub)));
+                ssub.set(delayer.unsafeSubscribe(new DelayObserver<T, U>(args, this, ssub)));
             }
 
             @Override
@@ -275,7 +277,7 @@ boolean checkDone() {
         /**
          * Delay observer.
          */
-        private static final class DelayObserver<T, U> implements Observer<U> {
+        private static final class DelayObserver<T, U> extends Subscriber<U> {
             final T value;
             final SourceObserver<T, U> parent;
             final Subscription token;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
index 2d937aa47a..390a445d3e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
@@ -19,6 +19,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 
 /**
@@ -54,7 +55,7 @@ public DematerializeObservable(Observable<? extends Notification<? extends T>> s
 
         @Override
         public Subscription onSubscribe(final Observer<? super T> observer) {
-            return sequence.subscribe(new Observer<Notification<? extends T>>() {
+            return sequence.unsafeSubscribe(new Subscriber<Notification<? extends T>>() {
                 @Override
                 public void onCompleted() {
                     observer.onCompleted();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java b/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
index 6c794c019a..9b0782d4a0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
@@ -24,6 +24,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Func1;
@@ -97,7 +98,7 @@ private Distinct(Observable<? extends T> source, Func1<? super T, ? extends U> k
 
         @Override
         public Subscription onSubscribe(final Observer<? super T> observer) {
-            final Subscription sourceSub = source.subscribe(new Observer<T>() {
+            final Subscription sourceSub = source.unsafeSubscribe(new Subscriber<T>() {
                 private final Set<U> emittedKeys = new HashSet<U>();
 
                 @Override
@@ -142,7 +143,7 @@ private DistinctWithComparator(Observable<? extends T> source, Func1<? super T,
 
         @Override
         public Subscription onSubscribe(final Observer<? super T> observer) {
-            final Subscription sourceSub = source.subscribe(new Observer<T>() {
+            final Subscription sourceSub = source.unsafeSubscribe(new Subscriber<T>() {
 
                 // due to the totally arbitrary equality comparator, we can't use anything more efficient than lists here 
                 private final List<U> emittedKeys = new ArrayList<U>();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java b/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
index 4760109c10..645bb95324 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
@@ -20,6 +20,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Func1;
@@ -108,7 +109,7 @@ private DistinctUntilChanged(Observable<? extends T> source, Func1<? super T, ?
 
         @Override
         public Subscription onSubscribe(final Observer<? super T> observer) {
-            final Subscription sourceSub = source.subscribe(new Observer<T>() {
+            final Subscription sourceSub = source.unsafeSubscribe(new Subscriber<T>() {
                 private U lastEmittedKey;
                 private boolean hasEmitted;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFinally.java b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
index a54a2586f8..f16b4651ab 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFinally.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 
@@ -68,10 +69,10 @@ private static class Finally<T> implements OnSubscribeFunc<T> {
         }
 
         public Subscription onSubscribe(Observer<? super T> observer) {
-            return sequence.subscribe(new FinallyObserver(observer));
+            return sequence.unsafeSubscribe(new FinallyObserver(observer));
         }
 
-        private class FinallyObserver implements Observer<T> {
+        private class FinallyObserver extends Subscriber<T> {
             private final Observer<? super T> observer;
 
             FinallyObserver(Observer<? super T> observer) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
index 6dd4a0a4ec..6d2606b2f9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
@@ -20,6 +20,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -102,13 +103,13 @@ public FlatMapPairSelector(Observable<? extends T> source, Func1<? super T, ? ex
         public Subscription onSubscribe(Observer<? super R> t1) {
             CompositeSubscription csub = new CompositeSubscription();
 
-            csub.add(source.subscribe(new SourceObserver<T, U, R>(t1, collectionSelector, resultSelector, csub)));
+            csub.add(source.unsafeSubscribe(new SourceObserver<T, U, R>(t1, collectionSelector, resultSelector, csub)));
 
             return csub;
         }
 
         /** Observes the source, starts the collections and projects the result. */
-        private static final class SourceObserver<T, U, R> implements Observer<T> {
+        private static final class SourceObserver<T, U, R> extends Subscriber<T> {
             final Observer<? super R> observer;
             final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
             final Func2<? super T, ? super U, ? extends R> resultSelector;
@@ -141,7 +142,7 @@ public void onNext(T args) {
                 csub.add(ssub);
                 wip.incrementAndGet();
 
-                ssub.set(coll.subscribe(new CollectionObserver<T, U, R>(this, args, ssub)));
+                ssub.set(coll.unsafeSubscribe(new CollectionObserver<T, U, R>(this, args, ssub)));
             }
 
             @Override
@@ -193,7 +194,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<T, U, R> implements Observer<U> {
+        private static final class CollectionObserver<T, U, R> extends Subscriber<U> {
             final SourceObserver<T, U, R> so;
             final Subscription cancel;
             final T value;
@@ -258,7 +259,7 @@ public FlatMapTransform(Observable<? extends T> source, Func1<? super T, ? exten
         public Subscription onSubscribe(Observer<? super R> t1) {
             CompositeSubscription csub = new CompositeSubscription();
 
-            csub.add(source.subscribe(new SourceObserver<T, R>(t1, onNext, onError, onCompleted, csub)));
+            csub.add(source.unsafeSubscribe(new SourceObserver<T, R>(t1, onNext, onError, onCompleted, csub)));
 
             return csub;
         }
@@ -271,7 +272,7 @@ public Subscription onSubscribe(Observer<? super R> t1) {
          * @param <R>
          *            the result value type
          */
-        private static final class SourceObserver<T, R> implements Observer<T> {
+        private static final class SourceObserver<T, R> extends Subscriber<T> {
             final Observer<? super R> observer;
             final Func1<? super T, ? extends Observable<? extends R>> onNext;
             final Func1<? super Throwable, ? extends Observable<? extends R>> onError;
@@ -345,7 +346,7 @@ void subscribeInner(Observable<? extends R> o) {
                 wip.incrementAndGet();
                 csub.add(ssub);
 
-                ssub.set(o.subscribe(new CollectionObserver<T, R>(this, ssub)));
+                ssub.set(o.unsafeSubscribe(new CollectionObserver<T, R>(this, ssub)));
             }
 
             void finish() {
@@ -359,7 +360,7 @@ void finish() {
         }
 
         /** Observes the collections. */
-        private static final class CollectionObserver<T, R> implements Observer<R> {
+        private static final class CollectionObserver<T, R> extends Subscriber<R> {
             final SourceObserver<T, R> parent;
             final Subscription cancel;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
index ab37d3a014..4875bfd9c4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
@@ -64,7 +64,7 @@ public Subscription onSubscribe(Observer<? super GroupedObservable<TKey, TResult
     }
 
     /** The source value sink and group manager. */
-    class ResultSink implements Observer<TSource> {
+    class ResultSink extends Subscriber<TSource> {
         /** Guarded by gate. */
         protected final Observer<? super GroupedObservable<TKey, TResult>> observer;
         protected final Subscription cancel;
@@ -83,7 +83,7 @@ public Subscription run() {
             SerialSubscription toSource = new SerialSubscription();
             group.add(toSource);
 
-            toSource.set(source.subscribe(this));
+            toSource.set(source.unsafeSubscribe(this));
 
             return group;
         }
@@ -128,7 +128,7 @@ public void onNext(TSource args) {
                 group.add(durationHandle);
 
                 DurationObserver durationObserver = new DurationObserver(key, durationHandle);
-                durationHandle.set(duration.subscribe(durationObserver));
+                durationHandle.set(duration.unsafeSubscribe(durationObserver));
 
             }
 
@@ -181,7 +181,7 @@ public void expire(TKey key, Subscription handle) {
         }
 
         /** Observe the completion of a group. */
-        class DurationObserver implements Observer<TDuration> {
+        class DurationObserver extends Subscriber<TDuration> {
             final TKey key;
             final Subscription handle;
 
@@ -209,7 +209,7 @@ public void onCompleted() {
     }
 
     /** A grouped observable with subject-like behavior. */
-    public static class GroupSubject<K, V> implements Observer<V> {
+    public static class GroupSubject<K, V> extends Subscriber<V> {
         protected final Subject<V, V> publish;
         private final K key;
 
@@ -222,7 +222,7 @@ public GroupedObservable<K, V> toObservable() {
             return new GroupedObservable<K, V>(key, new OnSubscribe<V>() {
                 @Override
                 public void call(Subscriber<? super V> o) {
-                    publish.subscribe(o);
+                    publish.unsafeSubscribe(o);
                 }
             });
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
index 33f5db3848..adf69e3deb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
@@ -23,6 +23,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -90,8 +91,8 @@ public void init() {
             group.add(s1);
             group.add(s2);
 
-            s1.setSubscription(left.subscribe(new LeftObserver(s1)));
-            s2.setSubscription(right.subscribe(new RightObserver(s2)));
+            s1.setSubscription(left.unsafeSubscribe(new LeftObserver(s1)));
+            s2.setSubscription(right.unsafeSubscribe(new RightObserver(s2)));
 
         }
 
@@ -115,7 +116,7 @@ void groupsOnCompleted() {
         }
 
         /** Observe the left source. */
-        class LeftObserver implements Observer<T1> {
+        class LeftObserver extends Subscriber<T1> {
             final Subscription tosource;
 
             public LeftObserver(Subscription tosource) {
@@ -138,7 +139,7 @@ public void onNext(T1 args) {
 
                     SerialSubscription sduration = new SerialSubscription();
                     group.add(sduration);
-                    sduration.setSubscription(duration.subscribe(new LeftDurationObserver(id, sduration, subj)));
+                    sduration.setSubscription(duration.unsafeSubscribe(new LeftDurationObserver(id, sduration, subj)));
 
                     R result = resultSelector.call(args, window);
 
@@ -180,7 +181,7 @@ public void onError(Throwable e) {
         }
 
         /** Observe the right source. */
-        class RightObserver implements Observer<T2> {
+        class RightObserver extends Subscriber<T2> {
             final Subscription tosource;
 
             public RightObserver(Subscription tosource) {
@@ -199,7 +200,7 @@ public void onNext(T2 args) {
 
                     SerialSubscription sduration = new SerialSubscription();
                     group.add(sduration);
-                    sduration.setSubscription(duration.subscribe(new RightDurationObserver(id, sduration)));
+                    sduration.setSubscription(duration.unsafeSubscribe(new RightDurationObserver(id, sduration)));
 
                     synchronized (guard) {
                         for (Observer<T2> o : leftMap.values()) {
@@ -238,7 +239,7 @@ public void onError(Throwable e) {
         }
 
         /** Observe left duration and apply termination. */
-        class LeftDurationObserver implements Observer<D1> {
+        class LeftDurationObserver extends Subscriber<D1> {
             final int id;
             final Subscription sduration;
             final Observer<T2> gr;
@@ -274,7 +275,7 @@ public void onNext(D1 args) {
         }
 
         /** Observe right duration and apply termination. */
-        class RightDurationObserver implements Observer<D2> {
+        class RightDurationObserver extends Subscriber<D2> {
             final int id;
             final Subscription sduration;
 
@@ -326,12 +327,12 @@ public Subscription onSubscribe(Observer<? super T> t1) {
             CompositeSubscription cs = new CompositeSubscription();
             cs.add(refCount.getSubscription());
             WindowObserver wo = new WindowObserver(t1, cs);
-            cs.add(underlying.subscribe(wo));
+            cs.add(underlying.unsafeSubscribe(wo));
             return cs;
         }
 
         /** Observe activities on the window. */
-        class WindowObserver implements Observer<T> {
+        class WindowObserver extends Subscriber<T> {
             final Observer<? super T> observer;
             final Subscription self;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
index 629ba9c708..779d8716d0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
@@ -21,6 +21,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -83,14 +84,14 @@ public Subscription run() {
             group.add(leftCancel);
             group.add(rightCancel);
 
-            leftCancel.setSubscription(left.subscribe(new LeftObserver(leftCancel)));
-            rightCancel.setSubscription(right.subscribe(new RightObserver(rightCancel)));
+            leftCancel.setSubscription(left.unsafeSubscribe(new LeftObserver(leftCancel)));
+            rightCancel.setSubscription(right.unsafeSubscribe(new RightObserver(rightCancel)));
 
             return group;
         }
 
         /** Observes the left values. */
-        class LeftObserver implements Observer<TLeft> {
+        class LeftObserver extends Subscriber<TLeft> {
             final Subscription self;
 
             public LeftObserver(Subscription self) {
@@ -128,7 +129,7 @@ public void onNext(TLeft args) {
                     return;
                 }
 
-                md.setSubscription(duration.subscribe(new LeftDurationObserver(id, md)));
+                md.setSubscription(duration.unsafeSubscribe(new LeftDurationObserver(id, md)));
 
                 synchronized (gate) {
                     for (Map.Entry<Integer, TRight> entry : rightMap.entrySet()) {
@@ -170,7 +171,7 @@ public void onCompleted() {
             }
 
             /** Observes the left duration. */
-            class LeftDurationObserver implements Observer<TLeftDuration> {
+            class LeftDurationObserver extends Subscriber<TLeftDuration> {
                 final int id;
                 final Subscription handle;
 
@@ -198,7 +199,7 @@ public void onCompleted() {
         }
 
         /** Observes the right values. */
-        class RightObserver implements Observer<TRight> {
+        class RightObserver extends Subscriber<TRight> {
             final Subscription self;
 
             public RightObserver(Subscription self) {
@@ -235,7 +236,7 @@ public void onNext(TRight args) {
                     return;
                 }
 
-                md.setSubscription(duration.subscribe(new RightDurationObserver(id, md)));
+                md.setSubscription(duration.unsafeSubscribe(new RightDurationObserver(id, md)));
 
                 synchronized (gate) {
                     for (Map.Entry<Integer, TLeft> entry : leftMap.entrySet()) {
@@ -277,7 +278,7 @@ public void onCompleted() {
             }
 
             /** Observe the right duration. */
-            class RightDurationObserver implements Observer<TRightDuration> {
+            class RightDurationObserver extends Subscriber<TRightDuration> {
                 final int id;
                 final Subscription handle;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
index 1b55cf819c..2ee716af46 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
@@ -32,6 +32,7 @@
 import rx.joins.Pattern1;
 import rx.joins.Pattern2;
 import rx.joins.Plan0;
+import rx.observers.Subscribers;
 import rx.subscriptions.CompositeSubscription;
 
 /**
@@ -121,7 +122,7 @@ public void call(ActivePlan0 activePlan) {
                         }));
                     }
                 } catch (Throwable t) {
-                    return Observable.<R> error(t).subscribe(t1);
+                    return Observable.<R> error(t).unsafeSubscribe(Subscribers.from(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 4fda664f93..d5e0da4f77 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationLatest.java
@@ -22,7 +22,7 @@
 
 import rx.Notification;
 import rx.Observable;
-import rx.Observer;
+import rx.Subscriber;
 import rx.exceptions.Exceptions;
 
 /**
@@ -41,14 +41,14 @@ public static <T> Iterable<T> latest(final Observable<? extends T> source) {
             @Override
             public Iterator<T> iterator() {
                 LatestObserverIterator<T> lio = new LatestObserverIterator<T>();
-                source.materialize().subscribe(lio);
+                source.materialize().unsafeSubscribe(lio);
                 return lio;
             }
         };
     }
 
     /** Observer of source, iterator for output. */
-    static final class LatestObserverIterator<T> implements Observer<Notification<? extends T>>, Iterator<T> {
+    static final class LatestObserverIterator<T> extends Subscriber<Notification<? extends T>> implements Iterator<T> {
         final Semaphore notify = new Semaphore(0);
         // observer's notification
         final AtomicReference<Notification<? extends T>> reference = new AtomicReference<Notification<? extends T>>();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java b/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
index 66356e1db0..7cf3ca5ee4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
@@ -19,6 +19,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 
 /**
@@ -54,7 +55,7 @@ public MaterializeObservable(Observable<? extends T> sequence) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Notification<T>> observer) {
-            return sequence.subscribe(new Observer<T>() {
+            return sequence.unsafeSubscribe(new Subscriber<T>() {
 
                 @Override
                 public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
index 4c97223a87..d5eacf649a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
@@ -23,6 +23,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
 import rx.observers.SerializedObserver;
@@ -146,7 +147,7 @@ public Subscription onSubscribe(Observer<? super T> actualObserver) {
             /**
              * Subscribe to the parent Observable to get to the children Observables
              */
-            completeSubscription.add(sequences.subscribe(new ParentObserver(synchronizedObserver)));
+            completeSubscription.add(sequences.unsafeSubscribe(new ParentObserver(synchronizedObserver)));
 
             /* return our subscription to allow unsubscribing */
             return completeSubscription;
@@ -190,7 +191,7 @@ public boolean isUnsubscribed() {
          * 
          * @param <T>
          */
-        private class ParentObserver implements Observer<Observable<? extends T>> {
+        private class ParentObserver extends Subscriber<Observable<? extends T>> {
             private final Observer<? super T> actualObserver;
 
             public ParentObserver(Observer<? super T> actualObserver) {
@@ -246,7 +247,7 @@ public void onNext(Observable<? extends T> childObservable) {
                  */
                 ChildObserver _w = new ChildObserver(actualObserver);
                 childObservers.put(_w, _w);
-                Subscription _subscription = childObservable.subscribe(_w);
+                Subscription _subscription = childObservable.unsafeSubscribe(_w);
                 // remember this Observer and the subscription from it
                 childSubscriptions.put(_w, _subscription);
             }
@@ -256,7 +257,7 @@ public void onNext(Observable<? extends T> childObservable) {
          * Subscribe to each child Observable<T> and forward their sequence of data to the actualObserver
          * 
          */
-        private class ChildObserver implements Observer<T> {
+        private class ChildObserver extends Subscriber<T> {
 
             private final Observer<? super T> actualObserver;
             private volatile boolean finished = false;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java b/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
index d0c296b06d..420e8a5fa0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
@@ -20,6 +20,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.observers.SerializedObserver;
 import rx.subscriptions.CompositeSubscription;
@@ -91,7 +92,7 @@ public Subscription onSubscribe(Observer<? super T> actualObserver) {
             /**
              * Subscribe to the parent Observable to get to the children Observables
              */
-            ourSubscription.add(sequences.subscribe(new ParentObserver(synchronizedObserver)));
+            ourSubscription.add(sequences.unsafeSubscribe(new ParentObserver(synchronizedObserver)));
 
             return subscription;
         }
@@ -101,7 +102,7 @@ public Subscription onSubscribe(Observer<? super T> actualObserver) {
          * 
          * @param <T>
          */
-        private class ParentObserver implements Observer<Observable<? extends T>> {
+        private class ParentObserver extends Subscriber<Observable<? extends T>> {
             private final SerializedObserver<T> serializedObserver;
 
             public ParentObserver(SerializedObserver<T> serializedObserver) {
@@ -149,7 +150,7 @@ public void onNext(Observable<? extends T> childObservable) {
                     }
                 }
                 if (observable != null) {
-                    ourSubscription.add(observable.subscribe(new ChildObserver(
+                    ourSubscription.add(observable.unsafeSubscribe(new ChildObserver(
                             serializedObserver)));
                 }
             }
@@ -159,7 +160,7 @@ public void onNext(Observable<? extends T> childObservable) {
          * Subscribe to each child Observable<T> and forward their sequence of data to the actualObserver
          * 
          */
-        private class ChildObserver implements Observer<T> {
+        private class ChildObserver extends Subscriber<T> {
 
             private final SerializedObserver<T> serializedObserver;
 
@@ -187,7 +188,7 @@ public void onCompleted() {
                     }
                 }
                 if (childObservable != null) {
-                    ourSubscription.add(childObservable.subscribe(this));
+                    ourSubscription.add(childObservable.unsafeSubscribe(this));
                 } else {
                     // No pending observable. Need to check if it's necessary to emit an onCompleted
                     if (isStopped()) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
index 4ae9ae5971..bff9eb7967 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
@@ -20,7 +20,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable;
-import rx.Observer;
+import rx.Subscriber;
 import rx.exceptions.Exceptions;
 
 /**
@@ -39,7 +39,7 @@ public Iterator<T> iterator() {
                 MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue);
                 final MostRecentIterator<T> nextIterator = new MostRecentIterator<T>(mostRecentObserver);
 
-                source.subscribe(mostRecentObserver);
+                source.unsafeSubscribe(mostRecentObserver);
 
                 return nextIterator;
             }
@@ -74,7 +74,7 @@ public void remove() {
         }
     }
 
-    private static class MostRecentObserver<T> implements Observer<T> {
+    private static class MostRecentObserver<T> extends Subscriber<T> {
         private final AtomicBoolean completed = new AtomicBoolean(false);
         private final AtomicReference<T> value;
         private final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
index 5f0803eb1e..f6760ee052 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
@@ -45,7 +45,7 @@ public MulticastConnectableObservable(Observable<? extends T> source, final Subj
             super(new OnSubscribe<R>() {
                 @Override
                 public void call(Subscriber<? super R> observer) {
-                    subject.subscribe(observer);
+                    subject.unsafeSubscribe(observer);
                 }
             });
             this.source = source;
@@ -55,7 +55,7 @@ public void call(Subscriber<? super R> observer) {
         public Subscription connect() {
             synchronized (lock) {
                 if (subscription == null) {
-                    subscription = source.subscribe(new Observer<T>() {
+                    subscription = source.unsafeSubscribe(new Subscriber<T>() {
                         @Override
                         public void onCompleted() {
                             subject.onCompleted();
@@ -138,7 +138,7 @@ public Subscription onSubscribe(Observer<? super TResult> t1) {
 
             CompositeSubscription csub = new CompositeSubscription();
 
-            csub.add(observable.subscribe(new SafeObserver<TResult>(
+            csub.add(observable.unsafeSubscribe(new SafeObserver<TResult>(
                     new SafeObservableSubscription(csub), t1)));
             csub.add(connectable.connect());
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationNext.java b/rxjava-core/src/main/java/rx/operators/OperationNext.java
index a37fba3cd1..70b2ac7cee 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationNext.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationNext.java
@@ -23,7 +23,7 @@
 
 import rx.Notification;
 import rx.Observable;
-import rx.Observer;
+import rx.Subscriber;
 import rx.exceptions.Exceptions;
 
 /**
@@ -40,7 +40,7 @@ public Iterator<T> iterator() {
                 NextObserver<T> nextObserver = new NextObserver<T>();
                 final NextIterator<T> nextIterator = new NextIterator<T>(nextObserver);
 
-                items.materialize().subscribe(nextObserver);
+                items.materialize().unsafeSubscribe(nextObserver);
 
                 return nextIterator;
             }
@@ -133,7 +133,7 @@ public void remove() {
         }
     }
 
-    private static class NextObserver<T> implements Observer<Notification<? extends T>> {
+    private static class NextObserver<T> extends Subscriber<Notification<? extends T>> {
         private final BlockingQueue<Notification<? extends T>> buf = new ArrayBlockingQueue<Notification<? extends T>>(1);
         private final AtomicBoolean waiting = new AtomicBoolean(false);
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
index a69241262a..dd6e662918 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
@@ -20,8 +20,10 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
+import rx.observers.Subscribers;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -66,7 +68,7 @@ public Subscription onSubscribe(final Observer<? super T> observer) {
             final AtomicReference<SafeObservableSubscription> subscriptionRef = new AtomicReference<SafeObservableSubscription>(subscription);
 
             // subscribe to the original Observable and remember the subscription
-            subscription.wrap(originalSequence.subscribe(new Observer<T>() {
+            subscription.wrap(originalSequence.unsafeSubscribe(new Subscriber<T>() {
                 public void onNext(T value) {
                     // forward the successful calls unless resumed
                     if (subscriptionRef.get() == subscription)
@@ -82,7 +84,7 @@ public void onError(Throwable ex) {
                     // check that we have not been unsubscribed and not already resumed before we can process the error
                     if (currentSubscription == subscription) {
                         /* error occurred, so switch subscription to the 'resumeSequence' */
-                        SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.subscribe(observer));
+                        SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.unsafeSubscribe(Subscribers.from(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
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
index de06acf78e..785775f064 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
@@ -21,6 +21,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
 import rx.functions.Action0;
@@ -66,7 +67,7 @@ public Subscription onSubscribe(final Observer<? super T> observer) {
             final AtomicReference<SafeObservableSubscription> subscriptionRef = new AtomicReference<SafeObservableSubscription>(subscription);
 
             // subscribe to the original Observable and remember the subscription
-            subscription.wrap(originalSequence.subscribe(new Observer<T>() {
+            subscription.wrap(originalSequence.unsafeSubscribe(new Subscriber<T>() {
                 public void onNext(T value) {
                     // forward the successful calls
                     observer.onNext(value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
index 26153577b6..4e31ff2d08 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
@@ -20,8 +20,10 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
+import rx.observers.Subscribers;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -68,7 +70,7 @@ public Subscription onSubscribe(final Observer<? super T> observer) {
             final AtomicReference<SafeObservableSubscription> subscriptionRef = new AtomicReference<SafeObservableSubscription>(subscription);
 
             // subscribe to the original Observable and remember the subscription
-            subscription.wrap(originalSequence.subscribe(new Observer<T>() {
+            subscription.wrap(originalSequence.unsafeSubscribe(new Subscriber<T>() {
                 public void onNext(T value) {
                     // forward the successful calls unless resumed
                     if (subscriptionRef.get() == subscription)
@@ -86,7 +88,7 @@ public void onError(Throwable ex) {
                         // check that we have not been unsubscribed and not already resumed before we can process the error
                         if (currentSubscription == subscription) {
                             /* error occurred, so switch subscription to the 'resumeSequence' */
-                            SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.subscribe(observer));
+                            SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.unsafeSubscribe(Subscribers.from(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
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
index ab99ca4628..59bcec2f62 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
@@ -20,6 +20,7 @@
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.observables.ConnectableObservable;
+import rx.observers.Subscribers;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -43,7 +44,7 @@ public RefCount(ConnectableObservable<T> innerConnectableObservable) {
 
         @Override
         public Subscription onSubscribe(Observer<? super T> observer) {
-            final Subscription subscription = innerConnectableObservable.subscribe(observer);
+            final Subscription subscription = innerConnectableObservable.unsafeSubscribe(Subscribers.from(observer));
             synchronized (gate) {
                 if (count++ == 0) {
                     connection = innerConnectableObservable.connect();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
index 3bfcf6beb7..e683feb5b2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationReplay.java
@@ -35,6 +35,7 @@
 import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.functions.Functions;
+import rx.observers.Subscribers;
 import rx.schedulers.Timestamped;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
@@ -151,7 +152,7 @@ public static <T> OnSubscribeFunc<T> subscriberOf(final Observable<T> target) {
         return new OnSubscribeFunc<T>() {
             @Override
             public Subscription onSubscribe(Observer<? super T> t1) {
-                return target.subscribe(t1);
+                return target.unsafeSubscribe(Subscribers.from(t1));
             }
         };
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSample.java b/rxjava-core/src/main/java/rx/operators/OperationSample.java
index 56b5d09c5a..bd199000dc 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSample.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSample.java
@@ -23,6 +23,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.schedulers.Schedulers;
@@ -70,7 +71,7 @@ private Sample(Observable<? extends T> source, long interval, TimeUnit unit, Sch
         @Override
         public Subscription onSubscribe(final Observer<? super T> observer) {
             Observable<Long> clock = Observable.create(OperationInterval.interval(period, unit, scheduler));
-            final Subscription clockSubscription = clock.subscribe(new Observer<Long>() {
+            final Subscription clockSubscription = clock.unsafeSubscribe(new Subscriber<Long>() {
                 @Override
                 public void onCompleted() { /* the clock never completes */
                 }
@@ -87,7 +88,7 @@ public void onNext(Long tick) {
                 }
             });
 
-            final Subscription sourceSubscription = source.subscribe(new Observer<T>() {
+            final Subscription sourceSubscription = source.unsafeSubscribe(new Subscriber<T>() {
                 @Override
                 public void onCompleted() {
                     clockSubscription.unsubscribe();
@@ -137,7 +138,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
         }
 
         /** Observe source values. */
-        class ResultManager implements Observer<T> {
+        class ResultManager extends Subscriber<T> {
             final Observer<? super T> observer;
             final CompositeSubscription cancel;
             T value;
@@ -152,8 +153,8 @@ public ResultManager(Observer<? super T> observer) {
             }
 
             public Subscription init() {
-                cancel.add(source.subscribe(this));
-                cancel.add(sampler.subscribe(new Sampler()));
+                cancel.add(source.unsafeSubscribe(this));
+                cancel.add(sampler.unsafeSubscribe(new Sampler()));
 
                 return cancel;
             }
@@ -189,7 +190,7 @@ public void onCompleted() {
             }
 
             /** Take the latest value, but only once. */
-            class Sampler implements Observer<U> {
+            class Sampler extends Subscriber<U> {
                 @Override
                 public void onNext(U args) {
                     synchronized (guard) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
index 04b4c41d17..22e42ff34a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
@@ -15,7 +15,9 @@
  */
 package rx.operators;
 
-import static rx.Observable.*;
+import static rx.Observable.concat;
+import static rx.Observable.from;
+import static rx.Observable.zip;
 import rx.Notification;
 import rx.Observable;
 import rx.functions.Func1;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSingle.java b/rxjava-core/src/main/java/rx/operators/OperationSingle.java
index 871d565092..7ccfe5cf37 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSingle.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSingle.java
@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 
 /**
@@ -45,7 +46,7 @@ private static <T> OnSubscribeFunc<T> single(
             @Override
             public Subscription onSubscribe(final Observer<? super T> observer) {
                 final SafeObservableSubscription subscription = new SafeObservableSubscription();
-                subscription.wrap(source.subscribe(new Observer<T>() {
+                subscription.wrap(source.unsafeSubscribe(new Subscriber<T>() {
 
                     private T value;
                     private boolean isEmpty = true;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 31ffa1c90f..0696c86792 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -17,13 +17,13 @@
 
 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.Scheduler.Inner;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.subscriptions.CompositeSubscription;
@@ -67,7 +67,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
             CompositeSubscription csub = new CompositeSubscription(timer, data);
 
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
-            data.wrap(source.subscribe(so));
+            data.wrap(source.unsafeSubscribe(so));
             if (!data.isUnsubscribed()) {
                 timer.wrap(scheduler.schedule(so, time, unit));
             }
@@ -81,7 +81,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
          * @param <T>
          *            the observed value type
          */
-        private static final class SourceObserver<T> implements Observer<T>, Action1<Inner> {
+        private static final class SourceObserver<T> extends Subscriber<T> implements Action1<Inner> {
             final AtomicBoolean gate;
             final Observer<? super T> observer;
             final Subscription cancel;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
index 894a3dc473..d4bdaad988 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
@@ -27,6 +27,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.schedulers.Timestamped;
 
@@ -75,7 +76,7 @@ public Subscription onSubscribe(final Observer<? super T> observer) {
                         "count could not be negative");
             }
             final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(source.subscribe(new Observer<T>() {
+            return subscription.wrap(source.unsafeSubscribe(new Subscriber<T>() {
 
                 private final ReentrantLock lock = new ReentrantLock();
 
@@ -149,11 +150,11 @@ public SkipLastTimed(Observable<? extends T> source, long time, TimeUnit unit, S
 
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
-            return source.subscribe(new SourceObserver<T>(t1, timeInMillis, scheduler));
+            return source.unsafeSubscribe(new SourceObserver<T>(t1, timeInMillis, scheduler));
         }
 
         /** Observes the source. */
-        private static final class SourceObserver<T> implements Observer<T> {
+        private static final class SourceObserver<T> extends Subscriber<T> {
             final Observer<? super T> observer;
             final long timeInMillis;
             final Scheduler scheduler;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
index 3bd44032b5..d9a607ab54 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
@@ -20,7 +20,9 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
+import rx.observers.Subscribers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.SerialSubscription;
 
@@ -64,8 +66,8 @@ public ResultManager init() {
             cancel.add(toSource);
             cancel.add(toOther);
 
-            toSource.setSubscription(source.subscribe(this));
-            toOther.setSubscription(other.subscribe(new OtherObserver(toOther)));
+            toSource.setSubscription(source.unsafeSubscribe(Subscribers.from(this)));
+            toOther.setSubscription(other.unsafeSubscribe(new OtherObserver(toOther)));
 
             return this;
         }
@@ -104,7 +106,7 @@ public void onCompleted() {
         }
 
         /** Observe the other stream. */
-        private class OtherObserver implements Observer<U> {
+        private class OtherObserver extends Subscriber<U> {
             final Subscription self;
 
             public OtherObserver(Subscription self) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 332e1090a9..3332a49f2a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.subscriptions.CompositeSubscription;
@@ -64,13 +65,13 @@ public Subscription onSubscribe(Observer<? super T> observer) {
 
             SerialSubscription child = new SerialSubscription();
 
-            parent.wrap(sequences.subscribe(new SwitchObserver<T>(observer, parent, child)));
+            parent.wrap(sequences.unsafeSubscribe(new SwitchObserver<T>(observer, parent, child)));
 
             return new CompositeSubscription(parent, child);
         }
     }
 
-    private static class SwitchObserver<T> implements Observer<Observable<? extends T>> {
+    private static class SwitchObserver<T> extends Subscriber<Observable<? extends T>> {
 
         private final Object gate;
         private final Observer<? super T> observer;
@@ -97,7 +98,7 @@ public void onNext(Observable<? extends T> args) {
             }
 
             final SafeObservableSubscription sub = new SafeObservableSubscription();
-            sub.wrap(args.subscribe(new Observer<T>() {
+            sub.wrap(args.unsafeSubscribe(new Subscriber<T>() {
                 @Override
                 public void onNext(T args) {
                     synchronized (gate) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
index 53beddd7d4..dbbb497eb7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
@@ -24,6 +24,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.schedulers.Timestamped;
 
@@ -61,10 +62,10 @@ public Subscription onSubscribe(Observer<? super T> observer) {
                 throw new IndexOutOfBoundsException(
                         "count could not be negative");
             }
-            return subscription.wrap(items.subscribe(new ItemObserver(observer)));
+            return subscription.wrap(items.unsafeSubscribe(new ItemObserver(observer)));
         }
 
-        private class ItemObserver implements Observer<T> {
+        private class ItemObserver extends Subscriber<T> {
 
             /**
              * Store the last count elements until now.
@@ -156,13 +157,13 @@ public TakeLastTimed(Observable<? extends T> source, int count, long time, TimeU
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
             SafeObservableSubscription sas = new SafeObservableSubscription();
-            sas.wrap(source.subscribe(new TakeLastTimedObserver<T>(t1, sas, count, ageMillis, scheduler)));
+            sas.wrap(source.unsafeSubscribe(new TakeLastTimedObserver<T>(t1, sas, count, ageMillis, scheduler)));
             return sas;
         }
     }
 
     /** Observes source values and keeps the most recent items. */
-    static final class TakeLastTimedObserver<T> implements Observer<T> {
+    static final class TakeLastTimedObserver<T> extends Subscriber<T> {
         final Observer<? super T> observer;
         final Subscription cancel;
         final long ageMillis;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
index 88fd652026..cd52a04762 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
@@ -23,6 +23,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.subscriptions.CompositeSubscription;
@@ -86,7 +87,7 @@ private Take(Observable<? extends T> items, int num) {
         @Override
         public Subscription onSubscribe(Observer<? super T> observer) {
             if (num < 1) {
-                items.subscribe(new Observer<T>()
+                items.unsafeSubscribe(new Subscriber<T>()
                 {
                     @Override
                     public void onCompleted()
@@ -107,10 +108,10 @@ public void onNext(T args)
                 return Subscriptions.empty();
             }
 
-            return subscription.wrap(items.subscribe(new ItemObserver(observer)));
+            return subscription.wrap(items.unsafeSubscribe(new ItemObserver(observer)));
         }
 
-        private class ItemObserver implements Observer<T> {
+        private class ItemObserver extends Subscriber<T> {
             private final Observer<? super T> observer;
 
             private final AtomicInteger counter = new AtomicInteger();
@@ -197,7 +198,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
             CompositeSubscription csub = new CompositeSubscription(timer, data);
 
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
-            data.wrap(source.subscribe(so));
+            data.wrap(source.unsafeSubscribe(so));
             if (!data.isUnsubscribed()) {
                 timer.wrap(scheduler.schedule(so, time, unit));
             }
@@ -211,7 +212,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
          * @param <T>
          *            the observed value type
          */
-        private static final class SourceObserver<T> implements Observer<T>, Action1<Inner> {
+        private static final class SourceObserver<T> extends Subscriber<T> implements Action1<Inner> {
             final Observer<? super T> observer;
             final Subscription cancel;
             final AtomicInteger state = new AtomicInteger();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
index fd3615b8b5..9ad8d9a6ab 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 
@@ -89,7 +90,7 @@ private SourceObservable(Observable<? extends T> sequence) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Notification<T>> notificationObserver) {
-            return sequence.subscribe(new Observer<T>() {
+            return sequence.unsafeSubscribe(new Subscriber<T>() {
                 @Override
                 public void onCompleted() {
                     notificationObserver.onNext(Notification.<T> halt());
@@ -117,7 +118,7 @@ private OtherObservable(Observable<? extends E> sequence) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Notification<T>> notificationObserver) {
-            return sequence.subscribe(new Observer<E>() {
+            return sequence.unsafeSubscribe(new Subscriber<E>() {
                 @Override
                 public void onCompleted() {
                     notificationObserver.onNext(Notification.<T> halt());
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
index b2b7748991..a94a570337 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
@@ -20,6 +20,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -96,10 +97,10 @@ private TakeWhile(Observable<? extends T> items, Func2<? super T, ? super Intege
 
         @Override
         public Subscription onSubscribe(Observer<? super T> observer) {
-            return subscription.wrap(items.subscribe(new ItemObserver(observer)));
+            return subscription.wrap(items.unsafeSubscribe(new ItemObserver(observer)));
         }
 
-        private class ItemObserver implements Observer<T> {
+        private class ItemObserver extends Subscriber<T> {
             private final Observer<? super T> observer;
 
             private final AtomicInteger counter = new AtomicInteger();
diff --git a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
index 44d2d02083..d305fdf1d7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
@@ -24,6 +24,7 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.functions.Func1;
+import rx.observers.Subscribers;
 import rx.schedulers.Schedulers;
 
 /**
@@ -80,7 +81,7 @@ public Boolean call(T value) {
                         }
                     }
 
-                }).subscribe(observer);
+                }).unsafeSubscribe(Subscribers.from(observer));
             }
         };
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
index 04b84044ec..9fd0ae490c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
@@ -19,6 +19,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.schedulers.Schedulers;
 import rx.schedulers.TimeInterval;
@@ -39,13 +40,13 @@ public static <T> OnSubscribeFunc<TimeInterval<T>> timeInterval(
             @Override
             public Subscription onSubscribe(
                     Observer<? super TimeInterval<T>> observer) {
-                return source.subscribe(new TimeIntervalObserver<T>(observer,
+                return source.unsafeSubscribe(new TimeIntervalObserver<T>(observer,
                         scheduler));
             }
         };
     }
 
-    private static class TimeIntervalObserver<T> implements Observer<T> {
+    private static class TimeIntervalObserver<T> extends Subscriber<T> {
 
         private final Observer<? super TimeInterval<T>> observer;
         /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
index 712930c4c5..2b7c2c2f63 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
@@ -24,7 +24,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable;
-import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 
 /**
@@ -52,7 +52,7 @@ public static <T> Future<T> toFuture(Observable<? extends T> that) {
         final AtomicReference<T> value = new AtomicReference<T>();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
 
-        final Subscription s = that.subscribe(new Observer<T>() {
+        final Subscription s = that.unsafeSubscribe(new Subscriber<T>() {
 
             @Override
             public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
index 399083582d..f1faf11495 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
@@ -22,7 +22,7 @@
 
 import rx.Notification;
 import rx.Observable;
-import rx.Observer;
+import rx.Subscriber;
 import rx.exceptions.Exceptions;
 
 /**
@@ -45,7 +45,7 @@ public class OperationToIterator {
     public static <T> Iterator<T> toIterator(Observable<? extends T> source) {
         final BlockingQueue<Notification<? extends T>> notifications = new LinkedBlockingQueue<Notification<? extends T>>();
 
-        source.materialize().subscribe(new Observer<Notification<? extends T>>() {
+        source.materialize().unsafeSubscribe(new Subscriber<Notification<? extends T>>() {
             @Override
             public void onCompleted() {
                 // ignore
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMap.java b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
index 5e346f1ddd..cd3a08e62e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
@@ -22,6 +22,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -116,7 +117,7 @@ public Subscription onSubscribe(Observer<? super Map<K, V>> t1) {
                 t1.onError(t);
                 return Subscriptions.empty();
             }
-            return source.subscribe(new ToMapObserver<K, V, T>(
+            return source.unsafeSubscribe(new ToMapObserver<K, V, T>(
                     t1, keySelector, valueSelector, map));
         }
 
@@ -124,7 +125,7 @@ public Subscription onSubscribe(Observer<? super Map<K, V>> t1) {
          * Observer that collects the source values of T into
          * a map.
          */
-        public static class ToMapObserver<K, V, T> implements Observer<T> {
+        public static class ToMapObserver<K, V, T> extends Subscriber<T> {
             /** The map. */
             Map<K, V> map;
             /** Key extractor. */
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
index 94900abeda..416c16acaf 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
@@ -24,6 +24,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -155,7 +156,7 @@ public Subscription onSubscribe(Observer<? super Map<K, Collection<V>>> t1) {
                 t1.onError(t);
                 return Subscriptions.empty();
             }
-            return source.subscribe(new ToMultimapObserver<T, K, V>(
+            return source.unsafeSubscribe(new ToMultimapObserver<T, K, V>(
                     t1, keySelector, valueSelector, map, collectionFactory
                     ));
         }
@@ -163,7 +164,7 @@ public Subscription onSubscribe(Observer<? super Map<K, Collection<V>>> t1) {
         /**
          * Observer that collects the source values of Ts into a multimap.
          */
-        public static class ToMultimapObserver<T, K, V> implements Observer<T> {
+        public static class ToMultimapObserver<T, K, V> extends Subscriber<T> {
             private final Func1<? super T, ? extends K> keySelector;
             private final Func1<? super T, ? extends V> valueSelector;
             private final Func1<? super K, ? extends Collection<V>> collectionFactory;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java b/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
index 5d25bcb593..fbb989b4b2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
@@ -32,7 +32,7 @@
  * return value of the get() method of that object, by using the from operation.
  * <p>
  * This is blocking so the Subscription returned when calling
- * <code>Observable.subscribe(Observer)</code> does nothing.
+ * <code>Observable.unsafeSubscribe(Observer)</code> does nothing.
  */
 public class OperationToObservableFuture {
     /* package accessible for unit tests */static class ToObservableFuture<T> implements OnSubscribeFunc<T> {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationUsing.java b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
index 15108481f4..2beb3bda95 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationUsing.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
@@ -21,6 +21,7 @@
 import rx.Subscription;
 import rx.functions.Func0;
 import rx.functions.Func1;
+import rx.observers.Subscribers;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 
@@ -46,12 +47,12 @@ public Subscription onSubscribe(Observer<? super T> observer) {
                     // Use SafeObserver to guarantee resourceSubscription will
                     // be unsubscribed.
                     return subscription.wrap(new CompositeSubscription(
-                            observable.subscribe(new SafeObserver<T>(
+                            observable.unsafeSubscribe(new SafeObserver<T>(
                                     subscription, observer)),
                             resourceSubscription));
                 } catch (Throwable e) {
                     resourceSubscription.unsubscribe();
-                    return Observable.<T> error(e).subscribe(observer);
+                    return Observable.<T> error(e).unsafeSubscribe(Subscribers.from(observer));
                 }
             }
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index 5b170c56a0..8280236a54 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -21,6 +21,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -69,7 +70,7 @@ public static <T, TClosing> OnSubscribeFunc<Observable<T>> window(final Observab
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker());
                 ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, Observable<T>, TClosing>(windows, windowClosingSelector);
-                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
 
         };
@@ -110,7 +111,7 @@ public static <T, TOpening, TClosing> OnSubscribeFunc<Observable<T>> window(fina
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker());
                 ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, Observable<T>, TOpening, TClosing>(windows, windowOpenings, windowClosingSelector);
-                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
         };
     }
@@ -168,7 +169,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? exten
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker(), count);
                 ChunkCreator creator = new SkippingChunkCreator<T, Observable<T>>(chunks, skip);
-                return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
+                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
             }
         };
     }
@@ -225,7 +226,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? exten
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker());
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timespan, unit, scheduler);
-                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
         };
     }
@@ -288,7 +289,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? exten
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker(), count, timespan, unit, scheduler);
                 ChunkCreator creator = new SingleChunkCreator<T, Observable<T>>(chunks);
-                return source.subscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
+                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
             }
         };
     }
@@ -351,7 +352,7 @@ public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? exten
             public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
                 OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker(), timespan, unit, scheduler);
                 ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timeshift, unit, scheduler);
-                return source.subscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
+                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
             }
         };
     }
@@ -410,10 +411,10 @@ public Subscription onSubscribe(Observer<? super Observable<T>> t1) {
                 t1.onError(t);
                 return Subscriptions.empty();
             }
-            csub.add(source.subscribe(so));
+            csub.add(source.unsafeSubscribe(so));
 
             if (!csub.isUnsubscribed()) {
-                csub.add(boundary.subscribe(new BoundaryObserver<T, U>(so)));
+                csub.add(boundary.unsafeSubscribe(new BoundaryObserver<T, U>(so)));
             }
 
             return csub;
@@ -422,7 +423,7 @@ public Subscription onSubscribe(Observer<? super Observable<T>> t1) {
         /**
          * Observe the source and emit the values into the current window.
          */
-        private static final class SourceObserver<T> implements Observer<T> {
+        private static final class SourceObserver<T> extends Subscriber<T> {
             final Observer<? super Observable<T>> observer;
             final Subscription cancel;
             final Object guard;
@@ -500,7 +501,7 @@ public void replace() {
         /**
          * Observe the boundary and replace the window on each item.
          */
-        private static final class BoundaryObserver<T, U> implements Observer<U> {
+        private static final class BoundaryObserver<T, U> extends Subscriber<U> {
             final SourceObserver<T> so;
 
             public BoundaryObserver(SourceObserver<T> so) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAmb.java b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
index a2bb92ebaf..3f8d715a8e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAmb.java
@@ -186,7 +186,7 @@ public void call(Subscriber<? super T> subscriber) {
             }
             AmbSubscriber<T> ambSubscriber = new AmbSubscriber<T>(subscriber, index, choice);
             subscriber.add(ambSubscriber);
-            source.subscribe(ambSubscriber);
+            source.unsafeSubscribe(ambSubscriber);
             index++;
         }
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorCast.java b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
index cbad677443..59afea80da 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorCast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCast.java
@@ -17,7 +17,6 @@
 
 import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.exceptions.Exceptions;
 import rx.exceptions.OnErrorThrowable;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
index 2451939581..b530bd9d86 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupBy.java
@@ -108,7 +108,7 @@ public void call() {
                                     }
 
                                 }));
-                                _gps.subscribe(new Subscriber<T>(o) {
+                                _gps.unsafeSubscribe(new Subscriber<T>(o) {
 
                                     @Override
                                     public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
index 15843ff19f..5b4091310a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMerge.java
@@ -63,7 +63,7 @@ public void onNext(Observable<? extends T> innerObservable) {
                 runningCount.incrementAndGet();
                 Subscriber<T> i = new InnerObserver();
                 childrenSubscriptions.add(i);
-                innerObservable.subscribe(i);
+                innerObservable.unsafeSubscribe(i);
             }
 
             final class InnerObserver extends Subscriber<T> {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java
index 92806aad7e..9546348f2f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorFlatMap.java
@@ -47,7 +47,7 @@ public void onCompleted() {
             public void onError(Throwable e) {
                 try {
                     Observable<? extends T> resume = resumeFunction.call(OnErrorThrowable.from(e));
-                    resume.subscribe(new Subscriber<T>() {
+                    resume.unsafeSubscribe(new Subscriber<T>() {
 
                         @Override
                         public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
index 5b3adc2360..9fc5a675b2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaFunction.java
@@ -60,7 +60,7 @@ public void onCompleted() {
             public void onError(Throwable e) {
                 try {
                     Observable<? extends T> resume = resumeFunction.call(e);
-                    resume.subscribe(child);
+                    resume.unsafeSubscribe(child);
                 } catch (Throwable e2) {
                     child.onError(e2);
                 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorPivot.java b/rxjava-core/src/main/java/rx/operators/OperatorPivot.java
index c341cca1b3..5b9c6742fd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorPivot.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorPivot.java
@@ -102,7 +102,7 @@ public void onError(Throwable e) {
         @Override
         public void onNext(final GroupedObservable<K1, GroupedObservable<K2, T>> k1Group) {
             groups.startK1Group(state, k1Group.getKey());
-            k1Group.subscribe(new Subscriber<GroupedObservable<K2, T>>(parentSubscription) {
+            k1Group.unsafeSubscribe(new Subscriber<GroupedObservable<K2, T>>(parentSubscription) {
 
                 @Override
                 public void onCompleted() {
@@ -124,7 +124,7 @@ public void onNext(final GroupedObservable<K2, T> k2Group) {
                         // we have been unsubscribed
                         return;
                     }
-                    k2Group.subscribe(new Subscriber<T>(parentSubscription) {
+                    k2Group.unsafeSubscribe(new Subscriber<T>(parentSubscription) {
 
                         @Override
                         public void onCompleted() {
@@ -308,7 +308,7 @@ public void call() {
                         }
 
                     }));
-                    subject.subscribe(new Subscriber<T>(o) {
+                    subject.unsafeSubscribe(new Subscriber<T>(o) {
 
                         @Override
                         public void onCompleted() {
@@ -352,7 +352,7 @@ public static <K1, K2, T> Outer<K1, K2, T> create(final GroupState<K1, K2, T> gr
 
                 @Override
                 public void call(final Subscriber<? super GroupedObservable<K1, T>> o) {
-                    subject.subscribe(new Subscriber<GroupedObservable<K1, T>>(o) {
+                    subject.unsafeSubscribe(new Subscriber<GroupedObservable<K1, T>>(o) {
 
                         @Override
                         public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index d587aa8a6b..3c0b08b5f3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -77,7 +77,7 @@ public void onNext(final Observable<T> t) {
                     @Override
                     public void call(final Inner inner) {
                         executionCount++;
-                        t.subscribe(new Subscriber<T>(child) {
+                        t.unsafeSubscribe(new Subscriber<T>(child) {
 
                             @Override
                             public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index 1ee809aa47..98c9a82f65 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -77,7 +77,7 @@ public void onNext(final Observable<T> o) {
                     public void call(final Inner inner) {
                         final Action1<Inner> _self = this;
                         attempts.incrementAndGet();
-                        o.subscribe(new Subscriber<T>(s) {
+                        o.unsafeSubscribe(new Subscriber<T>(s) {
 
                             @Override
                             public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java
index 70e5fc220a..f60e28f32e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipWhile.java
@@ -15,15 +15,8 @@
  */
 package rx.operators;
 
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observable.Operator;
-import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Func1;
 import rx.functions.Func2;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index d549c146c2..29e01fd369 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -55,7 +55,7 @@ public void onNext(final Observable<T> o) {
 
                     @Override
                     public void call(final Inner inner) {
-                        o.subscribe(subscriber);
+                        o.unsafeSubscribe(subscriber);
                     }
                 }));
             }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index 73bb966277..52069a20f6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -155,7 +155,8 @@ public void onTimeout(long seqId) {
                 if (other == null) {
                     serializedSubscriber.onError(new TimeoutException());
                 } else {
-                    serial.set(other.subscribe(serializedSubscriber));
+                    other.unsafeSubscribe(serializedSubscriber);
+                    serial.set(serializedSubscriber);
                 }
             }
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
index ffc79f749b..95505f87e3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
@@ -51,7 +51,7 @@ public Subscription call(
                         timeoutSubscriber.onError(t);
                         return Subscriptions.empty();
                     }
-                    return o.subscribe(new Subscriber<U>() {
+                    return o.unsafeSubscribe(new Subscriber<U>() {
 
                         @Override
                         public void onCompleted() {
@@ -87,7 +87,7 @@ public Subscription call(
                     timeoutSubscriber.onError(t);
                     return Subscriptions.empty();
                 }
-                return o.subscribe(new Subscriber<V>() {
+                return o.unsafeSubscribe(new Subscriber<V>() {
 
                     @Override
                     public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index 9ecc99b376..eae0b5ac61 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -162,7 +162,7 @@ public Zip(Observable[] os, final Subscriber<? super R> observer, FuncN<? extend
         @SuppressWarnings("unchecked")
         public void zip() {
             for (int i = 0; i < os.length; i++) {
-                os[i].subscribe((InnerObserver) observers[i]);
+                os[i].unsafeSubscribe((InnerObserver) observers[i]);
             }
         }
 
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
index 08984deae3..9a583ab87d 100644
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
@@ -19,6 +19,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
 import rx.exceptions.OnErrorNotImplementedException;
@@ -61,7 +62,7 @@
  * @deprecated replaced by SafeSubscriber
  */
 @Deprecated
-public class SafeObserver<T> implements Observer<T> {
+public class SafeObserver<T> extends Subscriber<T> {
 
     private final Observer<? super T> actual;
     private final AtomicBoolean isFinished = new AtomicBoolean(false);
diff --git a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
index c3bfce52c5..5a9a070680 100644
--- a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -72,6 +72,7 @@ public static class RxJavaErrorHandlerTestImpl extends RxJavaErrorHandler {
 
         @Override
         public void handleError(Throwable e) {
+            e.printStackTrace();
             this.e = e;
             count++;
         }
@@ -138,6 +139,7 @@ public void testOnErrorWhenNotImplemented() {
         RuntimeException re = new RuntimeException("test onError");
         try {
             Observable.error(re).subscribe();
+            fail("should fail");
         } catch (Throwable e) {
             // ignore as we expect it to throw
         }
diff --git a/settings.gradle b/settings.gradle
index e9d3b54392..93c02ea902 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 17b01ab1f20dc5a1a9570f40ab2db695ebe074f2 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 1 Apr 2014 23:20:02 -0700
Subject: [PATCH 188/422] Ignore Unit Test until Delay is Fixed

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

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 13afb43a93..a18070add1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -35,6 +35,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.Matchers;
 
@@ -431,6 +432,7 @@ public void call(String s) {
         assertEquals(37, sentEventCounter.get());
     }
 
+    @Ignore // ignore until https://github.com/Netflix/RxJava/issues/1011 is fixed
     @Test
     public void testStaggeredCompletion() throws InterruptedException {
         final AtomicInteger eventCounter = new AtomicInteger();

From 3e26fa32b15dfa1e16bddaae6b874a744358de75 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 2 Apr 2014 09:42:05 +0200
Subject: [PATCH 189/422] Removed window between the two synchronized blocks.

---
 .../java/rx/observers/SerializedObserver.java | 32 +++++++++++--------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index 94a7845bcb..c9103ba954 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
@@ -128,6 +128,7 @@ public void onNext(T t) {
         }
 
         // we only get here if we won the right to emit, otherwise we returned in the if(emitting) block above
+        boolean skipFinal = false;
         try {
             int iter = MAX_DRAIN_ITERATION;
             do {
@@ -141,27 +142,32 @@ public void onNext(T t) {
                     synchronized (this) {
                         list = queue;
                         queue = null;
-                    }
-                    if (list == null) {
-                        break;
+                        if (list == null) {
+                            emitting = false;
+                            skipFinal = true;
+                            return;
+                        }
                     }
                 }
             } while (iter > 0);
         } finally {
-            synchronized (this) {
-                if (terminated) {
-                    list = queue;
-                    queue = null;
-                } else {
-                    emitting = false;
-                    list = null;
+            if (!skipFinal) {
+                synchronized (this) {
+                    if (terminated) {
+                        list = queue;
+                        queue = null;
+                    } else {
+                        emitting = false;
+                        list = null;
+                    }
                 }
             }
-            // this will only drain if terminated (done here outside of synchronized block)
-            drainQueue(list);
         }
+        
+        // this will only drain if terminated (done here outside of synchronized block)
+        drainQueue(list);
     }
-
+    
     void drainQueue(FastList list) {
         if (list == null || list.size == 0) {
             return;

From 1eddfd5357b2409448a89e6103984b6745450439 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 2 Apr 2014 20:14:09 +0000
Subject: [PATCH 190/422] [Gradle Release Plugin] - pre tag commit:  '0.17.4'.

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

diff --git a/gradle.properties b/gradle.properties
index ba3ab22d56..fd31ec85a5 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.4-SNAPSHOT
+version=0.17.4

From afd1a88fb83edbacad967baceb99594ebd572133 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 2 Apr 2014 20:14:13 +0000
Subject: [PATCH 191/422] [Gradle Release Plugin] - new version commit: 
 '0.17.5-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index fd31ec85a5..27afea0ddf 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.4
+version=0.17.5-SNAPSHOT

From 7af5c327c199b1010ef034cdece487e1275b3fb4 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Wed, 2 Apr 2014 13:18:07 -0700
Subject: [PATCH 192/422] 0.17.4

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

diff --git a/CHANGES.md b/CHANGES.md
index 731fc21557..46c644ed27 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # RxJava Releases #
 
+### Version 0.17.4 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.4%22)) ###
+
+* [Pull 990] (https://github.com/Netflix/RxJava/pull/990) Quasar Lightweight Threads/Fibers Contrib Module
+* [Pull 1012] (https://github.com/Netflix/RxJava/pull/1012) SerializedObserver: Removed window between the two synchronized blocks
+
+
 ### Version 0.17.3 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.3%22)) ###
 
 * [Pull 991] (https://github.com/Netflix/RxJava/pull/991) JMH Benchmark Build Config

From 7ce68609c93c30d6cba942e4d22a798122266689 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 2 Apr 2014 21:30:01 -0700
Subject: [PATCH 193/422] Fix BlockingOperator Subscribe Behavior

The blocking operators need to use 'subscribe', not 'unsafeSubscribe' since they need the SafeSubscriber behavior in the final subscribe step they perform.
Renamed operators to BlockingOperator* for clarity and to match the Operation->Operator naming change.
---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 .../rx/observables/BlockingObservable.java    | 41 +++-------
 ...atest.java => BlockingOperatorLatest.java} |  6 +-
 ...t.java => BlockingOperatorMostRecent.java} |  8 +-
 ...ionNext.java => BlockingOperatorNext.java} |  4 +-
 ...ure.java => BlockingOperatorToFuture.java} |  4 +-
 ...r.java => BlockingOperatorToIterator.java} |  5 +-
 .../rx/operators/OperationDematerialize.java  |  2 +-
 .../rx/operators/OperationMaterialize.java    | 81 -------------------
 .../rx/operators/OperatorMaterialize.java     | 56 +++++++++++++
 ...t.java => BlockingOperatorLatestTest.java} |  2 +-
 ...va => BlockingOperatorMostRecentTest.java} |  4 +-
 ...est.java => BlockingOperatorNextTest.java} |  6 +-
 ...java => BlockingOperatorToFutureTest.java} |  4 +-
 ...va => BlockingOperatorToIteratorTest.java} |  4 +-
 ...Test.java => OperatorMaterializeTest.java} | 10 +--
 16 files changed, 103 insertions(+), 138 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationLatest.java => BlockingOperatorLatest.java} (96%)
 rename rxjava-core/src/main/java/rx/operators/{OperationMostRecent.java => BlockingOperatorMostRecent.java} (91%)
 rename rxjava-core/src/main/java/rx/operators/{OperationNext.java => BlockingOperatorNext.java} (98%)
 rename rxjava-core/src/main/java/rx/operators/{OperationToFuture.java => BlockingOperatorToFuture.java} (97%)
 rename rxjava-core/src/main/java/rx/operators/{OperationToIterator.java => BlockingOperatorToIterator.java} (93%)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMaterialize.java
 rename rxjava-core/src/test/java/rx/operators/{OperationLatestTest.java => BlockingOperatorLatestTest.java} (99%)
 rename rxjava-core/src/test/java/rx/operators/{OperationMostRecentTest.java => BlockingOperatorMostRecentTest.java} (96%)
 rename rxjava-core/src/test/java/rx/operators/{OperationNextTest.java => BlockingOperatorNextTest.java} (98%)
 rename rxjava-core/src/test/java/rx/operators/{OperationToFutureTest.java => BlockingOperatorToFutureTest.java} (97%)
 rename rxjava-core/src/test/java/rx/operators/{OperationToIteratorTest.java => BlockingOperatorToIteratorTest.java} (95%)
 rename rxjava-core/src/test/java/rx/operators/{OperationMaterializeTest.java => OperatorMaterializeTest.java} (92%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index d1e46e6213..223d1b08b6 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -74,7 +74,7 @@
 import rx.operators.OperationInterval;
 import rx.operators.OperationJoin;
 import rx.operators.OperationJoinPatterns;
-import rx.operators.OperationMaterialize;
+import rx.operators.OperatorMaterialize;
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMinMax;
@@ -4915,7 +4915,7 @@ public final <R> Observable<R> mapMany(Func1<? super T, ? extends Observable<R>>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229453.aspx">MSDN: Observable.materialize</a>
      */
     public final Observable<Notification<T>> materialize() {
-        return create(OperationMaterialize.materialize(this));
+        return lift(new OperatorMaterialize<T>());
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 916fca423a..e6fcba712e 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -22,15 +22,13 @@
 
 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.operators.BlockingOperatorLatest;
+import rx.operators.BlockingOperatorMostRecent;
+import rx.operators.BlockingOperatorNext;
+import rx.operators.BlockingOperatorToFuture;
+import rx.operators.BlockingOperatorToIterator;
 
 /**
  * An extension of {@link Observable} that provides blocking operators.
@@ -64,17 +62,6 @@ public static <T> BlockingObservable<T> from(final Observable<? extends T> o) {
         return new BlockingObservable<T>(o);
     }
 
-    /**
-     * Used for protecting against errors being thrown from {@link Subscriber} implementations and ensuring onNext/onError/onCompleted contract
-     * compliance.
-     * <p>
-     * 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(Subscriber<? super T> observer) {
-        return o.unsafeSubscribe(new SafeSubscriber<T>(observer));
-    }
-
     /**
      * Invoke a method on each item emitted by the {@link Observable}; block
      * until the Observable completes.
@@ -97,12 +84,10 @@ public void forEach(final Action1<? super T> onNext) {
         final AtomicReference<Throwable> exceptionFromOnError = new AtomicReference<Throwable>();
 
         /**
-         * 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"
+         * Use 'subscribe' instead of 'unsafeSubscribe' for Rx contract behavior
+         * as this is the final subscribe in the chain.
          */
-        protectivelyWrapAndSubscribe(new Subscriber<T>() {
+        o.subscribe(new Subscriber<T>() {
             @Override
             public void onCompleted() {
                 latch.countDown();
@@ -158,7 +143,7 @@ public void onNext(T args) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#transformations-tofuture-toiterable-and-toiteratorgetiterator">RxJava Wiki: getIterator()</a>
      */
     public Iterator<T> getIterator() {
-        return OperationToIterator.toIterator(o);
+        return BlockingOperatorToIterator.toIterator(o);
     }
 
     /**
@@ -311,7 +296,7 @@ public T lastOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229751.aspx">MSDN: Observable.MostRecent</a>
      */
     public Iterable<T> mostRecent(T initialValue) {
-        return OperationMostRecent.mostRecent(o, initialValue);
+        return BlockingOperatorMostRecent.mostRecent(o, initialValue);
     }
 
     /**
@@ -324,7 +309,7 @@ public Iterable<T> mostRecent(T initialValue) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211897.aspx">MSDN: Observable.Next</a>
      */
     public Iterable<T> next() {
-        return OperationNext.next(o);
+        return BlockingOperatorNext.next(o);
     }
 
     /**
@@ -344,7 +329,7 @@ public Iterable<T> next() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212115.aspx">MSDN: Observable.Latest</a>
      */
     public Iterable<T> latest() {
-        return OperationLatest.latest(o);
+        return BlockingOperatorLatest.latest(o);
     }
 
     /**
@@ -441,7 +426,7 @@ public T singleOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators#transformations-tofuture-toiterable-and-toiteratorgetiterator">RxJava Wiki: toFuture()</a>
      */
     public Future<T> toFuture() {
-        return OperationToFuture.toFuture(o);
+        return BlockingOperatorToFuture.toFuture(o);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationLatest.java b/rxjava-core/src/main/java/rx/operators/BlockingOperatorLatest.java
similarity index 96%
rename from rxjava-core/src/main/java/rx/operators/OperationLatest.java
rename to rxjava-core/src/main/java/rx/operators/BlockingOperatorLatest.java
index d5e0da4f77..5b98cfa269 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/BlockingOperatorLatest.java
@@ -30,9 +30,9 @@
  * If the source works faster than the iterator, values may be skipped, but
  * not the onError or onCompleted events.
  */
-public final class OperationLatest {
+public final class BlockingOperatorLatest {
     /** Utility class. */
-    private OperationLatest() {
+    private BlockingOperatorLatest() {
         throw new IllegalStateException("No instances!");
     }
 
@@ -41,7 +41,7 @@ public static <T> Iterable<T> latest(final Observable<? extends T> source) {
             @Override
             public Iterator<T> iterator() {
                 LatestObserverIterator<T> lio = new LatestObserverIterator<T>();
-                source.materialize().unsafeSubscribe(lio);
+                source.materialize().subscribe(lio);
                 return lio;
             }
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java b/rxjava-core/src/main/java/rx/operators/BlockingOperatorMostRecent.java
similarity index 91%
rename from rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
rename to rxjava-core/src/main/java/rx/operators/BlockingOperatorMostRecent.java
index bff9eb7967..ef974fb1b5 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationMostRecent.java
+++ b/rxjava-core/src/main/java/rx/operators/BlockingOperatorMostRecent.java
@@ -29,7 +29,7 @@
  * <p>
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.mostRecent.png">
  */
-public final class OperationMostRecent {
+public final class BlockingOperatorMostRecent {
 
     public static <T> Iterable<T> mostRecent(final Observable<? extends T> source, final T initialValue) {
 
@@ -39,7 +39,11 @@ public Iterator<T> iterator() {
                 MostRecentObserver<T> mostRecentObserver = new MostRecentObserver<T>(initialValue);
                 final MostRecentIterator<T> nextIterator = new MostRecentIterator<T>(mostRecentObserver);
 
-                source.unsafeSubscribe(mostRecentObserver);
+                /**
+                 * Subscribe instead of unsafeSubscribe since this is the final subscribe in the chain
+                 * since it is for BlockingObservable.
+                 */
+                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/BlockingOperatorNext.java
similarity index 98%
rename from rxjava-core/src/main/java/rx/operators/OperationNext.java
rename to rxjava-core/src/main/java/rx/operators/BlockingOperatorNext.java
index 70b2ac7cee..9c52880ef0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationNext.java
+++ b/rxjava-core/src/main/java/rx/operators/BlockingOperatorNext.java
@@ -31,7 +31,7 @@
  * <p>
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/B.next.png">
  */
-public final class OperationNext {
+public final class BlockingOperatorNext {
 
     public static <T> Iterable<T> next(final Observable<? extends T> items) {
         return new Iterable<T>() {
@@ -40,7 +40,7 @@ public Iterator<T> iterator() {
                 NextObserver<T> nextObserver = new NextObserver<T>();
                 final NextIterator<T> nextIterator = new NextIterator<T>(nextObserver);
 
-                items.materialize().unsafeSubscribe(nextObserver);
+                items.materialize().subscribe(nextObserver);
 
                 return nextIterator;
             }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java b/rxjava-core/src/main/java/rx/operators/BlockingOperatorToFuture.java
similarity index 97%
rename from rxjava-core/src/main/java/rx/operators/OperationToFuture.java
rename to rxjava-core/src/main/java/rx/operators/BlockingOperatorToFuture.java
index 2b7c2c2f63..4a9bbbba55 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/BlockingOperatorToFuture.java
@@ -35,7 +35,7 @@
  * The toFuture operation throws an exception if the Observable emits more than one item. If the
  * Observable may emit more than item, use <code>toList().toFuture()</code>.
  */
-public class OperationToFuture {
+public class BlockingOperatorToFuture {
 
     /**
      * Returns a Future that expects a single item from the observable.
@@ -52,7 +52,7 @@ public static <T> Future<T> toFuture(Observable<? extends T> that) {
         final AtomicReference<T> value = new AtomicReference<T>();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
 
-        final Subscription s = that.unsafeSubscribe(new Subscriber<T>() {
+        final Subscription s = that.subscribe(new Subscriber<T>() {
 
             @Override
             public void onCompleted() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java b/rxjava-core/src/main/java/rx/operators/BlockingOperatorToIterator.java
similarity index 93%
rename from rxjava-core/src/main/java/rx/operators/OperationToIterator.java
rename to rxjava-core/src/main/java/rx/operators/BlockingOperatorToIterator.java
index f1faf11495..d5922b2cdd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToIterator.java
+++ b/rxjava-core/src/main/java/rx/operators/BlockingOperatorToIterator.java
@@ -33,7 +33,7 @@
  * 
  * @see <a href="https://github.com/Netflix/RxJava/issues/50">Issue #50</a>
  */
-public class OperationToIterator {
+public class BlockingOperatorToIterator {
 
     /**
      * Returns an iterator that iterates all values of the observable.
@@ -45,7 +45,8 @@ public class OperationToIterator {
     public static <T> Iterator<T> toIterator(Observable<? extends T> source) {
         final BlockingQueue<Notification<? extends T>> notifications = new LinkedBlockingQueue<Notification<? extends T>>();
 
-        source.materialize().unsafeSubscribe(new Subscriber<Notification<? extends T>>() {
+        // using subscribe instead of unsafeSubscribe since this is a BlockingObservable "final subscribe"
+        source.materialize().subscribe(new Subscriber<Notification<? extends T>>() {
             @Override
             public void onCompleted() {
                 // ignore
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
index 390a445d3e..026bbc891d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
@@ -23,7 +23,7 @@
 import rx.Subscription;
 
 /**
- * Reverses the effect of {@link OperationMaterialize} by transforming the Notification objects
+ * Reverses the effect of {@link OperatorMaterialize} by transforming the Notification objects
  * emitted by a source Observable into the items or notifications they represent.
  * <p>
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/dematerialize.png">
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java b/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
deleted file mode 100644
index 7cf3ca5ee4..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationMaterialize.java
+++ /dev/null
@@ -1,81 +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.Notification;
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-
-/**
- * Turns all of the notifications from an Observable into <code>onNext</code> emissions, and marks
- * them with their original notification types within {@link Notification} objects.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/materialize.png">
- * <p>
- * See <a href="http://msdn.microsoft.com/en-us/library/hh229453(v=VS.103).aspx">here</a> for the
- * Microsoft Rx equivalent.
- */
-public final class OperationMaterialize {
-
-    /**
-     * Materializes the implicit notifications of an observable sequence as explicit notification values.
-     * 
-     * @param sequence
-     *            An observable sequence of elements to project.
-     * @return An observable sequence whose elements are the result of materializing the notifications of the given sequence.
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229453(v=VS.103).aspx">Observable.Materialize(TSource) Method </a>
-     */
-    public static <T> OnSubscribeFunc<Notification<T>> materialize(final Observable<? extends T> sequence) {
-        return new MaterializeObservable<T>(sequence);
-    }
-
-    private static class MaterializeObservable<T> implements OnSubscribeFunc<Notification<T>> {
-
-        private final Observable<? extends T> sequence;
-
-        public MaterializeObservable(Observable<? extends T> sequence) {
-            this.sequence = sequence;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super Notification<T>> observer) {
-            return sequence.unsafeSubscribe(new Subscriber<T>() {
-
-                @Override
-                public void onCompleted() {
-                    observer.onNext(new Notification<T>());
-                    observer.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    observer.onNext(new Notification<T>(e));
-                    observer.onCompleted();
-                }
-
-                @Override
-                public void onNext(T value) {
-                    observer.onNext(new Notification<T>(value));
-                }
-
-            });
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMaterialize.java b/rxjava-core/src/main/java/rx/operators/OperatorMaterialize.java
new file mode 100644
index 0000000000..1162ca9808
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMaterialize.java
@@ -0,0 +1,56 @@
+/**
+ * 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.Observable.Operator;
+import rx.Subscriber;
+
+/**
+ * Turns all of the notifications from an Observable into <code>onNext</code> emissions, and marks
+ * them with their original notification types within {@link Notification} objects.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/materialize.png">
+ * <p>
+ * See <a href="http://msdn.microsoft.com/en-us/library/hh229453(v=VS.103).aspx">here</a> for the
+ * Microsoft Rx equivalent.
+ */
+public final class OperatorMaterialize<T> implements Operator<Notification<T>, T> {
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super Notification<T>> child) {
+        return new Subscriber<T>(child) {
+
+            @Override
+            public void onCompleted() {
+                child.onNext(Notification.<T> createOnCompleted());
+                child.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onNext(Notification.<T> createOnError(e));
+                child.onCompleted();
+            }
+
+            @Override
+            public void onNext(T t) {
+                child.onNext(Notification.<T> createOnNext(t));
+            }
+
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorLatestTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationLatestTest.java
rename to rxjava-core/src/test/java/rx/operators/BlockingOperatorLatestTest.java
index 87cd7fdc23..58eaf4d6a4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationLatestTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorLatestTest.java
@@ -28,7 +28,7 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class OperationLatestTest {
+public class BlockingOperatorLatestTest {
     @Test(timeout = 1000)
     public void testSimple() {
         TestScheduler scheduler = new TestScheduler();
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
similarity index 96%
rename from rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java
rename to rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
index c9de7064f9..9ac1a358c3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMostRecentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
@@ -16,7 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
-import static rx.operators.OperationMostRecent.*;
+import static rx.operators.BlockingOperatorMostRecent.*;
 
 import java.util.Iterator;
 import java.util.concurrent.TimeUnit;
@@ -30,7 +30,7 @@
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 
-public class OperationMostRecentTest {
+public class BlockingOperatorMostRecentTest {
 
     @Test
     public void testMostRecent() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationNextTest.java
rename to rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
index 92a267c307..36bba0948a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationNextTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
@@ -16,7 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
-import static rx.operators.OperationNext.*;
+import static rx.operators.BlockingOperatorNext.*;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
@@ -37,7 +37,7 @@
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
 
-public class OperationNextTest {
+public class BlockingOperatorNextTest {
 
     private void fireOnNextInNewThread(final Subject<String, String> o, final String value) {
         new Thread() {
@@ -304,7 +304,7 @@ public void testSingleSourceManyIterators() throws InterruptedException {
         Iterable<Long> iter = source.next();
 
         for (int j = 0; j < 3; j++) {
-            OperationNext.NextIterator<Long> it = (OperationNext.NextIterator<Long>)iter.iterator();
+            BlockingOperatorNext.NextIterator<Long> it = (BlockingOperatorNext.NextIterator<Long>)iter.iterator();
 
             for (long i = 0; i < 9; i++) {
                 // hasNext has to set the waiting to true, otherwise, all onNext will be skipped
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToFutureTest.java
similarity index 97%
rename from rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
rename to rxjava-core/src/test/java/rx/operators/BlockingOperatorToFutureTest.java
index efe840dacc..e0460cc84d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToFutureTest.java
@@ -18,7 +18,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static rx.operators.OperationToFuture.toFuture;
+import static rx.operators.BlockingOperatorToFuture.toFuture;
 
 import java.util.List;
 import java.util.concurrent.CancellationException;
@@ -35,7 +35,7 @@
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
 
-public class OperationToFutureTest {
+public class BlockingOperatorToFutureTest {
 
     @Test
     public void testToFuture() throws InterruptedException, ExecutionException {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToIteratorTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
similarity index 95%
rename from rxjava-core/src/test/java/rx/operators/OperationToIteratorTest.java
rename to rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
index cb5f53d90d..d10c5269db 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToIteratorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
@@ -16,7 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
-import static rx.operators.OperationToIterator.*;
+import static rx.operators.BlockingOperatorToIterator.*;
 
 import java.util.Iterator;
 
@@ -28,7 +28,7 @@
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
 
-public class OperationToIteratorTest {
+public class BlockingOperatorToIteratorTest {
 
     @Test
     public void testToIterator() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMaterializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
similarity index 92%
rename from rxjava-core/src/test/java/rx/operators/OperationMaterializeTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
index 75dfaa59a7..ffcfca150e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMaterializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
@@ -16,7 +16,7 @@
 package rx.operators;
 
 import static org.junit.Assert.*;
-import static rx.operators.OperationMaterialize.*;
+import static rx.operators.OperatorMaterialize.*;
 
 import java.util.List;
 import java.util.Vector;
@@ -31,7 +31,7 @@
 import rx.Subscription;
 import rx.subscriptions.Subscriptions;
 
-public class OperationMaterializeTest {
+public class OperatorMaterializeTest {
 
     @Test
     public void testMaterialize1() {
@@ -39,7 +39,7 @@ public void testMaterialize1() {
         final TestAsyncErrorObservable o1 = new TestAsyncErrorObservable("one", "two", null, "three");
 
         TestObserver Observer = new TestObserver();
-        Observable<Notification<String>> m = Observable.create(materialize(Observable.create(o1)));
+        Observable<Notification<String>> m = Observable.create(o1).materialize();
         m.subscribe(Observer);
 
         try {
@@ -64,7 +64,7 @@ public void testMaterialize2() {
         final TestAsyncErrorObservable o1 = new TestAsyncErrorObservable("one", "two", "three");
 
         TestObserver Observer = new TestObserver();
-        Observable<Notification<String>> m = Observable.create(materialize(Observable.create(o1)));
+        Observable<Notification<String>> m = Observable.create(o1).materialize();
         m.subscribe(Observer);
 
         try {
@@ -89,7 +89,7 @@ public void testMaterialize2() {
     public void testMultipleSubscribes() throws InterruptedException, ExecutionException {
         final TestAsyncErrorObservable o = new TestAsyncErrorObservable("one", "two", null, "three");
 
-        Observable<Notification<String>> m = Observable.create(materialize(Observable.create(o)));
+        Observable<Notification<String>> m = Observable.create(o).materialize();
 
         assertEquals(3, m.toList().toBlockingObservable().toFuture().get().size());
         assertEquals(3, m.toList().toBlockingObservable().toFuture().get().size());

From 0ab352f849dada233f287fcb27b009985a6c1fc1 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 3 Apr 2014 09:49:50 -0700
Subject: [PATCH 194/422] Remove Redundant protectivelyWrap Method

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 223d1b08b6..24b779a100 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5367,17 +5367,6 @@ public final <R> Observable<R> parallel(final Func1<Observable<T>, Observable<R>
         return lift(new OperatorParallel<T, R>(f, s));
     }
 
-    /**
-     * Protects against errors being thrown from Observer implementations and ensures
-     * onNext/onError/onCompleted contract compliance.
-     * <p>
-     * 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<? super T> o) {
-        return subscribe(new SafeSubscriber<T>(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.
@@ -6704,7 +6693,7 @@ public final Observable<T> startWith(T[] values, Scheduler scheduler) {
      *             if the Observable tries to call {@code onError}
      */
     public final Subscription subscribe() {
-        return protectivelyWrapAndSubscribe(new Subscriber<T>() {
+        return subscribe(new Subscriber<T>() {
 
             @Override
             public final void onCompleted() {
@@ -6743,13 +6732,7 @@ public final Subscription subscribe(final Action1<? super T> onNext) {
             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 Observer"
-         */
-        return protectivelyWrapAndSubscribe(new Subscriber<T>() {
+        return subscribe(new Subscriber<T>() {
 
             @Override
             public final void onCompleted() {
@@ -6793,13 +6776,7 @@ public final Subscription subscribe(final Action1<? super T> onNext, final Actio
             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 Observer"
-         */
-        return protectivelyWrapAndSubscribe(new Subscriber<T>() {
+        return subscribe(new Subscriber<T>() {
 
             @Override
             public final void onCompleted() {
@@ -6850,12 +6827,7 @@ public final Subscription subscribe(final Action1<? super T> onNext, final Actio
             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 Observer"
-         */
-        return protectivelyWrapAndSubscribe(new Subscriber<T>() {
+        return subscribe(new Subscriber<T>() {
 
             @Override
             public final void onCompleted() {
@@ -7011,7 +6983,7 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
      * For more information see the
      * <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
      * 
-     * @param observer
+     * @param subscriber
      *            the {@link Subscriber}
      * @return a {@link Subscription} reference with which Subscribers that are {@link Observer}s can
      *         unsubscribe from the Observable
@@ -7024,11 +6996,11 @@ public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
      * @throws RuntimeException
      *             if the {@link Subscriber}'s {@code onError} method itself threw a {@code Throwable}
      */
-    public final Subscription subscribe(Subscriber<? super T> observer) {
+    public final Subscription subscribe(Subscriber<? super T> subscriber) {
         // allow the hook to intercept and/or decorate
         OnSubscribe<T> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
         // validate and proceed
-        if (observer == null) {
+        if (subscriber == null) {
             throw new IllegalArgumentException("observer can not be null");
         }
         if (onSubscribeFunction == null) {
@@ -7044,12 +7016,12 @@ public final Subscription subscribe(Subscriber<? super T> observer) {
              * to user code from within an Observer"
              */
             // if not already wrapped
-            if (!(observer instanceof SafeSubscriber)) {
+            if (!(subscriber instanceof SafeSubscriber)) {
                 // assign to `observer` so we return the protected version
-                observer = new SafeSubscriber<T>(observer);
+                subscriber = new SafeSubscriber<T>(subscriber);
             }
-            onSubscribeFunction.call(observer);
-            final Subscription returnSubscription = hook.onSubscribeReturn(observer);
+            onSubscribeFunction.call(subscriber);
+            final Subscription returnSubscription = hook.onSubscribeReturn(subscriber);
             // we return it inside a Subscription so it can't be cast back to Subscriber
             return Subscriptions.create(new Action0() {
 
@@ -7064,7 +7036,7 @@ public void call() {
             Exceptions.throwIfFatal(e);
             // if an unhandled error occurs executing the onSubscribe we will propagate it
             try {
-                observer.onError(hook.onSubscribeError(e));
+                subscriber.onError(hook.onSubscribeError(e));
             } catch (OnErrorNotImplementedException e2) {
                 // special handling when onError is not implemented ... we just rethrow
                 throw e2;

From 4b13ff60940881288a14f5bc0711af6414160cdb Mon Sep 17 00:00:00 2001
From: Peter McDonnell <petermd@gmail.com>
Date: Fri, 4 Apr 2014 16:33:52 +0100
Subject: [PATCH 195/422] unsubscribe before retry

---
 .../main/java/rx/operators/OperatorRetry.java | 20 ++++-
 .../java/rx/operators/OperatorRetryTest.java  | 90 +++++++++++++++++++
 2 files changed, 107 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index 98c9a82f65..e5e5abe955 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -32,11 +32,14 @@
  */
 
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable;
 import rx.Observable.Operator;
+import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.Subscription;
 import rx.functions.Action1;
 import rx.schedulers.Schedulers;
 
@@ -71,13 +74,16 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(final Observable<T> o) {
+
+                final AtomicReference<Subscription> retrySub=new AtomicReference<Subscription>();
+
                 Schedulers.trampoline().schedule(new Action1<Inner>() {
 
                     @Override
                     public void call(final Inner inner) {
                         final Action1<Inner> _self = this;
                         attempts.incrementAndGet();
-                        o.unsafeSubscribe(new Subscriber<T>(s) {
+                        retrySub.set(o.unsafeSubscribe(new Subscriber<T>(s) {
 
                             @Override
                             public void onCompleted() {
@@ -88,7 +94,15 @@ public void onCompleted() {
                             public void onError(Throwable e) {
                                 if ((retryCount == INFINITE_RETRY || attempts.get() <= retryCount) && !inner.isUnsubscribed()) {
                                     // retry again
-                                    inner.schedule(_self);
+                                    inner.schedule(new Action1<Inner>() {
+                                        @Override
+                                        public void call(Inner inner)
+                                        {
+                                            // Remove the failed subscription first
+                                            retrySub.get().unsubscribe();
+                                            _self.call(inner);
+                                        }
+                                    });
                                 } else {
                                     // give up and pass the failure
                                     s.onError(e);
@@ -100,7 +114,7 @@ public void onNext(T v) {
                                 s.onNext(v);
                             }
 
-                        });
+                        }));
                     }
                 });
             }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
index 1092156fd8..97ea46adf5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
@@ -19,6 +19,8 @@
 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 org.junit.Test;
@@ -27,6 +29,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.subjects.PublishSubject;
@@ -147,6 +150,93 @@ public void call(Integer n) {
         assertEquals(1, count.get());
     }
 
+    public static class SlowFuncAlwaysFails implements Observable.OnSubscribe<String> {
+
+        final AtomicInteger nextSeq=new AtomicInteger();
+        final AtomicInteger activeSubs=new AtomicInteger();
+        final AtomicInteger concurrentSubs=new AtomicInteger();
+
+        public void call(final Subscriber<? super String> s)
+        {
+            final int seq=nextSeq.incrementAndGet();
+
+            int cur=activeSubs.incrementAndGet();
+            // Track concurrent subscriptions
+            concurrentSubs.set(Math.max(cur,concurrentSubs.get()));
+
+            // Use async error
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        Thread.sleep(100);
+                    } catch (InterruptedException e) {
+                        // ignore
+                    }
+                    s.onError(new RuntimeException("Subscriber #"+seq+" fails"));
+                }
+            }).start();
+
+            // Track unsubscribes
+            s.add(new Subscription()
+            {
+                private boolean active=true;
+
+                public void unsubscribe()
+                {
+                    if (active) {
+                        activeSubs.decrementAndGet();
+                        active=false;
+                    }
+                }
+
+                public boolean isUnsubscribed()
+                {
+                    return !active;
+                }
+            });
+        }
+    }
+
+    @Test
+    public void testUnsubscribeAfterError() {
+
+        final CountDownLatch check=new CountDownLatch(1);
+        final SlowFuncAlwaysFails sf=new SlowFuncAlwaysFails();
+
+        Observable
+            .create(sf)
+            .retry(4)
+            .subscribe(
+                new Action1<String>()
+                {
+                    @Override
+                    public void call(String v)
+                    {
+                        fail("Should never happen");
+                    }
+                },
+                new Action1<Throwable>()
+                {
+                    public void call(Throwable throwable)
+                    {
+                        check.countDown();
+                    }
+                }
+            );
+
+        try
+        {
+            check.await(1, TimeUnit.SECONDS);
+        } catch (InterruptedException e)
+        {
+            fail("interrupted");
+        }
+
+        assertEquals("5 Subscribers created", 5, sf.nextSeq.get());
+        assertEquals("1 Active Subscriber", 1, sf.concurrentSubs.get());
+    }
+
     @Test
     public void testRetryAllowsSubscriptionAfterAllSubscriptionsUnsubsribed() throws InterruptedException {
         final AtomicInteger subsCount = new AtomicInteger(0);

From 840c92b7e51ec05a4e4942949316a4ef5f620901 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 4 Apr 2014 10:14:17 -0700
Subject: [PATCH 196/422] Unsubscribe on retry using SerialSubscription

---
 .../main/java/rx/operators/OperatorRetry.java | 42 ++++++++-----------
 1 file changed, 18 insertions(+), 24 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index e5e5abe955..31057ccc49 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -32,16 +32,14 @@
  */
 
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable;
 import rx.Observable.Operator;
-import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Action1;
 import rx.schedulers.Schedulers;
+import rx.subscriptions.SerialSubscription;
 
 public class OperatorRetry<T> implements Operator<T, Observable<T>> {
 
@@ -58,10 +56,13 @@ public OperatorRetry() {
     }
 
     @Override
-    public Subscriber<? super Observable<T>> call(final Subscriber<? super T> s) {
-        return new Subscriber<Observable<T>>(s) {
+    public Subscriber<? super Observable<T>> call(final Subscriber<? super T> child) {
+        final SerialSubscription serialSubscription = new SerialSubscription();
+        // add serialSubscription so it gets unsubscribed if child is unsubscribed
+        child.add(serialSubscription);
+        return new Subscriber<Observable<T>>(child) {
             final AtomicInteger attempts = new AtomicInteger(0);
-            
+
             @Override
             public void onCompleted() {
                 // ignore as we expect a single nested Observable<T>
@@ -69,52 +70,45 @@ public void onCompleted() {
 
             @Override
             public void onError(Throwable e) {
-                s.onError(e);
+                child.onError(e);
             }
 
             @Override
             public void onNext(final Observable<T> o) {
-
-                final AtomicReference<Subscription> retrySub=new AtomicReference<Subscription>();
-
                 Schedulers.trampoline().schedule(new Action1<Inner>() {
 
                     @Override
                     public void call(final Inner inner) {
                         final Action1<Inner> _self = this;
                         attempts.incrementAndGet();
-                        retrySub.set(o.unsafeSubscribe(new Subscriber<T>(s) {
+
+                        Subscriber<T> subscriber = new Subscriber<T>(child) {
 
                             @Override
                             public void onCompleted() {
-                                s.onCompleted();
+                                child.onCompleted();
                             }
 
                             @Override
                             public void onError(Throwable e) {
                                 if ((retryCount == INFINITE_RETRY || attempts.get() <= retryCount) && !inner.isUnsubscribed()) {
                                     // retry again
-                                    inner.schedule(new Action1<Inner>() {
-                                        @Override
-                                        public void call(Inner inner)
-                                        {
-                                            // Remove the failed subscription first
-                                            retrySub.get().unsubscribe();
-                                            _self.call(inner);
-                                        }
-                                    });
+                                    inner.schedule(_self);
                                 } else {
                                     // give up and pass the failure
-                                    s.onError(e);
+                                    child.onError(e);
                                 }
                             }
 
                             @Override
                             public void onNext(T v) {
-                                s.onNext(v);
+                                child.onNext(v);
                             }
 
-                        }));
+                        };
+                        // register this Subscription (and unsubscribe previous if exists) 
+                        serialSubscription.set(subscriber);
+                        o.unsafeSubscribe(subscriber);
                     }
                 });
             }

From d521bccac1f608671019c222cbba024cc6aec82b Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Fri, 4 Apr 2014 17:27:11 +0000
Subject: [PATCH 197/422] [Gradle Release Plugin] - pre tag commit:  '0.17.5'.

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

diff --git a/gradle.properties b/gradle.properties
index 27afea0ddf..8f55517bc7 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.5-SNAPSHOT
+version=0.17.5

From 6a6c2a966e88268ee755ce4db53e6f4274aa61e5 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Fri, 4 Apr 2014 17:27:15 +0000
Subject: [PATCH 198/422] [Gradle Release Plugin] - new version commit: 
 '0.17.6-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index 8f55517bc7..fada833319 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.5
+version=0.17.6-SNAPSHOT

From 3c6fbe0bb170e45ed072b82adef8b34f63100a79 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Fri, 4 Apr 2014 10:34:47 -0700
Subject: [PATCH 199/422] Version 0.17.5

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

diff --git a/CHANGES.md b/CHANGES.md
index 46c644ed27..fa6f37834d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,11 @@
 # RxJava Releases #
 
+### Version 0.17.5 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.5%22)) ###
+
+* [Pull 1010] (https://github.com/Netflix/RxJava/pull/1010) Observable.unsafeSubscribe
+* [Pull 1015] (https://github.com/Netflix/RxJava/pull/1015) Remove Redundant protectivelyWrap Method
+* [Pull 1019] (https://github.com/Netflix/RxJava/pull/1019) Fix: retry() never unsubscribes from source until operator completes 
+
 ### Version 0.17.4 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.4%22)) ###
 
 * [Pull 990] (https://github.com/Netflix/RxJava/pull/990) Quasar Lightweight Threads/Fibers Contrib Module

From effc6ab6ed1f638f71aea722e960b38762d9f945 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Sat, 5 Apr 2014 17:29:21 +0200
Subject: [PATCH 200/422] Upgrade Gradle wrapper for Android samples to Gradle
 1.11

Android Studio 0.5.4 refuses to build with 1.10
---
 .../gradle/wrapper/gradle-wrapper.properties                  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
index a4b6756f97..acc117c91f 100644
--- a/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
+++ b/rxjava-contrib/rxjava-android-samples/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Wed Mar 12 12:09:46 CET 2014
+#Sat Apr 05 11:18:06 CEST 2014
 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.11-all.zip

From bc6ad010149592a3e868ffd0c6e7be5f9a2dbb80 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Sun, 6 Apr 2014 11:42:04 +0200
Subject: [PATCH 201/422] OperatorWeakBinding to not use WeakReferences anymore

related issues:
https://github.com/Netflix/RxJava/pull/1008
https://github.com/Netflix/RxJava/issues/1006
https://github.com/Netflix/RxJava/issues/979
---
 .../samples/src/main/AndroidManifest.xml      |   9 ++
 .../android/samples/ListenInOutActivity.java  |  87 ++++++++++++++
 .../samples/ListeningFragmentActivity.java    |   6 +-
 .../samples/RetainedFragmentActivity.java     |   9 +-
 .../res/layout/listen_in_out_activity.xml     |  28 +++++
 .../observables/AndroidObservable.java        |  30 +++--
 .../rx/operators/OperatorWeakBinding.java     | 108 +++++++-----------
 .../rx/operators/OperatorWeakBindingTest.java |  75 +++++-------
 8 files changed, 222 insertions(+), 130 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListenInOutActivity.java
 create mode 100644 rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listen_in_out_activity.xml

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
index f307d55bb0..b4a1d24633 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
@@ -29,6 +29,15 @@
         <activity
             android:name=".ListFragmentActivity">
 
+            <intent-filter>
+                <category android:name="android.intent.category.LAUNCHER"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".ListenInOutActivity">
+
             <intent-filter>
                 <category android:name="android.intent.category.LAUNCHER"/>
                 <category android:name="android.intent.category.DEFAULT"/>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListenInOutActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListenInOutActivity.java
new file mode 100644
index 0000000000..893124b2f2
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListenInOutActivity.java
@@ -0,0 +1,87 @@
+package com.netflix.rxjava.android.samples;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.TextView;
+import android.widget.Toast;
+import android.widget.ToggleButton;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Subscription;
+import rx.observables.ConnectableObservable;
+
+import static rx.android.observables.AndroidObservable.bindActivity;
+
+/**
+ * Activity that binds to a counting sequence and is able to listen in and out to that
+ * sequence by pressing a toggle button. The button disables itself once the sequence
+ * finishes.
+ */
+public class ListenInOutActivity extends Activity implements Observer<String> {
+
+    private Observable<String> source;
+    private Subscription subscription;
+    private TextView textView;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.listen_in_out_activity);
+
+        textView = (TextView) findViewById(android.R.id.text1);
+
+        // in a production app, you would use dependency injection, fragments, or other
+        // means to preserve the observable, but this will suffice here
+        source = (Observable<String>) getLastNonConfigurationInstance();
+        if (source == null) {
+            source = SampleObservables.numberStrings(1, 100, 200).publish();
+            ((ConnectableObservable) source).connect();
+        }
+
+        subscribeToSequence();
+    }
+
+    private void subscribeToSequence() {
+        subscription = bindActivity(this, source).subscribe(this);
+    }
+
+    @Override
+    public Object onRetainNonConfigurationInstance() {
+        return source;
+    }
+
+    @Override
+    protected void onDestroy() {
+        subscription.unsubscribe();
+        super.onDestroy();
+    }
+
+    @Override
+    public void onCompleted() {
+        TextView button = (TextView) findViewById(R.id.toggle_button);
+        button.setText("Completed");
+        button.setEnabled(false);
+    }
+
+    @Override
+    public void onError(Throwable e) {
+        e.printStackTrace();
+        Toast.makeText(this, "Error: " + e, Toast.LENGTH_SHORT).show();
+    }
+
+    @Override
+    public void onNext(String s) {
+        textView.setText(s);
+    }
+
+    public void onSequenceToggleClicked(View view) {
+        if (((ToggleButton) view).isChecked()) {
+            subscription.unsubscribe();
+        } else {
+            subscribeToSequence();
+        }
+    }
+}
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java
index b402135bc1..966568fd15 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/ListeningFragmentActivity.java
@@ -14,7 +14,7 @@
 import rx.observables.ConnectableObservable;
 import rx.subscriptions.Subscriptions;
 
-import static rx.android.schedulers.AndroidSchedulers.mainThread;
+import static rx.android.observables.AndroidObservable.bindFragment;
 
 /**
  * Problem:
@@ -52,7 +52,7 @@ public ListeningFragment() {
         public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
 
-            strings = SampleObservables.numberStrings(1, 50, 250).observeOn(mainThread()).publish();
+            strings = SampleObservables.numberStrings(1, 50, 250).publish();
             strings.connect(); // trigger the sequence
         }
 
@@ -74,7 +74,7 @@ public void onViewCreated(final View view, Bundle savedInstanceState) {
             final TextView textView = (TextView) view.findViewById(android.R.id.text1);
 
             // re-connect to sequence
-            subscription = strings.subscribe(new Subscriber<String>() {
+            subscription = bindFragment(this, strings).subscribe(new Subscriber<String>() {
 
                 @Override
                 public void onCompleted() {
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
index 82c5225101..dc8706a24a 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
@@ -14,11 +14,12 @@
 
 import rx.Observable;
 import rx.Subscription;
-import rx.android.schedulers.AndroidSchedulers;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
 
+import static rx.android.observables.AndroidObservable.bindFragment;
+
 /**
  * Problem:
  * You have a data source (where that data is potentially expensive to obtain), and you want to
@@ -68,9 +69,7 @@ public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
 
             // simulate fetching a JSON document with a latency of 2 seconds
-            strings = SampleObservables.fakeApiCall(2000).map(PARSE_JSON)
-                    .observeOn(AndroidSchedulers.mainThread())
-                    .cache();
+            strings = SampleObservables.fakeApiCall(2000).map(PARSE_JSON).cache();
         }
 
         @Override
@@ -93,7 +92,7 @@ public void onViewCreated(final View view, Bundle savedInstanceState) {
 
             // (re-)subscribe to the sequence, which either emits the cached result or simply re-
             // attaches the subscriber to wait for it to arrive
-            subscription = strings.subscribe(new Action1<String>() {
+            subscription = bindFragment(this, strings).subscribe(new Action1<String>() {
                 @Override
                 public void call(String result) {
                     textView.setText(result);
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listen_in_out_activity.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listen_in_out_activity.xml
new file mode 100644
index 0000000000..bc2c1e1a99
--- /dev/null
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/listen_in_out_activity.xml
@@ -0,0 +1,28 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:paddingLeft="@dimen/activity_horizontal_margin"
+    android:paddingRight="@dimen/activity_horizontal_margin"
+    android:paddingTop="@dimen/activity_vertical_margin"
+    android:paddingBottom="@dimen/activity_vertical_margin"
+    tools:context="com.netflix.rxjava.android.samples.ListenInOutActivity">
+
+    <TextView
+        android:id="@android:id/text1"
+        android:layout_centerInParent="true"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content" />
+
+    <ToggleButton
+        android:id="@+id/toggle_button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_below="@android:id/text1"
+        android:layout_centerHorizontal="true"
+        android:textOff="Pause"
+        android:textOn="Resume"
+        android:onClick="onSequenceToggleClicked" />
+
+
+</RelativeLayout>
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 46d0e48285..e0fafb14bc 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
@@ -51,7 +51,7 @@ public Boolean call(Activity activity) {
     private static final Func1<Fragment, Boolean> FRAGMENT_VALIDATOR = new Func1<Fragment, Boolean>() {
         @Override
         public Boolean call(Fragment fragment) {
-            return fragment.isAdded();
+            return fragment.isAdded() && !fragment.getActivity().isFinishing();
         }
     };
 
@@ -59,7 +59,7 @@ public Boolean call(Fragment fragment) {
             new Func1<android.support.v4.app.Fragment, Boolean>() {
                 @Override
                 public Boolean call(android.support.v4.app.Fragment fragment) {
-                    return fragment.isAdded();
+                    return fragment.isAdded() && !fragment.getActivity().isFinishing();
                 }
             };
 
@@ -131,11 +131,15 @@ public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sour
     }
 
     /**
-     * Binds the given source sequence to the life-cycle of an activity.
+     * Binds the given source sequence to an activity.
      * <p/>
      * This helper will schedule the given sequence to be observed on the main UI thread and ensure
-     * that no notifications will be forwarded to the activity in case it gets destroyed by the Android runtime
-     * or garbage collected by the VM.
+     * that no notifications will be forwarded to the activity in case it is scheduled to finish.
+     * <p/>
+     * You should unsubscribe from the returned Observable in onDestroy at the latest, in order to not
+     * leak the activity or an inner subscriber. Conversely, when the source sequence can outlive the activity,
+     * make sure to bind to new instances of the activity again, e.g. after going through configuration changes.
+     * Refer to the samples project for actual examples.
      *
      * @param activity the activity to bind the source sequence to
      * @param source   the source sequence
@@ -146,24 +150,28 @@ public static <T> Observable<T> bindActivity(Activity activity, Observable<T> so
     }
 
     /**
-     * Binds the given source sequence to the life-cycle of a fragment (native or support-v4).
+     * Binds the given source sequence to a fragment (native or support-v4).
      * <p/>
      * This helper will schedule the given sequence to be observed on the main UI thread and ensure
      * that no notifications will be forwarded to the fragment in case it gets detached from its
-     * activity or garbage collected by the VM.
+     * activity or the activity is scheduled to finish.
+     * <p/>
+     * You should unsubscribe from the returned Observable in onDestroy for normal fragments, or in onDestroyView
+     * for retained fragments, in order to not leak any references to the host activity or the fragment.
+     * Refer to the samples project for actual examples.
      *
      * @param fragment the fragment to bind the source sequence to
      * @param source   the source sequence
      */
-    public static <T> Observable<T> bindFragment(Object fragment, Observable<T> cachedSequence) {
+    public static <T> Observable<T> bindFragment(Object fragment, Observable<T> source) {
         Assertions.assertUiThread();
-        final Observable<T> source = cachedSequence.observeOn(mainThread());
+        final Observable<T> o = source.observeOn(mainThread());
         if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
             android.support.v4.app.Fragment f = (android.support.v4.app.Fragment) fragment;
-            return source.lift(new OperatorWeakBinding<T, android.support.v4.app.Fragment>(f, FRAGMENTV4_VALIDATOR));
+            return o.lift(new OperatorWeakBinding<T, android.support.v4.app.Fragment>(f, FRAGMENTV4_VALIDATOR));
         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && fragment instanceof Fragment) {
             Fragment f = (Fragment) fragment;
-            return source.lift(new OperatorWeakBinding<T, Fragment>(f, FRAGMENT_VALIDATOR));
+            return o.lift(new OperatorWeakBinding<T, Fragment>(f, FRAGMENT_VALIDATOR));
         } 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/operators/OperatorWeakBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
index 3cc8258302..d0e37fdab5 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
@@ -7,12 +7,9 @@
 
 import android.util.Log;
 
-import java.lang.ref.WeakReference;
-
 /**
- * Ties a source sequence to the life-cycle of the given target object, and/or the subscriber
- * using weak references. When either object is gone, this operator automatically unsubscribes
- * from the source sequence.
+ * Ties a source sequence to the given target object using a predicate. If the predicate fails
+ * to validate, the sequence unsubscribes itself and releases the bound reference.
  * <p/>
  * You can also pass in an optional predicate function, which whenever it evaluates to false
  * on the target object, will also result in the operator unsubscribing from the sequence.
@@ -24,88 +21,71 @@ public final class OperatorWeakBinding<T, R> implements Observable.Operator<T, T
 
     private static final String LOG_TAG = "WeakBinding";
 
-    final WeakReference<R> boundRef;
+    private R boundRef;
     private final Func1<? super R, Boolean> predicate;
 
     public OperatorWeakBinding(R bound, Func1<? super R, Boolean> predicate) {
-        boundRef = new WeakReference<R>(bound);
+        boundRef = bound;
         this.predicate = predicate;
     }
 
     public OperatorWeakBinding(R bound) {
-        boundRef = new WeakReference<R>(bound);
+        boundRef = bound;
         this.predicate = Functions.alwaysTrue();
     }
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> child) {
-        return new WeakSubscriber(child);
-    }
-
-    final class WeakSubscriber extends Subscriber<T> {
-
-        final WeakReference<Subscriber<? super T>> subscriberRef;
+        return new  Subscriber<T>(child) {
 
-        private WeakSubscriber(Subscriber<? super T> source) {
-            super(source);
-            subscriberRef = new WeakReference<Subscriber<? super T>>(source);
-        }
+            @Override
+            public void onCompleted() {
+                if (shouldForwardNotification()) {
+                    child.onCompleted();
+                } else {
+                    handleLostBinding("onCompleted");
+                }
+            }
 
-        @Override
-        public void onCompleted() {
-            final Subscriber<? super T> sub = subscriberRef.get();
-            if (shouldForwardNotification(sub)) {
-                sub.onCompleted();
-            } else {
-                handleLostBinding(sub, "onCompleted");
+            @Override
+            public void onError(Throwable e) {
+                if (shouldForwardNotification()) {
+                    child.onError(e);
+                } else {
+                    handleLostBinding("onError");
+                }
             }
-        }
 
-        @Override
-        public void onError(Throwable e) {
-            final Subscriber<? super T> sub = subscriberRef.get();
-            if (shouldForwardNotification(sub)) {
-                sub.onError(e);
-            } else {
-                handleLostBinding(sub, "onError");
+            @Override
+            public void onNext(T t) {
+                if (shouldForwardNotification()) {
+                    child.onNext(t);
+                } else {
+                    handleLostBinding("onNext");
+                }
             }
-        }
 
-        @Override
-        public void onNext(T t) {
-            final Subscriber<? super T> sub = subscriberRef.get();
-            if (shouldForwardNotification(sub)) {
-                sub.onNext(t);
-            } else {
-                handleLostBinding(sub, "onNext");
+            private boolean shouldForwardNotification() {
+                return boundRef != null && predicate.call(boundRef);
             }
-        }
 
-        private boolean shouldForwardNotification(Subscriber<? super T> sub) {
-            final R target = boundRef.get();
-            return sub != null && target != null && predicate.call(target);
-        }
+            private void handleLostBinding(String context) {
+                log("bound object has become invalid; skipping " + context);
+                log("unsubscribing...");
+                boundRef = null;
+                unsubscribe();
+            }
 
-        private void handleLostBinding(Subscriber<? super T> sub, String context) {
-            if (sub == null) {
-                log("subscriber gone; skipping " + context);
-            } else {
-                final R r = boundRef.get();
-                if (r != null) {
-                    // the predicate failed to validate
-                    log("bound component has become invalid; skipping " + context);
-                } else {
-                    log("bound component gone; skipping " + context);
+            private void log(String message) {
+                if (Log.isLoggable(LOG_TAG, Log.DEBUG)) {
+                    Log.d(LOG_TAG, message);
                 }
             }
-            log("unsubscribing...");
-            unsubscribe();
-        }
+        };
+    }
 
-        private void log(String message) {
-            if (Log.isLoggable(LOG_TAG, Log.DEBUG)) {
-                Log.d(LOG_TAG, message);
-            }
-        }
+    /* Visible for testing */
+    R getBoundRef() {
+        return boundRef;
     }
 }
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
index 6dd72c606d..c27f207467 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
@@ -1,16 +1,19 @@
 package rx.operators;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
+import rx.Subscriber;
+import rx.functions.Func1;
 import rx.functions.Functions;
 import rx.observers.TestSubscriber;
 
-import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 @RunWith(RobolectricTestRunner.class)
 public class OperatorWeakBindingTest {
@@ -23,49 +26,27 @@ public void setUp() throws Exception {
     }
 
     @Test
-    public void shouldForwardAllNotificationsWhenSubscriberAndTargetAlive() {
-        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
-        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
-        weakSub.onNext("one");
-        weakSub.onNext("two");
-        weakSub.onCompleted();
-        weakSub.onError(new Exception());
-
-        subscriber.assertReceivedOnNext(Arrays.asList("one", "two"));
-        assertEquals(1, subscriber.getOnCompletedEvents().size());
-        assertEquals(1, subscriber.getOnErrorEvents().size());
-    }
-
-    @Test
-    public void shouldUnsubscribeFromSourceSequenceWhenSubscriberReleased() {
-        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
-
-        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
-        weakSub.onNext("one");
-        weakSub.subscriberRef.clear();
-        weakSub.onNext("two");
-        weakSub.onCompleted();
-        weakSub.onError(new Exception());
-
-        subscriber.assertReceivedOnNext(Arrays.asList("one"));
-        assertEquals(0, subscriber.getOnCompletedEvents().size());
-        assertEquals(0, subscriber.getOnErrorEvents().size());
-    }
-
-    @Test
-    public void shouldUnsubscribeFromSourceSequenceWhenTargetObjectReleased() {
-        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
-
-        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
-        weakSub.onNext("one");
-        op.boundRef.clear();
-        weakSub.onNext("two");
-        weakSub.onCompleted();
-        weakSub.onError(new Exception());
-
-        subscriber.assertReceivedOnNext(Arrays.asList("one"));
+    public void shouldReleaseBoundReferenceIfPredicateFailsToPass() {
+        final AtomicBoolean toggle = new AtomicBoolean(true);
+        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(
+                new Object(), new Func1<Object, Boolean>() {
+            @Override
+            public Boolean call(Object o) {
+                return toggle.get();
+            }
+        });
+
+        Subscriber<? super String> sub = op.call(subscriber);
+        sub.onNext("one");
+        toggle.set(false);
+        sub.onNext("two");
+        sub.onCompleted();
+        sub.onError(new Exception());
+
+        assertEquals(1, subscriber.getOnNextEvents().size());
         assertEquals(0, subscriber.getOnCompletedEvents().size());
         assertEquals(0, subscriber.getOnErrorEvents().size());
+        assertNull(op.getBoundRef());
     }
 
     @Test
@@ -73,11 +54,11 @@ public void shouldUnsubscribeFromSourceSequenceWhenPredicateFailsToPass() {
         OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(
                 new Object(), Functions.alwaysFalse());
 
-        OperatorWeakBinding.WeakSubscriber weakSub = (OperatorWeakBinding.WeakSubscriber) op.call(subscriber);
-        weakSub.onNext("one");
-        weakSub.onNext("two");
-        weakSub.onCompleted();
-        weakSub.onError(new Exception());
+        Subscriber<? super String> sub = op.call(subscriber);
+        sub.onNext("one");
+        sub.onNext("two");
+        sub.onCompleted();
+        sub.onError(new Exception());
 
         assertEquals(0, subscriber.getOnNextEvents().size());
         assertEquals(0, subscriber.getOnCompletedEvents().size());

From d9fef71f51a261dbe1ad78c2a9a42d2c9b1acb8b Mon Sep 17 00:00:00 2001
From: Peter McDonnell <petermd@gmail.com>
Date: Tue, 8 Apr 2014 20:35:38 +0100
Subject: [PATCH 202/422] isolate subscriber used for retries, cleanup tests

---
 .../main/java/rx/operators/OperatorRetry.java |   2 +-
 .../java/rx/operators/OperatorRetryTest.java  | 232 +++++++++++-------
 2 files changed, 146 insertions(+), 88 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index 31057ccc49..1e1e9539f8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -82,7 +82,7 @@ public void call(final Inner inner) {
                         final Action1<Inner> _self = this;
                         attempts.incrementAndGet();
 
-                        Subscriber<T> subscriber = new Subscriber<T>(child) {
+                        Subscriber<T> subscriber = new Subscriber<T>() {
 
                             @Override
                             public void onCompleted() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
index 97ea46adf5..f1f1a83a0c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
@@ -21,6 +21,7 @@
 
 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;
@@ -31,6 +32,7 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
@@ -150,93 +152,6 @@ public void call(Integer n) {
         assertEquals(1, count.get());
     }
 
-    public static class SlowFuncAlwaysFails implements Observable.OnSubscribe<String> {
-
-        final AtomicInteger nextSeq=new AtomicInteger();
-        final AtomicInteger activeSubs=new AtomicInteger();
-        final AtomicInteger concurrentSubs=new AtomicInteger();
-
-        public void call(final Subscriber<? super String> s)
-        {
-            final int seq=nextSeq.incrementAndGet();
-
-            int cur=activeSubs.incrementAndGet();
-            // Track concurrent subscriptions
-            concurrentSubs.set(Math.max(cur,concurrentSubs.get()));
-
-            // Use async error
-            new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        Thread.sleep(100);
-                    } catch (InterruptedException e) {
-                        // ignore
-                    }
-                    s.onError(new RuntimeException("Subscriber #"+seq+" fails"));
-                }
-            }).start();
-
-            // Track unsubscribes
-            s.add(new Subscription()
-            {
-                private boolean active=true;
-
-                public void unsubscribe()
-                {
-                    if (active) {
-                        activeSubs.decrementAndGet();
-                        active=false;
-                    }
-                }
-
-                public boolean isUnsubscribed()
-                {
-                    return !active;
-                }
-            });
-        }
-    }
-
-    @Test
-    public void testUnsubscribeAfterError() {
-
-        final CountDownLatch check=new CountDownLatch(1);
-        final SlowFuncAlwaysFails sf=new SlowFuncAlwaysFails();
-
-        Observable
-            .create(sf)
-            .retry(4)
-            .subscribe(
-                new Action1<String>()
-                {
-                    @Override
-                    public void call(String v)
-                    {
-                        fail("Should never happen");
-                    }
-                },
-                new Action1<Throwable>()
-                {
-                    public void call(Throwable throwable)
-                    {
-                        check.countDown();
-                    }
-                }
-            );
-
-        try
-        {
-            check.await(1, TimeUnit.SECONDS);
-        } catch (InterruptedException e)
-        {
-            fail("interrupted");
-        }
-
-        assertEquals("5 Subscribers created", 5, sf.nextSeq.get());
-        assertEquals("1 Active Subscriber", 1, sf.concurrentSubs.get());
-    }
-
     @Test
     public void testRetryAllowsSubscriptionAfterAllSubscriptionsUnsubsribed() throws InterruptedException {
         final AtomicInteger subsCount = new AtomicInteger(0);
@@ -269,4 +184,147 @@ public boolean isUnsubscribed() {
         streamWithRetry.subscribe();
         assertEquals(1, subsCount.get());
     }
+
+    class SlowObservable implements Observable.OnSubscribe<Long> {
+
+        private AtomicInteger efforts=new AtomicInteger(0);
+        private AtomicInteger active=new AtomicInteger(0),maxActive=new AtomicInteger(0);
+        private AtomicInteger nextBeforeFailure;
+
+        private final int emitDelay;
+
+        public SlowObservable(int emitDelay,int countNext) {
+            this.emitDelay=emitDelay;
+            this.nextBeforeFailure=new AtomicInteger(countNext);
+        }
+
+        public void call(final Subscriber<? super Long> subscriber) {
+            final AtomicBoolean terminate=new AtomicBoolean(false);
+            efforts.getAndIncrement();
+            active.getAndIncrement();
+            maxActive.set(Math.max(active.get(),maxActive.get()));
+            final Thread thread = new Thread() {
+                @Override
+                public void run() {
+                    long nr = 0;
+                    try {
+                        while (!terminate.get()) {
+                            Thread.sleep(emitDelay);
+                            if (nextBeforeFailure.getAndDecrement()>0) {
+                                subscriber.onNext(nr++);
+                            }
+                            else {
+                                subscriber.onError(new RuntimeException("expected-failed"));
+                            }
+                        }
+                    }
+                    catch(InterruptedException t) {
+                    }
+                }
+            };
+            thread.start();
+            subscriber.add(Subscriptions.create(new Action0() {
+                @Override
+                public void call() {
+                    terminate.set(true);
+                    active.decrementAndGet();
+                }
+            }));
+        }
+    }
+
+    /** Observer for listener on seperate thread */
+    class AsyncObserver<T> implements Observer<T> {
+
+        protected CountDownLatch latch=new CountDownLatch(1);
+
+        protected Observer<T> target;
+
+        /** Wrap existing Observer */
+        public AsyncObserver(Observer<T> target) {
+            this.target=target;
+        }
+
+        /** Wait */
+        public void await() {
+            try {
+                latch.await();
+            } catch (InterruptedException e) {
+                fail("Test interrupted");
+            }
+        }
+
+        // Observer implementation
+
+        @Override
+        public void onCompleted() {
+            target.onCompleted();
+            latch.countDown();
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            target.onError(t);
+            latch.countDown();
+        }
+
+        @Override
+        public void onNext(T v) {
+            target.onNext(v);
+        }
+    }
+
+    @Test
+    public void testUnsubscribeAfterError() {
+
+        @SuppressWarnings("unchecked")
+        Observer<Long> observer=mock(Observer.class);
+
+        // Observable that always fails after 100ms
+        SlowObservable so=new SlowObservable(100,0);
+        Observable<Long> o=Observable
+            .create(so)
+            .retry(5);
+
+        AsyncObserver<Long> async=new AsyncObserver<Long>(observer);
+
+        o.subscribe(async);
+
+        async.await();
+
+        InOrder inOrder = inOrder(observer);
+        // Should fail once
+        inOrder.verify(observer, times(1)).onError(any(Throwable.class));
+        inOrder.verify(observer, never()).onCompleted();
+
+        assertEquals("Start 6 threads, retry 5 then fail on 6",6,so.efforts.get());
+        assertEquals("Only 1 active subscription",1,so.maxActive.get());
+    }
+
+    @Test
+    public void testTimeoutWithRetry() {
+
+        @SuppressWarnings("unchecked")
+        Observer<Long> observer=mock(Observer.class);
+
+        // Observable that sends every 100ms (timeout fails instead)
+        SlowObservable so=new SlowObservable(100,10);
+        Observable<Long> o=Observable
+            .create(so)
+            .timeout(80, TimeUnit.MILLISECONDS)
+            .retry(5);
+
+        AsyncObserver<Long> async=new AsyncObserver<Long>(observer);
+
+        o.subscribe(async);
+
+        async.await();
+
+        InOrder inOrder = inOrder(observer);
+        // Should fail once
+        inOrder.verify(observer, times(1)).onError(any(Throwable.class));
+        inOrder.verify(observer, never()).onCompleted();
+
+        assertEquals("Start 6 threads, retry 5 then fail on 6",6,so.efforts.get());
+    }
 }

From bb46e032dd257dc02c029ffdb0baf2a7816eb114 Mon Sep 17 00:00:00 2001
From: Zachary Siegel <zsiegel87@gmail.com>
Date: Thu, 10 Apr 2014 02:28:43 -0500
Subject: [PATCH 203/422] Updating the new sample to demonstrate UI binding

This commit binds the observable to a method where a user can update their UI accordingly.
---
 .../samples/src/main/AndroidManifest.xml      |  2 +-
 ...ActivityV2.java => UIBindingActivity.java} | 66 +++++++++++--------
 ...ctivity_v2.xml => ui_binding_activity.xml} |  2 +-
 3 files changed, 39 insertions(+), 31 deletions(-)
 rename rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/{RetainedFragmentActivityV2.java => UIBindingActivity.java} (61%)
 rename rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/{retained_fragment_activity_v2.xml => ui_binding_activity.xml} (84%)

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
index bc5af1ecb8..00da2c7336 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/AndroidManifest.xml
@@ -9,7 +9,7 @@
         android:theme="@style/AppTheme"
         android:label="@string/app_name">
         <activity
-                android:name=".RetainedFragmentActivityV2">
+                android:name=".UIBindingActivity">
 
             <intent-filter>
                 <category android:name="android.intent.category.LAUNCHER"/>
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivityV2.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/UIBindingActivity.java
similarity index 61%
rename from rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivityV2.java
rename to rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/UIBindingActivity.java
index 25736d12fc..8d4508846c 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivityV2.java
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/UIBindingActivity.java
@@ -19,32 +19,32 @@
 import rx.subscriptions.Subscriptions;
 
 /**
- * A retained fragment whose goals are below
- *
- * 1) gracefully handle rotation - not losing any data
- * 2) gracefully handle the user moving in and out of the app
- * 3) use a button or trigger of some sort to start the observable, something more in line with typical use
- * 4) ensure that the callbacks are not called if the user moves away from the fragment
+ * Problem:
+ * You have a data source (where that data is potentially expensive to obtain), and you want to
+ * emit this data into a fragment. However, you want to gracefully deal with rotation changes and
+ * not lose any data already emitted.
+ * <p/>
+ * You also want your UI to update accordingly to the data being emitted.
  *
  * @author zsiegel (zsiegel87@gmail.com)
  */
-public class RetainedFragmentActivityV2 extends Activity {
+public class UIBindingActivity extends Activity {
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
-        setTitle("Fake API call V2");
-        setContentView(R.layout.retained_fragment_activity_v2);
+        setTitle("UIBinding");
+        setContentView(R.layout.ui_binding_activity);
     }
 
     @SuppressWarnings("ConstantConditions")
-    public static class RetainedFragmentV2 extends Fragment {
+    public static class RetainedBindingFragment extends Fragment {
 
-        private Observable<String> observable;
-        private Subscription subscription = Subscriptions.empty();
         private Button startButton;
-        private boolean progressVisiblity;
+
+        private Observable<String> request;
+        private Subscription requestSubscription = Subscriptions.empty();
 
         // in a production app, you don't want to have JSON parser code in your fragment,
         // but we'll simplify a little here
@@ -60,7 +60,7 @@ public String call(String json) {
             }
         };
 
-        public RetainedFragmentV2() {
+        public RetainedBindingFragment() {
             setRetainInstance(true);
         }
 
@@ -69,7 +69,7 @@ public RetainedFragmentV2() {
          */
         @Override
         public void onPause() {
-            subscription.unsubscribe();
+            requestSubscription.unsubscribe();
             super.onPause();
         }
 
@@ -91,7 +91,7 @@ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle sa
         public void onViewCreated(final View view, Bundle savedInstanceState) {
             super.onViewCreated(view, savedInstanceState);
 
-            final TextView textView = (TextView)getView().findViewById(android.R.id.text1);
+            final TextView textView = (TextView) getView().findViewById(android.R.id.text1);
 
             startButton = (Button) view.findViewById(R.id.button);
             startButton.setOnClickListener(new View.OnClickListener() {
@@ -99,16 +99,13 @@ public void onViewCreated(final View view, Bundle savedInstanceState) {
                 public void onClick(View v) {
                     textView.setText("");
                     start();
-                    startButton.setEnabled(false);
                 }
             });
         }
 
         private void start() {
 
-            progressVisiblity = true;
-
-            observable = SampleObservables
+            request = SampleObservables
                     .fakeApiCall(5000)
                     .map(PARSE_JSON)
                     .observeOn(AndroidSchedulers.mainThread())
@@ -121,22 +118,33 @@ private void start() {
          * We subscribe/re-subscribe here
          */
         private void subscribe() {
-            if (observable != null) {
+            if (request != null) {
+
+                final TextView textView = (TextView) getView().findViewById(android.R.id.text1);
 
-                getActivity().setProgressBarIndeterminateVisibility(progressVisiblity);
+                requestSubscription = request.map(new Func1<String, Boolean>() {
 
-                final TextView textView = (TextView)getView().findViewById(android.R.id.text1);
+                    //Consume the data that comes back and then signal that we are done
+                    @Override
+                    public Boolean call(String s) {
+                        textView.setText(s);
+                        return true;
+                    }
+                }).startWith(false) //Before we receive data our request is not complete
+                  .subscribe(new Action1<Boolean>() {
 
-                subscription = observable.subscribe(new Action1<String>() {
+                    //We update the UI based on the state of the request
                     @Override
-                    public void call(String result) {
-                        textView.setText(result);
-                        progressVisiblity = false;
-                        getActivity().setProgressBarIndeterminateVisibility(progressVisiblity);
-                        startButton.setEnabled(true);
+                    public void call(Boolean completed) {
+                        setRequestInProgress(completed);
                     }
                 });
             }
         }
+
+        private void setRequestInProgress(boolean completed) {
+            getActivity().setProgressBarIndeterminateVisibility(!completed);
+            startButton.setEnabled(completed);
+        }
     }
 }
diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity_v2.xml b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/ui_binding_activity.xml
similarity index 84%
rename from rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity_v2.xml
rename to rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/ui_binding_activity.xml
index a6fe72f624..106d534af5 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/retained_fragment_activity_v2.xml
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/res/layout/ui_binding_activity.xml
@@ -8,7 +8,7 @@
             android:tag="retained_fragment_v2"
             android:layout_width="match_parent"
             android:layout_height="match_parent"
-            android:name="com.netflix.rxjava.android.samples.RetainedFragmentActivityV2$RetainedFragmentV2"
+            android:name="com.netflix.rxjava.android.samples.UIBindingActivity$RetainedBindingFragment"
             tools:layout="@layout/retained_fragment" />
 
 </RelativeLayout>

From 329a0936d48bdbfd194ea48055e11718c65d9da6 Mon Sep 17 00:00:00 2001
From: Michael Nitschinger <michael@nitschinger.at>
Date: Fri, 11 Apr 2014 20:04:21 +0200
Subject: [PATCH 204/422] Benchmarking: Add JMH benchmark for ReplaySubject.

---
 .../src/perf/java/rx/jmh/Baseline.java        | 15 +++
 .../java/rx/operators/OperatorMapPerf.java    | 15 +++
 .../rx/operators/OperatorSerializePerf.java   | 15 +++
 .../java/rx/subjects/ReplaySubjectPerf.java   | 98 +++++++++++++++++++
 4 files changed, 143 insertions(+)
 create mode 100644 rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java

diff --git a/rxjava-core/src/perf/java/rx/jmh/Baseline.java b/rxjava-core/src/perf/java/rx/jmh/Baseline.java
index 549118752f..c12f540aaa 100644
--- a/rxjava-core/src/perf/java/rx/jmh/Baseline.java
+++ b/rxjava-core/src/perf/java/rx/jmh/Baseline.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.jmh;
 
 import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
index 70074b4b08..2a41151e45 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.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.CountDownLatch;
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java
index a130c0711c..925e9906c7 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.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.CountDownLatch;
diff --git a/rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java b/rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java
new file mode 100644
index 0000000000..84bce3b841
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java
@@ -0,0 +1,98 @@
+/**
+ * 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.subjects;
+
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.logic.BlackHole;
+import rx.Observer;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Benchmarks the {@link ReplaySubject}.
+ */
+public class ReplaySubjectPerf {
+
+    @State(Scope.Thread)
+    public static class Input {
+        @Param({ "1", "512", "1024", "1048576" })
+        public int nextRuns;
+    }
+
+    @GenerateMicroBenchmark
+    public void subscribeBeforeEvents(final Input input, final BlackHole bh) throws Exception {
+        ReplaySubject<Object> subject = ReplaySubject.create();
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicLong sum = new AtomicLong();
+
+        subject.subscribe(new Observer<Object>() {
+            @Override
+            public void onCompleted() {
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+            }
+
+            @Override
+            public void onNext(Object o) {
+                sum.incrementAndGet();
+            }
+        });
+        for (int i = 0; i < input.nextRuns; i++) {
+            subject.onNext("Response");
+        }
+        subject.onCompleted();
+        latch.await();
+        bh.consume(sum);
+    }
+
+    @GenerateMicroBenchmark
+    public void subscribeAfterEvents(final Input input, final BlackHole bh) throws Exception {
+        ReplaySubject<Object> subject = ReplaySubject.create();
+        final CountDownLatch latch = new CountDownLatch(1);
+        final AtomicLong sum = new AtomicLong();
+
+        for (int i = 0; i < input.nextRuns; i++) {
+            subject.onNext("Response");
+        }
+        subject.onCompleted();
+
+        subject.subscribe(new Observer<Object>() {
+            @Override
+            public void onCompleted() {
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+            }
+
+            @Override
+            public void onNext(Object o) {
+                sum.incrementAndGet();
+            }
+        });
+        latch.await();
+        bh.consume(sum);
+    }
+
+}

From 42558e8f564338f0b961ce06fdaee0eb2139959d Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Fri, 11 Apr 2014 12:23:54 -0700
Subject: [PATCH 205/422] exclude tests

excluding out all tests until they stop hanging CloudBees
---
 rxjava-contrib/rxjava-quasar/build.gradle | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/rxjava-contrib/rxjava-quasar/build.gradle b/rxjava-contrib/rxjava-quasar/build.gradle
index fdcac9663f..1f8ddb5d8f 100644
--- a/rxjava-contrib/rxjava-quasar/build.gradle
+++ b/rxjava-contrib/rxjava-quasar/build.gradle
@@ -38,3 +38,8 @@ tasks.withType(Test) {
 tasks.withType(JavaExec) {
     jvmArgs "-javaagent:${configurations.quasar.iterator().next()}" // =vdmc (verbose, debug, allow monitors, check class)
 }
+
+test {
+    // excluding out all tests until they stop hanging CloudBees
+    excludes = '**/*'
+}

From ef562e7cab4b97cf5e6ad6d32c526683b06c8e89 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Fri, 11 Apr 2014 12:24:25 -0700
Subject: [PATCH 206/422] Restore rxjava-scala

Accidentally commented out while doing Java 8 builds (since Scala has issues with Java 8)
---
 settings.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/settings.gradle b/settings.gradle
index 4be7e888a2..0ee27bf3eb 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 56eebb5146fc354d10e9a10d920c7c1e71a57cc3 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 11 Apr 2014 12:35:52 -0700
Subject: [PATCH 207/422] Fix NPE in SubjectSubscriptionManager

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

diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 6f049eb38a..2b744f4515 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -94,7 +94,7 @@ public void call() {
                         }));
                         if (subscription.isUnsubscribed()) {
                             addedObserver = false;
-                            break;
+                            return;
                         }
                         // on subscribe add it to the map of outbound observers to notify
                         newState = current.addObserver(subscription, observer);

From bc387d1fac670cb6baf8693548a82be9b1bce9ea Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Fri, 11 Apr 2014 12:42:14 -0700
Subject: [PATCH 208/422] exclude tests

try that again
---
 rxjava-contrib/rxjava-quasar/build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-contrib/rxjava-quasar/build.gradle b/rxjava-contrib/rxjava-quasar/build.gradle
index 1f8ddb5d8f..e64793b384 100644
--- a/rxjava-contrib/rxjava-quasar/build.gradle
+++ b/rxjava-contrib/rxjava-quasar/build.gradle
@@ -41,5 +41,5 @@ tasks.withType(JavaExec) {
 
 test {
     // excluding out all tests until they stop hanging CloudBees
-    excludes = '**/*'
+    excludes = ['**/**']
 }

From 1e503b4127906f59b06e6d6e7e8b190287d1bb44 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 11 Apr 2014 17:05:05 -0700
Subject: [PATCH 209/422] Unit Test and Review of #1027

---
 .../main/java/rx/operators/OperatorRetry.java |   4 +
 .../java/rx/operators/OperatorRetryTest.java  | 111 +++++++++++-------
 2 files changed, 74 insertions(+), 41 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index 1e1e9539f8..ca5e7da892 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -37,9 +37,11 @@
 import rx.Observable.Operator;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.SerialSubscription;
+import rx.subscriptions.Subscriptions;
 
 public class OperatorRetry<T> implements Operator<T, Observable<T>> {
 
@@ -82,6 +84,8 @@ public void call(final Inner inner) {
                         final Action1<Inner> _self = this;
                         attempts.incrementAndGet();
 
+                        // new subscription each time so if it unsubscribes itself it does not prevent retries
+                        // by unsubscribing the child subscription
                         Subscriber<T> subscriber = new Subscriber<T>() {
 
                             @Override
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
index f1f1a83a0c..645895817b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
@@ -15,9 +15,13 @@
  */
 package rx.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.junit.Assert.fail;
+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 java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -28,12 +32,13 @@
 import org.mockito.InOrder;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 
@@ -114,7 +119,7 @@ public void testInfiniteRetry() {
         inOrder.verifyNoMoreInteractions();
     }
 
-    public static class FuncWithErrors implements Observable.OnSubscribeFunc<String> {
+    public static class FuncWithErrors implements Observable.OnSubscribe<String> {
 
         private final int numFailures;
         private final AtomicInteger count = new AtomicInteger(0);
@@ -124,7 +129,7 @@ public static class FuncWithErrors implements Observable.OnSubscribeFunc<String>
         }
 
         @Override
-        public Subscription onSubscribe(Observer<? super String> o) {
+        public void call(Subscriber<? super String> o) {
             o.onNext("beginningEveryTime");
             if (count.incrementAndGet() <= numFailures) {
                 o.onError(new RuntimeException("forced failure: " + count.get()));
@@ -132,7 +137,6 @@ public Subscription onSubscribe(Observer<? super String> o) {
                 o.onNext("onSuccessOnly");
                 o.onCompleted();
             }
-            return Subscriptions.empty();
         }
     }
 
@@ -153,13 +157,13 @@ public void call(Integer n) {
     }
 
     @Test
-    public void testRetryAllowsSubscriptionAfterAllSubscriptionsUnsubsribed() throws InterruptedException {
+    public void testRetryAllowsSubscriptionAfterAllSubscriptionsUnsubscribed() throws InterruptedException {
         final AtomicInteger subsCount = new AtomicInteger(0);
-        OnSubscribeFunc<String> onSubscribe = new OnSubscribeFunc<String>() {
+        OnSubscribe<String> onSubscribe = new OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> s) {
                 subsCount.incrementAndGet();
-                return new Subscription() {
+                s.add(new Subscription() {
                     boolean unsubscribed = false;
 
                     @Override
@@ -172,7 +176,7 @@ public void unsubscribe() {
                     public boolean isUnsubscribed() {
                         return unsubscribed;
                     }
-                };
+                });
             }
         };
         Observable<String> stream = Observable.create(onSubscribe);
@@ -185,24 +189,49 @@ public boolean isUnsubscribed() {
         assertEquals(1, subsCount.get());
     }
 
+    @Test
+    public void testSourceObservableCallsUnsubscribe() throws InterruptedException {
+        final AtomicInteger subsCount = new AtomicInteger(0);
+
+        final TestSubscriber<String> ts = new TestSubscriber<String>();
+
+        OnSubscribe<String> onSubscribe = new OnSubscribe<String>() {
+            @Override
+            public void call(Subscriber<? super String> s) {
+                // if isUnsubscribed is true that means we have a bug such as https://github.com/Netflix/RxJava/issues/1024
+                if (!s.isUnsubscribed()) {
+                    subsCount.incrementAndGet();
+                    s.onError(new RuntimeException("failed"));
+                    // it unsubscribes the child directly
+                    // this simulates various error/completion scenarios that could occur
+                    // or just a source that proactively triggers cleanup
+                    s.unsubscribe();
+                }
+            }
+        };
+
+        Observable.create(onSubscribe).retry(3).subscribe(ts);
+        assertEquals(4, subsCount.get()); // 1 + 3 retries
+    }
+
     class SlowObservable implements Observable.OnSubscribe<Long> {
 
-        private AtomicInteger efforts=new AtomicInteger(0);
-        private AtomicInteger active=new AtomicInteger(0),maxActive=new AtomicInteger(0);
+        private AtomicInteger efforts = new AtomicInteger(0);
+        private AtomicInteger active = new AtomicInteger(0), maxActive = new AtomicInteger(0);
         private AtomicInteger nextBeforeFailure;
 
         private final int emitDelay;
 
-        public SlowObservable(int emitDelay,int countNext) {
-            this.emitDelay=emitDelay;
-            this.nextBeforeFailure=new AtomicInteger(countNext);
+        public SlowObservable(int emitDelay, int countNext) {
+            this.emitDelay = emitDelay;
+            this.nextBeforeFailure = new AtomicInteger(countNext);
         }
 
         public void call(final Subscriber<? super Long> subscriber) {
-            final AtomicBoolean terminate=new AtomicBoolean(false);
+            final AtomicBoolean terminate = new AtomicBoolean(false);
             efforts.getAndIncrement();
             active.getAndIncrement();
-            maxActive.set(Math.max(active.get(),maxActive.get()));
+            maxActive.set(Math.max(active.get(), maxActive.get()));
             final Thread thread = new Thread() {
                 @Override
                 public void run() {
@@ -210,7 +239,7 @@ public void run() {
                     try {
                         while (!terminate.get()) {
                             Thread.sleep(emitDelay);
-                            if (nextBeforeFailure.getAndDecrement()>0) {
+                            if (nextBeforeFailure.getAndDecrement() > 0) {
                                 subscriber.onNext(nr++);
                             }
                             else {
@@ -218,7 +247,7 @@ public void run() {
                             }
                         }
                     }
-                    catch(InterruptedException t) {
+                    catch (InterruptedException t) {
                     }
                 }
             };
@@ -236,13 +265,13 @@ public void call() {
     /** Observer for listener on seperate thread */
     class AsyncObserver<T> implements Observer<T> {
 
-        protected CountDownLatch latch=new CountDownLatch(1);
+        protected CountDownLatch latch = new CountDownLatch(1);
 
         protected Observer<T> target;
 
         /** Wrap existing Observer */
         public AsyncObserver(Observer<T> target) {
-            this.target=target;
+            this.target = target;
         }
 
         /** Wait */
@@ -274,19 +303,19 @@ public void onNext(T v) {
         }
     }
 
-    @Test
+    @Test(timeout = 1000)
     public void testUnsubscribeAfterError() {
 
         @SuppressWarnings("unchecked")
-        Observer<Long> observer=mock(Observer.class);
+        Observer<Long> observer = mock(Observer.class);
 
         // Observable that always fails after 100ms
-        SlowObservable so=new SlowObservable(100,0);
-        Observable<Long> o=Observable
-            .create(so)
-            .retry(5);
+        SlowObservable so = new SlowObservable(100, 0);
+        Observable<Long> o = Observable
+                .create(so)
+                .retry(5);
 
-        AsyncObserver<Long> async=new AsyncObserver<Long>(observer);
+        AsyncObserver<Long> async = new AsyncObserver<Long>(observer);
 
         o.subscribe(async);
 
@@ -297,24 +326,24 @@ public void testUnsubscribeAfterError() {
         inOrder.verify(observer, times(1)).onError(any(Throwable.class));
         inOrder.verify(observer, never()).onCompleted();
 
-        assertEquals("Start 6 threads, retry 5 then fail on 6",6,so.efforts.get());
-        assertEquals("Only 1 active subscription",1,so.maxActive.get());
+        assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
+        assertEquals("Only 1 active subscription", 1, so.maxActive.get());
     }
 
-    @Test
+    @Test(timeout = 1000)
     public void testTimeoutWithRetry() {
 
         @SuppressWarnings("unchecked")
-        Observer<Long> observer=mock(Observer.class);
+        Observer<Long> observer = mock(Observer.class);
 
         // Observable that sends every 100ms (timeout fails instead)
-        SlowObservable so=new SlowObservable(100,10);
-        Observable<Long> o=Observable
-            .create(so)
-            .timeout(80, TimeUnit.MILLISECONDS)
-            .retry(5);
+        SlowObservable so = new SlowObservable(100, 10);
+        Observable<Long> o = Observable
+                .create(so)
+                .timeout(80, TimeUnit.MILLISECONDS)
+                .retry(5);
 
-        AsyncObserver<Long> async=new AsyncObserver<Long>(observer);
+        AsyncObserver<Long> async = new AsyncObserver<Long>(observer);
 
         o.subscribe(async);
 
@@ -325,6 +354,6 @@ public void testTimeoutWithRetry() {
         inOrder.verify(observer, times(1)).onError(any(Throwable.class));
         inOrder.verify(observer, never()).onCompleted();
 
-        assertEquals("Start 6 threads, retry 5 then fail on 6",6,so.efforts.get());
+        assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
     }
 }

From 0afafe3906a0ef4492a5362651ac886f8c8c060b Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Sat, 12 Apr 2014 10:21:45 +0200
Subject: [PATCH 210/422] OperatorWeakBinding -> OperatorConditionalBinding

---
 .../java/rx/android/observables/AndroidObservable.java    | 8 ++++----
 ...orWeakBinding.java => OperatorConditionalBinding.java} | 8 ++++----
 ...ndingTest.java => OperatorConditionalBindingTest.java} | 8 ++++----
 3 files changed, 12 insertions(+), 12 deletions(-)
 rename rxjava-contrib/rxjava-android/src/main/java/rx/operators/{OperatorWeakBinding.java => OperatorConditionalBinding.java} (89%)
 rename rxjava-contrib/rxjava-android/src/test/java/rx/operators/{OperatorWeakBindingTest.java => OperatorConditionalBindingTest.java} (85%)

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 e0fafb14bc..6f26377da9 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
@@ -20,7 +20,7 @@
 import rx.Observable;
 import rx.functions.Func1;
 import rx.operators.OperatorObserveFromAndroidComponent;
-import rx.operators.OperatorWeakBinding;
+import rx.operators.OperatorConditionalBinding;
 
 import android.app.Activity;
 import android.app.Fragment;
@@ -146,7 +146,7 @@ public static <T> Observable<T> fromFragment(Object fragment, Observable<T> sour
      */
     public static <T> Observable<T> bindActivity(Activity activity, Observable<T> source) {
         Assertions.assertUiThread();
-        return source.observeOn(mainThread()).lift(new OperatorWeakBinding<T, Activity>(activity, ACTIVITY_VALIDATOR));
+        return source.observeOn(mainThread()).lift(new OperatorConditionalBinding<T, Activity>(activity, ACTIVITY_VALIDATOR));
     }
 
     /**
@@ -168,10 +168,10 @@ public static <T> Observable<T> bindFragment(Object fragment, Observable<T> sour
         final Observable<T> o = source.observeOn(mainThread());
         if (USES_SUPPORT_FRAGMENTS && fragment instanceof android.support.v4.app.Fragment) {
             android.support.v4.app.Fragment f = (android.support.v4.app.Fragment) fragment;
-            return o.lift(new OperatorWeakBinding<T, android.support.v4.app.Fragment>(f, FRAGMENTV4_VALIDATOR));
+            return o.lift(new OperatorConditionalBinding<T, android.support.v4.app.Fragment>(f, FRAGMENTV4_VALIDATOR));
         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && fragment instanceof Fragment) {
             Fragment f = (Fragment) fragment;
-            return o.lift(new OperatorWeakBinding<T, Fragment>(f, FRAGMENT_VALIDATOR));
+            return o.lift(new OperatorConditionalBinding<T, Fragment>(f, FRAGMENT_VALIDATOR));
         } 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/operators/OperatorWeakBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorConditionalBinding.java
similarity index 89%
rename from rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
rename to rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorConditionalBinding.java
index d0e37fdab5..51713367ca 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorWeakBinding.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorConditionalBinding.java
@@ -17,19 +17,19 @@
  * @param <T> the type of the objects emitted to a subscriber
  * @param <R> the type of the target object to bind to
  */
-public final class OperatorWeakBinding<T, R> implements Observable.Operator<T, T> {
+public final class OperatorConditionalBinding<T, R> implements Observable.Operator<T, T> {
 
-    private static final String LOG_TAG = "WeakBinding";
+    private static final String LOG_TAG = "ConditionalBinding";
 
     private R boundRef;
     private final Func1<? super R, Boolean> predicate;
 
-    public OperatorWeakBinding(R bound, Func1<? super R, Boolean> predicate) {
+    public OperatorConditionalBinding(R bound, Func1<? super R, Boolean> predicate) {
         boundRef = bound;
         this.predicate = predicate;
     }
 
-    public OperatorWeakBinding(R bound) {
+    public OperatorConditionalBinding(R bound) {
         boundRef = bound;
         this.predicate = Functions.alwaysTrue();
     }
diff --git a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorConditionalBindingTest.java
similarity index 85%
rename from rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
rename to rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorConditionalBindingTest.java
index c27f207467..3661dd3bc9 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorWeakBindingTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorConditionalBindingTest.java
@@ -16,7 +16,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 @RunWith(RobolectricTestRunner.class)
-public class OperatorWeakBindingTest {
+public class OperatorConditionalBindingTest {
 
     private TestSubscriber<String> subscriber = new TestSubscriber<String>();
 
@@ -28,7 +28,7 @@ public void setUp() throws Exception {
     @Test
     public void shouldReleaseBoundReferenceIfPredicateFailsToPass() {
         final AtomicBoolean toggle = new AtomicBoolean(true);
-        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(
+        OperatorConditionalBinding<String, Object> op = new OperatorConditionalBinding<String, Object>(
                 new Object(), new Func1<Object, Boolean>() {
             @Override
             public Boolean call(Object o) {
@@ -51,7 +51,7 @@ public Boolean call(Object o) {
 
     @Test
     public void shouldUnsubscribeFromSourceSequenceWhenPredicateFailsToPass() {
-        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(
+        OperatorConditionalBinding<String, Object> op = new OperatorConditionalBinding<String, Object>(
                 new Object(), Functions.alwaysFalse());
 
         Subscriber<? super String> sub = op.call(subscriber);
@@ -67,7 +67,7 @@ public void shouldUnsubscribeFromSourceSequenceWhenPredicateFailsToPass() {
 
     @Test
     public void unsubscribeWillUnsubscribeFromWrappedSubscriber() {
-        OperatorWeakBinding<String, Object> op = new OperatorWeakBinding<String, Object>(new Object());
+        OperatorConditionalBinding<String, Object> op = new OperatorConditionalBinding<String, Object>(new Object());
 
         op.call(subscriber).unsubscribe();
         subscriber.assertUnsubscribed();

From c40d9efae6bdf30d8ea1fc38c44dffb08ddf0da9 Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Sat, 12 Apr 2014 10:50:02 +0200
Subject: [PATCH 211/422] Move bindFragment call in sample to onCreate

Having it in onViewCreated is fine, but misleading, since we don't need to reattach retained fragments. (the referenced object remains the same.)
---
 .../rxjava/android/samples/RetainedFragmentActivity.java   | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
index dc8706a24a..b598fe5c72 100644
--- a/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
+++ b/rxjava-contrib/rxjava-android-samples/samples/src/main/java/com/netflix/rxjava/android/samples/RetainedFragmentActivity.java
@@ -69,7 +69,10 @@ public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
 
             // simulate fetching a JSON document with a latency of 2 seconds
-            strings = SampleObservables.fakeApiCall(2000).map(PARSE_JSON).cache();
+            // in retained fragments, it's sufficient to bind the fragment in onCreate, since
+            // Android takes care of detaching the Activity for us, and holding a reference for
+            // the duration of the observable does not harm.
+            strings = bindFragment(this, SampleObservables.fakeApiCall(2000).map(PARSE_JSON).cache());
         }
 
         @Override
@@ -92,7 +95,7 @@ public void onViewCreated(final View view, Bundle savedInstanceState) {
 
             // (re-)subscribe to the sequence, which either emits the cached result or simply re-
             // attaches the subscriber to wait for it to arrive
-            subscription = bindFragment(this, strings).subscribe(new Action1<String>() {
+            subscription = strings.subscribe(new Action1<String>() {
                 @Override
                 public void call(String result) {
                     textView.setText(result);

From d4860d8c8a815028b77cb94055513bd7a59067cd Mon Sep 17 00:00:00 2001
From: Georgi Khomeriki <g.khomeriki@gmail.com>
Date: Mon, 14 Apr 2014 11:41:18 +0200
Subject: [PATCH 212/422] replaced FRP with RP in README title

Mentioning "Functional Reactive Programming" causes confusion and misconception.
I think it's better to simply stick with "Reactive Programming".
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4486b6769d..f955055845 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# RxJava: Functional Reactive Programming on the JVM
+# RxJava: Reactive Programming on the JVM
 
 This library is a Java implementation of <a href="https://rx.codeplex.com">Rx Observables</a>.
 

From 96760afff1a51db313b6abcb608feeee2423389f Mon Sep 17 00:00:00 2001
From: Eugene Vigdorchik <eugene.vigdorchik@gmail.com>
Date: Mon, 14 Apr 2014 13:57:19 +0400
Subject: [PATCH 213/422] Simplify 'buffer' signature to be the same as
 'window'.

---
 .../src/main/scala/rx/lang/scala/Observable.scala           | 6 +++---
 1 file changed, 3 insertions(+), 3 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 d185c1af8b..104576a59e 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
@@ -345,9 +345,9 @@ trait Observable[+T]
    *         An [[rx.lang.scala.Observable]] which produces connected non-overlapping buffers, which are emitted
    *         when the current [[rx.lang.scala.Observable]] created with the function argument produces an object.
    */
-  def buffer[Closing](closings: () => Observable[_ <: Closing]) : Observable[Seq[T]] = {
-    val f: Func0[_ <: rx.Observable[_ <: Closing]] = closings().asJavaObservable
-    val jObs: rx.Observable[_ <: java.util.List[_]] = asJavaObservable.buffer[Closing](f)
+  def buffer(closings: () => Observable[Any]) : Observable[Seq[T]] = {
+    val f: Func0[_ <: rx.Observable[_ <: Any]] = closings().asJavaObservable
+    val jObs: rx.Observable[_ <: java.util.List[_]] = asJavaObservable.buffer[Any](f)
     Observable.jObsOfListToScObsOfSeq(jObs.asInstanceOf[rx.Observable[_ <: java.util.List[T]]])
   }
   /**

From 19a9d33b0161ef95887284dd5a51568237cd92d3 Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Mon, 14 Apr 2014 14:51:06 -0700
Subject: [PATCH 214/422] improve javadocs for onErrorFlatMap( ) with link to
 wiki docs & marble diagram

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 24b779a100..011254d514 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5277,7 +5277,8 @@ public final Observable<T> onErrorResumeNext(final Observable<? extends T> resum
      * 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
+     * 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}.
      * <p>
      * You can use this to prevent errors from propagating or to supply fallback data should errors be
@@ -5294,26 +5295,38 @@ public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFun
     }
 
     /**
-     * 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.
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorFlatMap.png">
+     *
+     * @param resumeFunction
+     *            a function that accepts an {@link OnErrorThrowable} representing the Throwable issued by the
+     *            source Observable, and returns an Observable that issues items that will be emitted in place
+     *            of the error
+     * @return the original Observable, with appropriately modified behavior
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#onerrorflatmap">RxJava Wiki: onErrorFlatMap()</a>
      */
     public final Observable<T> onErrorFlatMap(final Func1<OnErrorThrowable, ? extends Observable<? extends T>> resumeFunction) {
         return lift(new OperatorOnErrorFlatMap<T>(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}.
+     * Instruct an Observable to pass control to another Observable rather than invoking
+     * {@link Observer#onError onError} if it encounters an {@link java.lang.Exception}.
      * <p>
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onExceptionResumeNextViaObservable.png">
      * <p>
      * 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
+     * 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.
      * <p>

From bc37906083a9ed16f4fd9114fdfe7571ec96adbf Mon Sep 17 00:00:00 2001
From: Yarix <Yarikx@gmail.com>
Date: Tue, 15 Apr 2014 23:53:43 +0300
Subject: [PATCH 215/422] rxjava-android: parameterize OperatorViewClick by
 concrete view type

---
 .../main/java/rx/android/observables/ViewObservable.java  | 2 +-
 .../src/main/java/rx/operators/OperatorViewClick.java     | 8 ++++----
 2 files changed, 5 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 205f25c944..ecf0ab4f21 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
@@ -26,7 +26,7 @@
 
 public class ViewObservable {
 
-    public static Observable<View> clicks(final View view, final boolean emitInitialValue) {
+    public static <T extends View> Observable<T> clicks(final T view, final boolean emitInitialValue) {
         return Observable.create(new OperatorViewClick(view, emitInitialValue));
     }
 
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 7ee7149b72..fb4f06625e 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
@@ -28,17 +28,17 @@
 import rx.functions.Action0;
 import android.view.View;
 
-public final class OperatorViewClick implements Observable.OnSubscribe<View> {
+public final class OperatorViewClick<T extends View> implements Observable.OnSubscribe<T> {
     private final boolean emitInitialValue;
-    private final View view;
+    private final T view;
 
-    public OperatorViewClick(final View view, final boolean emitInitialValue) {
+    public OperatorViewClick(final T view, final boolean emitInitialValue) {
         this.emitInitialValue = emitInitialValue;
         this.view = view;
     }
 
     @Override
-    public void call(final Subscriber<? super View> observer) {
+    public void call(final Subscriber<? super T> observer) {
         Assertions.assertUiThread();
         final CompositeOnClickListener composite = CachedListeners.getFromViewOrCreate(view);
 

From 9dd7648c4045673c9c0f374e943d00398fc92807 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Tue, 15 Apr 2014 14:54:15 -0700
Subject: [PATCH 216/422] Title -> RxJava: Reactive Extensions for the JVM

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f955055845..875c7746ac 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# RxJava: Reactive Programming on the JVM
+# RxJava: Reactive Extensions for the JVM
 
 This library is a Java implementation of <a href="https://rx.codeplex.com">Rx Observables</a>.
 

From 210df42374ec6b581640508aada8d592af73e3f6 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 15 Apr 2014 15:41:25 -0700
Subject: [PATCH 217/422] Simplify Subscription/Observer State

---
 .../subjects/SubjectSubscriptionManager.java  | 70 +++++++------------
 1 file changed, 25 insertions(+), 45 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index d5885f5771..2452b56fc8 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -23,10 +23,8 @@
 import rx.Observable.OnSubscribe;
 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;
 
 /* package */class SubjectSubscriptionManager<T> {
@@ -39,10 +37,11 @@
      *            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.
-     * @param onUnsubscribe called after the child subscription is removed from the state
+     * @param onUnsubscribe
+     *            called after the child subscription is removed from the state
      * @return
      */
-    public OnSubscribe<T> getOnSubscribeFunc(final Action1<SubjectObserver<? super T>> onSubscribe, 
+    public OnSubscribe<T> getOnSubscribeFunc(final Action1<SubjectObserver<? super T>> onSubscribe,
             final Action1<SubjectObserver<? super T>> onTerminated,
             final Action1<SubjectObserver<? super T>> onUnsubscribe) {
         return new OnSubscribe<T>() {
@@ -73,10 +72,9 @@ public void call(Subscriber<? super T> actualOperator) {
                         }
                         break;
                     } else {
-                        final SafeObservableSubscription subscription = new SafeObservableSubscription();
-                        actualOperator.add(subscription); // add to parent if the Subject itself is unsubscribed
                         addedObserver = true;
-                        subscription.wrap(Subscriptions.create(new Action0() {
+                        // add to parent if the Subject itself is unsubscribed
+                        actualOperator.add(Subscriptions.create(new Action0() {
 
                             @Override
                             public void call() {
@@ -85,19 +83,19 @@ public void call() {
                                 do {
                                     current = state.get();
                                     // on unsubscribe remove it from the map of outbound observers to notify
-                                    newState = current.removeObserver(subscription);
+                                    newState = current.removeObserver(observer);
                                 } while (!state.compareAndSet(current, newState));
                                 if (onUnsubscribe != null) {
                                     onUnsubscribe.call(observer);
                                 }
                             }
                         }));
-                        if (subscription.isUnsubscribed()) {
-                            addedObserver = false;
+                        if (actualOperator.isUnsubscribed()) {
+                            // we've been unsubscribed while working so return and do nothing
                             return;
                         }
                         // on subscribe add it to the map of outbound observers to notify
-                        newState = current.addObserver(subscription, observer);
+                        newState = current.addObserver(observer);
                     }
                 } while (!state.compareAndSet(current, newState));
 
@@ -126,7 +124,7 @@ protected Collection<SubjectObserver<? super T>> terminate(Action1<Collection<Su
             }
         } while (!state.compareAndSet(current, newState));
 
-        Collection<SubjectObserver<? super T>> observerCollection = (Collection)Arrays.asList(newState.observers);
+        Collection<SubjectObserver<? super T>> observerCollection = (Collection) Arrays.asList(newState.observers);
         /*
          * if we get here then we won setting the state to terminated
          * and have a deterministic set of Observers to emit to (concurrent subscribes
@@ -158,25 +156,19 @@ public SubjectObserver<Object>[] rawSnapshot() {
     protected static class State<T> {
         final boolean terminated;
         final CountDownLatch terminationLatch;
-        final Subscription[] subscriptions;
         final SubjectObserver[] observers;
         // to avoid lots of empty arrays
-        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,
-                Subscription[] subscriptions, SubjectObserver[] observers) {
+        private State(boolean isTerminated, CountDownLatch terminationLatch, SubjectObserver[] observers) {
             this.terminationLatch = terminationLatch;
             this.terminated = isTerminated;
-            this.subscriptions = subscriptions;
             this.observers = observers;
         }
 
         State() {
             this.terminated = false;
             this.terminationLatch = null;
-            this.subscriptions = EMPTY_S;
             this.observers = EMPTY_O;
         }
 
@@ -184,71 +176,59 @@ public State<T> terminate() {
             if (terminated) {
                 throw new IllegalStateException("Already terminated.");
             }
-            return new State<T>(true, new CountDownLatch(1), subscriptions, observers);
+            return new State<T>(true, new CountDownLatch(1), observers);
         }
 
-        public State<T> addObserver(Subscription s, SubjectObserver<? super T> observer) {
+        public State<T> addObserver(SubjectObserver<? super T> 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);
+            return createNewWith(newobservers);
         }
 
-        private State<T> createNewWith(Subscription[] newsubscriptions, SubjectObserver[] newobservers) {
-            return new State<T>(terminated, terminationLatch, newsubscriptions, newobservers);
+        private State<T> createNewWith(SubjectObserver[] newobservers) {
+            return new State<T>(terminated, terminationLatch, newobservers);
         }
 
-        public State<T> removeObserver(Subscription s) {
+        public State<T> removeObserver(SubjectObserver<? super T> o) {
             // we are empty, nothing to remove
             if (this.observers.length == 0) {
                 return this;
-            } else
-            if (this.observers.length == 1) {
-                if (this.subscriptions[0].equals(s)) {
-                    return createNewWith(EMPTY_S, EMPTY_O);
-                }
-                return this;
             }
+
             int n = this.observers.length - 1;
             int copied = 0;
-            Subscription[] newsubscriptions = new Subscription[n];
             SubjectObserver[] newobservers = new SubjectObserver[n];
 
-            for (int i = 0; i < this.subscriptions.length; i++) {
-                Subscription s0 = this.subscriptions[i];
-                if (!s0.equals(s)) {
+            for (int i = 0; i < this.observers.length; i++) {
+                SubjectObserver s0 = this.observers[i];
+                if (!s0.equals(o)) {
                     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];
+                    newobservers[copied] = s0;
                     copied++;
                 }
             }
 
             if (copied == 0) {
-                return createNewWith(EMPTY_S, EMPTY_O);
+                return createNewWith(EMPTY_O);
             }
             // if somehow copied less than expected, truncate the arrays
             // if s is unique, this should never happen
             if (copied < n) {
-                Subscription[] newsubscriptions2 = new Subscription[copied];
-                System.arraycopy(newsubscriptions, 0, newsubscriptions2, 0, copied);
-                
                 SubjectObserver[] newobservers2 = new SubjectObserver[copied];
                 System.arraycopy(newobservers, 0, newobservers2, 0, copied);
 
-                return createNewWith(newsubscriptions2, newobservers2);
+                return createNewWith(newobservers2);
             }
-            return createNewWith(newsubscriptions, newobservers);
+            return createNewWith(newobservers);
         }
     }
 

From 56f88df6fe078e5e110c40aadf8d21646fc076cf Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 15 Apr 2014 15:49:11 -0700
Subject: [PATCH 218/422] Remove Redundant Action1 Observer Collection Argument

Since the collection is being returned we don't want to also inject it as an argument, so I migrated to Action0 from Action1 as per discussion at https://github.com/Netflix/RxJava/pull/972#issuecomment-38189145
---
 .../main/java/rx/subjects/AsyncSubject.java   | 13 +++++----
 .../java/rx/subjects/BehaviorSubject.java     | 27 ++++++++-----------
 .../main/java/rx/subjects/PublishSubject.java | 13 +++++----
 .../main/java/rx/subjects/ReplaySubject.java  | 20 +++++++-------
 .../subjects/SubjectSubscriptionManager.java  |  7 +++--
 .../main/java/rx/subjects/TestSubject.java    | 25 ++++++++++-------
 6 files changed, 51 insertions(+), 54 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index c2302d9890..2a12a840ff 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.functions.Action0;
 import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
@@ -105,11 +106,10 @@ protected AsyncSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T>
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
+            public void call() {
             }
         });
         if (observers != null) {
@@ -121,11 +121,10 @@ public void call(Collection<SubjectObserver<? super T>> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
-                lastNotification.set(Notification.<T>createOnError(e));
+            public void call() {
+                lastNotification.set(Notification.<T> createOnError(e));
             }
         });
         if (observers != null) {
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 5f2010fd85..9100caa3c3 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.functions.Action0;
 import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
@@ -67,12 +68,10 @@
 public final class BehaviorSubject<T> extends Subject<T, T> {
 
     /**
-     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each
-     * {@link Observer} that subscribes to it.
+     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
      * 
      * @param defaultValue
-     *            the value which will be published to any {@link Observer} as long as the
-     *            {@link BehaviorSubject} has not yet received any events
+     *            the value which will be published to any {@link Observer} as long as the {@link BehaviorSubject} has not yet received any events
      * @return the constructed {@link BehaviorSubject}
      * @deprecated use {@link #create(T)} instead
      */
@@ -81,12 +80,10 @@ public static <T> BehaviorSubject<T> createWithDefaultValue(T defaultValue) {
     }
 
     /**
-     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each
-     * {@link Observer} that subscribes to it.
+     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
      * 
      * @param defaultValue
-     *            the value which will be published to any {@link Observer} as long as the
-     *            {@link BehaviorSubject} has not yet received any events
+     *            the value which will be published to any {@link Observer} as long as the {@link BehaviorSubject} has not yet received any events
      * @return the constructed {@link BehaviorSubject}
      */
     public static <T> BehaviorSubject<T> create(T defaultValue) {
@@ -144,12 +141,11 @@ protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
-                lastNotification.set(Notification.<T>createOnCompleted());
+            public void call() {
+                lastNotification.set(Notification.<T> createOnCompleted());
             }
         });
         if (observers != null) {
@@ -161,12 +157,11 @@ public void call(Collection<SubjectObserver<? super T>> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
-                lastNotification.set(Notification.<T>createOnError(e));
+            public void call() {
+                lastNotification.set(Notification.<T> createOnError(e));
             }
         });
         if (observers != null) {
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 687d039e6a..998385a741 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.functions.Action0;
 import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
@@ -95,10 +96,9 @@ protected PublishSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
+            public void call() {
                 lastNotification.set(Notification.<T> createOnCompleted());
             }
         });
@@ -111,12 +111,11 @@ public void call(Collection<SubjectObserver<? super T>> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
-                lastNotification.set(Notification.<T>createOnError(e));
+            public void call() {
+                lastNotification.set(Notification.<T> createOnError(e));
             }
         });
         if (observers != null) {
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 01107efa20..d37f7820b1 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -23,6 +23,7 @@
 
 import rx.Notification;
 import rx.Observer;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
@@ -88,7 +89,7 @@ public void call(SubjectObserver<? super T> o) {
                         // we will finish replaying if there is anything left
                         replayObserverFromIndex(state.history, idx, o);
                     }
-                }, 
+                },
                 new Action1<SubjectObserver<? super T>>() {
                     @Override
                     public void call(SubjectObserver<? super T> o) {
@@ -122,12 +123,11 @@ protected ReplaySubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
-                state.history.complete(Notification.<T>createOnCompleted());
+            public void call() {
+                state.history.complete(Notification.<T> createOnCompleted());
             }
         });
         if (observers != null) {
@@ -141,12 +141,11 @@ public void call(Collection<SubjectObserver<? super T>> observers) {
 
     @Override
     public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers =
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
-                state.history.complete(Notification.<T>createOnError(e));
+            public void call() {
+                state.history.complete(Notification.<T> createOnError(e));
             }
         });
         if (observers != null) {
@@ -242,10 +241,11 @@ public void complete(Notification<T> n) {
             terminalValue.set(n);
         }
     }
+
     /**
      * @return Returns the number of subscribers.
      */
-    /* Support test.*/ int subscriberCount() {
+    /* Support test. */int subscriberCount() {
         return state.replayState.size();
     }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 2452b56fc8..7a66ad3cdf 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -111,7 +111,7 @@ public void call() {
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
-    protected Collection<SubjectObserver<? super T>> terminate(Action1<Collection<SubjectObserver<? super T>>> onTerminate) {
+    protected Collection<SubjectObserver<? super T>> terminate(Action0 onTerminate) {
         State<T> current;
         State<T> newState = null;
         do {
@@ -128,12 +128,11 @@ protected Collection<SubjectObserver<? super T>> terminate(Action1<Collection<Su
         /*
          * 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)
+         * will have failed and will try again and see we are terminated)
          */
         try {
             // had to circumvent type check, we know what the array contains
-            onTerminate.call(observerCollection);
+            onTerminate.call();
         } finally {
             // mark that termination is completed
             newState.terminationLatch.countDown();
diff --git a/rxjava-core/src/main/java/rx/subjects/TestSubject.java b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
index 7904886c75..002b904e23 100644
--- a/rxjava-core/src/main/java/rx/subjects/TestSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
@@ -23,6 +23,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
@@ -105,16 +106,18 @@ public void onCompleted() {
     }
 
     private void _onCompleted() {
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
+            public void call() {
                 lastNotification.set(Notification.<T> createOnCompleted());
-                for (Observer<? super T> o : observers) {
-                    o.onCompleted();
-                }
             }
         });
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                o.onCompleted();
+            }
+        }
     }
 
     public void onCompleted(long timeInMilliseconds) {
@@ -134,16 +137,18 @@ public void onError(final Throwable e) {
     }
 
     private void _onError(final Throwable e) {
-        subscriptionManager.terminate(new Action1<Collection<SubjectObserver<? super T>>>() {
+        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
             @Override
-            public void call(Collection<SubjectObserver<? super T>> observers) {
+            public void call() {
                 lastNotification.set(Notification.<T> createOnError(e));
-                for (Observer<? super T> o : observers) {
-                    o.onError(e);
-                }
             }
         });
+        if (observers != null) {
+            for (Observer<? super T> o : observers) {
+                o.onError(e);
+            }
+        }
 
     }
 

From 6a858c4578cf05a79f993d3282b2ac6299a2c401 Mon Sep 17 00:00:00 2001
From: MarioAriasC <mario@marioarias.org>
Date: Wed, 16 Apr 2014 02:33:14 +0100
Subject: [PATCH 219/422] Kotlin M7, minor fixes, compatibility with 0.17.0

---
 language-adaptors/rxjava-kotlin/build.gradle  |  4 ++--
 .../main/kotlin/rx/lang/kotlin/namespace.kt   | 11 ++++++---
 .../kotlin/rx/lang/kotlin/BasicKotlinTests.kt | 23 +++++++++----------
 .../kotlin/rx/lang/kotlin/ExtensionTests.kt   | 15 +++++-------
 4 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/language-adaptors/rxjava-kotlin/build.gradle b/language-adaptors/rxjava-kotlin/build.gradle
index aa44049d05..fc710d89fb 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.1673'
+        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:0.7.270'
     }
 }
 
@@ -13,7 +13,7 @@ apply plugin: 'osgi'
 
 dependencies {
     compile project(':rxjava-core')
-    compile 'org.jetbrains.kotlin:kotlin-stdlib:0.6.1673'
+    compile 'org.jetbrains.kotlin:kotlin-stdlib:0.7.270'
     provided 'junit:junit-dep:4.10'
     provided 'org.mockito:mockito-core:1.8.5'
 }
diff --git a/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt b/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt
index d5eb8420f5..a333c3062d 100644
--- a/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt
+++ b/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt
@@ -21,11 +21,16 @@ import rx.Observable
 import rx.Observable.OnSubscribe
 import rx.Subscription
 import rx.Observable.OnSubscribeFunc
+import rx.Subscriber
 
 
-public fun<T> Function1<Observer<in T>, Unit>.asObservable(): Observable<T> {
-    return Observable.create(OnSubscribe<T>{ t1 ->
-        this(t1!!)
+public fun<T> Function1<Subscriber<in T>, Unit>.asObservable(): Observable<T> {
+    val v = this
+    return Observable.create(object:OnSubscribe<T> {
+        override fun call(t1: Subscriber<in T>?) {
+            v(t1!!)
+        }
+
     })!!
 }
 
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 cf4d3787b3..4237ab10d1 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
@@ -16,10 +16,7 @@
 
 package rx.lang.kotlin
 
-import org.mockito.Mock
 import rx.Observable
-import org.junit.Before
-import org.mockito.MockitoAnnotations
 import org.junit.Test
 import rx.subscriptions.Subscriptions
 import org.mockito.Mockito.*
@@ -31,21 +28,23 @@ import rx.Subscription
 import kotlin.concurrent.thread
 import rx.Observable.OnSubscribeFunc
 import rx.lang.kotlin.BasicKotlinTests.AsyncObservable
+import rx.Observable.OnSubscribe
+import rx.Subscriber
 
 /**
  * This class use plain Kotlin without extensions from the language adaptor
  */
-public class BasicKotlinTests:KotlinTests() {
-
+public class BasicKotlinTests : KotlinTests() {
 
 
     [Test]
     public fun testCreate() {
 
-        Observable.create(OnSubscribeFunc<String> {
-            it!!.onNext("Hello")
-            it.onCompleted()
-            Subscriptions.empty()
+        Observable.create(object:OnSubscribe<String> {
+            override fun call(subscriber: Subscriber<in String>?) {
+                subscriber!!.onNext("Hello")
+                subscriber.onCompleted()
+            }
         })!!.subscribe { result ->
             a!!.received(result)
         }
@@ -310,7 +309,7 @@ public class BasicKotlinTests:KotlinTests() {
 
 
 
-    public class TestFactory(){
+    public class TestFactory() {
         var counter = 1
 
         val numbers: Observable<Int>
@@ -330,7 +329,7 @@ public class BasicKotlinTests:KotlinTests() {
 
     }
 
-    class AsyncObservable : OnSubscribeFunc<Int>{
+    class AsyncObservable : OnSubscribeFunc<Int> {
         override fun onSubscribe(op: Observer<in Int>?): Subscription? {
             thread {
                 Thread.sleep(50)
@@ -343,7 +342,7 @@ public class BasicKotlinTests:KotlinTests() {
         }
     }
 
-    class TestOnSubscribe(val count: Int) : OnSubscribeFunc<String>{
+    class TestOnSubscribe(val count: Int) : OnSubscribeFunc<String> {
         override fun onSubscribe(op: Observer<in String>?): Subscription? {
             op!!.onNext("hello_$count")
             op.onCompleted()
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 c9fa67a6a1..614dc9e970 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
@@ -16,10 +16,7 @@
 
 package rx.lang.kotlin
 
-import org.mockito.Mock
 import rx.Observable
-import org.junit.Before
-import org.mockito.MockitoAnnotations
 import org.junit.Test
 import rx.subscriptions.Subscriptions
 import org.mockito.Mockito.*
@@ -29,6 +26,7 @@ import org.junit.Assert.*
 import rx.Notification
 import rx.Subscription
 import kotlin.concurrent.thread
+import rx.Subscriber
 
 /**
  * This class contains tests using the extension functions provided by the language adaptor.
@@ -39,11 +37,10 @@ public class ExtensionTests : KotlinTests() {
     [Test]
     public fun testCreate() {
 
-        {(observer: Observer<in String>) ->
-            observer.onNext("Hello")
-            observer.onCompleted()
-            Subscriptions.empty()!!
-        }.asObservableFunc().subscribe { result ->
+        {(subscriber: Subscriber<in String>) ->
+            subscriber.onNext("Hello")
+            subscriber.onCompleted()
+        }.asObservable().subscribe { result ->
             a!!.received(result)
         }
 
@@ -283,7 +280,7 @@ public class ExtensionTests : KotlinTests() {
         return {(p2: P2) -> this(p1, p2) }
     }
 
-    inner public class TestFactory(){
+    inner public class TestFactory() {
         var counter = 1
 
         val numbers: Observable<Int>

From 1a368734010ac371e12b182ba040efca5808f12b Mon Sep 17 00:00:00 2001
From: MarioAriasC <mario@marioarias.org>
Date: Wed, 16 Apr 2014 02:49:40 +0100
Subject: [PATCH 220/422] Test with full compatibility with 0.17.0

---
 .../kotlin/rx/lang/kotlin/BasicKotlinTests.kt | 11 ++++---
 .../kotlin/rx/lang/kotlin/ExtensionTests.kt   | 29 ++++++++-----------
 2 files changed, 17 insertions(+), 23 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 4237ab10d1..99d6b4278b 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
@@ -329,8 +329,8 @@ public class BasicKotlinTests : KotlinTests() {
 
     }
 
-    class AsyncObservable : OnSubscribeFunc<Int> {
-        override fun onSubscribe(op: Observer<in Int>?): Subscription? {
+    class AsyncObservable : OnSubscribe<Int> {
+        override fun call(op: Subscriber<in Int>?) {
             thread {
                 Thread.sleep(50)
                 op!!.onNext(1)
@@ -338,15 +338,14 @@ public class BasicKotlinTests : KotlinTests() {
                 op.onNext(3)
                 op.onCompleted()
             }
-            return Subscriptions.empty()
+
         }
     }
 
-    class TestOnSubscribe(val count: Int) : OnSubscribeFunc<String> {
-        override fun onSubscribe(op: Observer<in String>?): Subscription? {
+    class TestOnSubscribe(val count: Int) : OnSubscribe<String> {
+        override fun call(op: Subscriber<in String>?)  {
             op!!.onNext("hello_$count")
             op.onCompleted()
-            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 614dc9e970..c601bd54a1 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
@@ -18,13 +18,10 @@ package rx.lang.kotlin
 
 import rx.Observable
 import org.junit.Test
-import rx.subscriptions.Subscriptions
 import org.mockito.Mockito.*
 import org.mockito.Matchers.*
-import rx.Observer
 import org.junit.Assert.*
 import rx.Notification
-import rx.Subscription
 import kotlin.concurrent.thread
 import rx.Subscriber
 
@@ -213,7 +210,7 @@ public class ExtensionTests : KotlinTests() {
 
     [Test]
     public fun testForEach() {
-        asyncObservable.asObservableFunc().toBlockingObservable()!!.forEach(received())
+        asyncObservable.asObservable().toBlockingObservable()!!.forEach(received())
         verify(a, times(1))!!.received(1)
         verify(a, times(1))!!.received(2)
         verify(a, times(1))!!.received(3)
@@ -221,7 +218,7 @@ public class ExtensionTests : KotlinTests() {
 
     [Test(expected = javaClass<RuntimeException>())]
     public fun testForEachWithError() {
-        asyncObservable.asObservableFunc().toBlockingObservable()!!.forEach { throw RuntimeException("err") }
+        asyncObservable.asObservable().toBlockingObservable()!!.forEach { throw RuntimeException("err") }
         fail("we expect an exception to be thrown")
     }
 
@@ -256,21 +253,19 @@ public class ExtensionTests : KotlinTests() {
         assertEquals(listOf(3, 6, 9), values[2])
     }
 
-    val funOnSubscribe: (Int, Observer<in String>) -> Subscription = { counter, observer ->
-        observer.onNext("hello_$counter")
-        observer.onCompleted()
-        Subscriptions.empty()!!
+    val funOnSubscribe: (Int, Subscriber<in String>) -> Unit = { counter, subscriber ->
+        subscriber.onNext("hello_$counter")
+        subscriber.onCompleted()
     }
 
-    val asyncObservable: (Observer<in Int>) -> Subscription = { observer ->
+    val asyncObservable: (Subscriber<in Int>) -> Unit = { subscriber ->
         thread {
             Thread.sleep(50)
-            observer.onNext(1)
-            observer.onNext(2)
-            observer.onNext(3)
-            observer.onCompleted()
+            subscriber.onNext(1)
+            subscriber.onNext(2)
+            subscriber.onNext(3)
+            subscriber.onCompleted()
         }
-        Subscriptions.empty()!!
     }
 
     /**
@@ -288,14 +283,14 @@ public class ExtensionTests : KotlinTests() {
                 return listOf(1, 3, 2, 5, 4).asObservable()
             }
 
-        val onSubscribe: (Observer<in String>) -> Subscription
+        val onSubscribe: (Subscriber<in String>) -> Unit
             get(){
                 return funOnSubscribe.partially1(counter++)
             }
 
         val observable: Observable<String>
             get(){
-                return onSubscribe.asObservableFunc()
+                return onSubscribe.asObservable()
             }
 
     }

From 0fa7896d5dbcdd53822af1745c508fd38a50b03e Mon Sep 17 00:00:00 2001
From: Eugene Vigdorchik <eugene.vigdorchik@gmail.com>
Date: Wed, 16 Apr 2014 10:49:29 +0400
Subject: [PATCH 221/422] Update doc comments.

---
 .../src/main/scala/rx/lang/scala/Observable.scala    | 12 +++++-------
 1 file changed, 5 insertions(+), 7 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 104576a59e..a8c67cb10d 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
@@ -354,9 +354,8 @@ trait Observable[+T]
    * Creates an Observable which produces buffers of collected values.
    *
    * This Observable produces buffers. Buffers are created when the specified `openings`
-   * Observable produces an object. Additionally the function argument
-   * is used to create an Observable which produces [[rx.lang.scala.util.Closing]] objects. When this
-   * Observable produces such an object, the associated buffer is emitted.
+   * Observable produces an object. That object is used to construct an Observable to emit buffers, feeding it into `closings` function.
+   * Buffers are emitted when the created Observable produces an object.
    *
    * @param openings
    *            The [[rx.lang.scala.Observable]] which, when it produces an object, will cause
@@ -566,10 +565,9 @@ trait Observable[+T]
   }
 
   /**
-   * Creates an Observable which produces windows of collected values. This Observable produces windows.
-   * Chunks are created when the specified `openings` Observable produces an object.
-   * Additionally the `closings` argument is used to create an Observable which produces [[rx.lang.scala.util.Closing]] objects. 
-   * When this Observable produces such an object, the associated window is emitted.
+   * Creates an Observable which produces windows of collected values. Chunks are created when the specified `openings`
+   * Observable produces an object. That object is used to construct an Observable to emit windows, feeding it into `closings` function.
+   * Windows are emitted when the created Observable produces an object.
    *
    * @param openings
    *            The [[rx.lang.scala.Observable]] which when it produces an object, will cause

From a26a6d03e484efb3ffdbe8037a88ba09ae28cbd1 Mon Sep 17 00:00:00 2001
From: MarioAriasC <mario@marioarias.org>
Date: Wed, 16 Apr 2014 09:31:16 +0100
Subject: [PATCH 222/422] Update README

---
 language-adaptors/rxjava-kotlin/README.md     | 32 +++++++++++++------
 .../main/kotlin/rx/lang/kotlin/namespace.kt   |  4 +--
 2 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/language-adaptors/rxjava-kotlin/README.md b/language-adaptors/rxjava-kotlin/README.md
index c0eb072c26..037d759654 100644
--- a/language-adaptors/rxjava-kotlin/README.md
+++ b/language-adaptors/rxjava-kotlin/README.md
@@ -3,25 +3,37 @@
 Kotlin has support for SAM (Single Abstract Method) Interfaces as Functions (i.e. Java 8 Lambdas). So you could use Kotlin in RxJava whitout this adaptor
 
 ```kotlin
-Observable.create(OnSubscribeFunc<String> {
-    it!!.onNext("Hello")
-    it.onCompleted()
+Observable.create(OnSubscribeFunc<String> { observer ->
+    observer!!.onNext("Hello")
+    observer.onCompleted()
     Subscriptions.empty()
 })!!.subscribe { result ->
     a!!.received(result)
 }
 ```
 
-This adaptor exposes a set of Extension functions that allow a more idiomatic Kotlin usage
+In RxJava [0.17.0](https://github.com/Netflix/RxJava/releases/tag/0.17.0) version a new Subscriber type was included
 
 ```kotlin
-import rx.lang.kotlin.*
+Observable.create(object:OnSubscribe<String> {
+    override fun call(subscriber: Subscriber<in String>?) {
+        subscriber!!.onNext("Hello")
+        subscriber.onCompleted()
+    }
+})!!.subscribe { result ->
+    a!!.received(result)
+}
+```
 
-{(observer: Observer<in String>) ->
-    observer.onNext("Hello")
-    observer.onCompleted()
-    Subscriptions.empty()!!
-}.asObservableFunc().subscribe { result ->
+(Due to a [bug in Kotlin's compiler](http://youtrack.jetbrains.com/issue/KT-4753) you can't use SAM with OnSubscribe)
+
+This adaptor exposes a set of Extension functions that allow a more idiomatic Kotlin usage
+
+```kotlin
+{(subscriber: Subscriber<in String>) ->
+    subscriber.onNext("Hello")
+    subscriber.onCompleted()
+}.asObservable().subscribe { result ->
     a!!.received(result)
 }
 ```
diff --git a/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt b/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt
index a333c3062d..006f97e48a 100644
--- a/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt
+++ b/language-adaptors/rxjava-kotlin/src/main/kotlin/rx/lang/kotlin/namespace.kt
@@ -25,15 +25,15 @@ import rx.Subscriber
 
 
 public fun<T> Function1<Subscriber<in T>, Unit>.asObservable(): Observable<T> {
-    val v = this
     return Observable.create(object:OnSubscribe<T> {
         override fun call(t1: Subscriber<in T>?) {
-            v(t1!!)
+            this@asObservable(t1!!)
         }
 
     })!!
 }
 
+[deprecated("Use Function1<Subscriber<in T>, Unit>.asObservable()")]
 public fun<T> Function1<Observer<in T>, Subscription>.asObservableFunc(): Observable<T> {
     return Observable.create(OnSubscribeFunc<T>{ op ->
         this(op!!)

From a7e8da2542f6fd42c78c2166db11af6f722702bd Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Thu, 17 Apr 2014 02:48:57 +0000
Subject: [PATCH 223/422] [Gradle Release Plugin] - pre tag commit:  '0.17.6'.

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

diff --git a/gradle.properties b/gradle.properties
index fada833319..a183058b92 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.6-SNAPSHOT
+version=0.17.6

From ee6bd97f8c3802c820abddea37e0d24ed50a80b7 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Thu, 17 Apr 2014 02:49:01 +0000
Subject: [PATCH 224/422] [Gradle Release Plugin] - new version commit: 
 '0.17.7-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index a183058b92..cf84ac8f3e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.6
+version=0.17.7-SNAPSHOT

From 81e0f7ac294497a2d9ee07f6b5e75021924d5dbb Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Wed, 16 Apr 2014 20:06:06 -0700
Subject: [PATCH 225/422] 0.17.6

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

diff --git a/CHANGES.md b/CHANGES.md
index fa6f37834d..68a0474a2b 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,19 @@
 # RxJava Releases #
 
+### Version 0.17.6 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.6%22)) ###
+
+* [Pull 1031] (https://github.com/Netflix/RxJava/pull/1031) Fix NPE in SubjectSubscriptionManager
+* [Pull 1030] (https://github.com/Netflix/RxJava/pull/1030) Benchmarking: Add JMH benchmark for ReplaySubject
+* [Pull 1033] (https://github.com/Netflix/RxJava/pull/1033) isolate subscriber used for retries, cleanup tests
+* [Pull 1021] (https://github.com/Netflix/RxJava/pull/1021) OperatorWeakBinding to not use WeakReferences anymore
+* [Pull 1005] (https://github.com/Netflix/RxJava/pull/1005) add toMap from Java Observable
+* [Pull 1040] (https://github.com/Netflix/RxJava/pull/1040) Fixed deadlock in Subjects + OperatorCache
+* [Pull 1042] (https://github.com/Netflix/RxJava/pull/1042) Kotlin M7 and full compatibility with 0.17.0
+* [Pull 1035] (https://github.com/Netflix/RxJava/pull/1035) Scala cleanup
+* [Pull 1009] (https://github.com/Netflix/RxJava/pull/1009) Android - Adding a new RetainedFragment example
+* [Pull 1020] (https://github.com/Netflix/RxJava/pull/1020) Upgrade Gradle wrapper for Android samples to Gradle 1.11
+* [Pull 1038] (https://github.com/Netflix/RxJava/pull/1038) rxjava-android: parameterize OperatorViewClick by concrete view type
+
 ### Version 0.17.5 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.5%22)) ###
 
 * [Pull 1010] (https://github.com/Netflix/RxJava/pull/1010) Observable.unsafeSubscribe

From 526d091430572684e426983fa609fe1e843ff5bd Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Thu, 17 Apr 2014 12:13:37 -0700
Subject: [PATCH 226/422] (#1045) clarify javadocs to accurately describe
 currently-intended behavior of sample()

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4b74e272ab..75b45069f0 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6058,8 +6058,8 @@ public final Observable<T> 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 most recently emitted item (if any) emitted by the source Observable
+     * within periodic time intervals.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.png">
      * 
@@ -6076,8 +6076,8 @@ public final Observable<T> 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 most recently emitted item (if any) emitted by the source Observable
+     * within periodic time intervals, where the intervals are defined on a particular Scheduler.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.s.png">
      * 
@@ -6096,8 +6096,9 @@ public final Observable<T> 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.
+     * Returns an Observable that, when the specified {@code sampler} Observable emits an item or completes,
+     * emits the most recently emitted item (if any) emitted by the source Observable since the previous
+     * emission from the {@code sampler} Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.o.png">
      * 

From cbc1c6b58f2148f47f5e4a1cc8d2d060909dc75c Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 17 Apr 2014 20:28:41 -0700
Subject: [PATCH 227/422] Scheduler.inner() for Core

---
 rxjava-core/src/main/java/rx/Scheduler.java   | 173 +++----
 .../java/rx/operators/ChunkedOperation.java   |  63 +--
 .../java/rx/operators/OperationDebounce.java  |  11 +-
 .../java/rx/operators/OperationDelay.java     |  11 +-
 .../java/rx/operators/OperationInterval.java  |  15 +-
 .../main/java/rx/operators/OperationSkip.java |  21 +-
 .../java/rx/operators/OperationTakeTimed.java |  21 +-
 .../java/rx/operators/OperationTimer.java     |  12 +-
 .../java/rx/operators/OperatorObserveOn.java  |  49 +-
 .../operators/OperatorObserveOnBounded.java   | 310 ------------
 .../java/rx/operators/OperatorRepeat.java     |  12 +-
 .../main/java/rx/operators/OperatorRetry.java |  15 +-
 .../rx/operators/OperatorSubscribeOn.java     |  10 +-
 .../java/rx/operators/OperatorTimeout.java    |  24 +-
 .../rx/operators/OperatorTimeoutBase.java     |  26 +-
 .../OperatorTimeoutWithSelector.java          |   8 +-
 .../rx/operators/OperatorUnsubscribeOn.java   |  13 +-
 .../java/rx/schedulers/ExecutorScheduler.java |  91 ++--
 .../rx/schedulers/ImmediateScheduler.java     |  25 +-
 .../rx/schedulers/NewThreadScheduler.java     |  26 +-
 .../java/rx/schedulers/SleepingAction.java    |  25 +-
 .../java/rx/schedulers/TestScheduler.java     |  53 +-
 .../rx/schedulers/TrampolineScheduler.java    |  56 ++-
 .../main/java/rx/subjects/TestSubject.java    |  15 +-
 .../OperatorObserveOnPerformance.java         |  48 +-
 .../schedulers/TestRecursionMemoryUsage.java  | 132 ++---
 rxjava-core/src/test/java/rx/ConcatTests.java |   3 +-
 .../src/test/java/rx/ErrorHandlingTests.java  |   2 +-
 rxjava-core/src/test/java/rx/EventStream.java |  39 +-
 rxjava-core/src/test/java/rx/MergeTests.java  |   2 +-
 .../src/test/java/rx/ObservableDoOnTest.java  |   5 +-
 .../src/test/java/rx/ObservableTests.java     |  16 +-
 .../test/java/rx/ObservableWindowTests.java   |   3 +-
 rxjava-core/src/test/java/rx/ReduceTests.java |   2 +-
 .../src/test/java/rx/RefCountTests.java       |   4 +-
 .../src/test/java/rx/StartWithTests.java      |   2 +-
 .../src/test/java/rx/ThrottleFirstTests.java  |   3 +-
 .../src/test/java/rx/ThrottleLastTests.java   |   3 +-
 .../java/rx/ThrottleWithTimeoutTests.java     |   3 +-
 rxjava-core/src/test/java/rx/ZipTests.java    |   3 +-
 .../rx/exceptions/CompositeExceptionTest.java |   2 +-
 .../observables/BlockingObservableTest.java   |   3 +-
 .../observers/SynchronizedObserverTest.java   |  12 +-
 .../java/rx/observers/TestObserverTest.java   |   6 +-
 .../java/rx/observers/TestSubscriberTest.java |   6 +-
 .../BlockingOperatorMostRecentTest.java       |   6 +-
 .../operators/BlockingOperatorNextTest.java   |   7 +-
 .../BlockingOperatorToIteratorTest.java       |   4 +-
 .../rx/operators/OnSubscribeRangeTest.java    |   7 +-
 .../java/rx/operators/OperationAllTest.java   |   6 +-
 .../java/rx/operators/OperationAnyTest.java   |   9 +-
 .../rx/operators/OperationAverageTest.java    |  17 +-
 .../rx/operators/OperationBufferTest.java     |  24 +-
 .../operators/OperationCombineLatestTest.java |  11 +-
 .../rx/operators/OperationConcatTest.java     |  13 +-
 .../rx/operators/OperationDebounceTest.java   |  27 +-
 .../OperationDefaultIfEmptyTest.java          |   7 +-
 .../java/rx/operators/OperationDeferTest.java |   6 +-
 .../java/rx/operators/OperationDelayTest.java |  11 +-
 .../rx/operators/OperationDistinctTest.java   |  12 +-
 .../OperationDistinctUntilChangedTest.java    |  12 +-
 .../rx/operators/OperationFinallyTest.java    |   6 +-
 .../OperationFirstOrDefaultTest.java          |  12 +-
 .../rx/operators/OperationFlatMapTest.java    |   7 +-
 .../operators/OperationGroupByUntilTest.java  |   7 +-
 .../rx/operators/OperationGroupJoinTest.java  |   6 +-
 .../rx/operators/OperationIntervalTest.java   |   9 +-
 .../java/rx/operators/OperationJoinTest.java  |   6 +-
 .../java/rx/operators/OperationJoinsTest.java |   7 +-
 .../java/rx/operators/OperationLastTest.java  |   8 +-
 .../OperationMergeDelayErrorTest.java         |  12 +-
 .../OperationMergeMaxConcurrentTest.java      |   3 +-
 .../rx/operators/OperationMinMaxTest.java     |  11 +-
 .../rx/operators/OperationMulticastTest.java  |   5 +-
 ...ionOnErrorResumeNextViaObservableTest.java |  10 +-
 .../operators/OperationOnErrorReturnTest.java |  11 +-
 ...nExceptionResumeNextViaObservableTest.java |  12 +-
 .../rx/operators/OperationReduceTest.java     |   6 +-
 .../rx/operators/OperationReplayTest.java     |   8 +-
 .../rx/operators/OperationSampleTest.java     |  26 +-
 .../OperationSequenceEqualTests.java          |   6 +-
 .../rx/operators/OperationSingleTest.java     |   6 +-
 .../rx/operators/OperationSkipLastTest.java   |  10 +-
 .../java/rx/operators/OperationSkipTest.java  |   7 +-
 .../rx/operators/OperationSkipUntilTest.java  |   6 +-
 .../rx/operators/OperationSkipWhileTest.java  |   8 +-
 .../java/rx/operators/OperationSumTest.java   |  16 +-
 .../rx/operators/OperationSwitchTest.java     |  27 +-
 .../rx/operators/OperationTakeLastTest.java   |  10 +-
 .../rx/operators/OperationTakeTimedTest.java  |   7 +-
 .../rx/operators/OperationTakeUntilTest.java  |   6 +-
 .../rx/operators/OperationTakeWhileTest.java  |  12 +-
 .../operators/OperationThrottleFirstTest.java |  24 +-
 .../operators/OperationTimeIntervalTest.java  |   3 +-
 .../java/rx/operators/OperationTimerTest.java |   7 +-
 .../java/rx/operators/OperationToMapTest.java |   6 +-
 .../rx/operators/OperationToMultimapTest.java |   6 +-
 .../OperationToObservableFutureTest.java      |   6 +-
 .../java/rx/operators/OperationUsingTest.java |  10 +-
 .../rx/operators/OperationWindowTest.java     |  26 +-
 .../operators/OperationZipTestCompletion.java |   4 +-
 .../java/rx/operators/OperatorAmbTest.java    |  14 +-
 .../java/rx/operators/OperatorCacheTest.java  |   6 +-
 .../java/rx/operators/OperatorCastTest.java   |   5 +-
 .../rx/operators/OperatorDoOnEachTest.java    |   6 +-
 .../java/rx/operators/OperatorFilterTest.java |   6 +-
 .../operators/OperatorFromIterableTest.java   |   6 +-
 .../java/rx/operators/OperatorMapTest.java    |   6 +-
 .../rx/operators/OperatorMaterializeTest.java |   5 +-
 .../java/rx/operators/OperatorMergeTest.java  |  18 +-
 .../OperatorObserveOnBoundedTest.java         | 461 ------------------
 .../rx/operators/OperatorObserveOnTest.java   |  13 +-
 .../operators/OperatorOnErrorFlatMapTest.java |   2 +-
 ...ratorOnErrorResumeNextViaFunctionTest.java |   9 +-
 .../rx/operators/OperatorParallelTest.java    |   2 +-
 .../java/rx/operators/OperatorRepeatTest.java |  10 +-
 .../java/rx/operators/OperatorScanTest.java   |   9 +-
 .../rx/operators/OperatorSerializeTest.java   |  11 +-
 .../java/rx/operators/OperatorSkipTest.java   |   9 +-
 .../rx/operators/OperatorSubscribeOnTest.java |  44 +-
 .../rx/operators/OperatorSynchronizeTest.java |  12 +-
 .../java/rx/operators/OperatorTakeTest.java   |  14 +-
 .../rx/operators/OperatorTimeoutTests.java    |   9 +-
 .../OperatorTimeoutWithSelectorTest.java      |  11 +-
 .../rx/operators/OperatorTimestampTest.java   |   7 +-
 .../OperatorToObservableListTest.java         |   6 +-
 .../OperatorToObservableSortedListTest.java   |   6 +-
 .../operators/OperatorUnsubscribeOnTest.java  |  31 +-
 .../rx/operators/OperatorZipIterableTest.java |   7 +-
 .../java/rx/operators/OperatorZipTest.java    |  11 +-
 .../SafeObservableSubscriptionTest.java       |   4 +-
 .../java/rx/operators/SafeSubscriberTest.java |   6 +-
 .../java/rx/plugins/RxJavaPluginsTest.java    |   4 +-
 .../AbstractSchedulerConcurrencyTests.java    |  68 +--
 .../rx/schedulers/AbstractSchedulerTests.java | 113 +++--
 .../rx/schedulers/ExecutorSchedulerTests.java |  12 +-
 .../rx/schedulers/ImmediateSchedulerTest.java |   2 +-
 .../java/rx/schedulers/TestSchedulerTest.java |  31 +-
 .../schedulers/TrampolineSchedulerTest.java   |   2 +-
 .../java/rx/subjects/AsyncSubjectTest.java    |  11 +-
 .../java/rx/subjects/BehaviorSubjectTest.java |  10 +-
 .../java/rx/subjects/PublishSubjectTest.java  |   9 +-
 .../ReplaySubjectConcurrencyTest.java         |   2 +-
 .../java/rx/subjects/ReplaySubjectTest.java   |  12 +-
 .../CompositeSubscriptionTest.java            |   5 +-
 .../MultipleAssignmentSubscriptionTest.java   |   7 +-
 .../RefCountSubscriptionTest.java             |   7 +-
 .../SerialSubscriptionTests.java              |   8 +-
 .../rx/subscriptions/SubscriptionsTest.java   |   6 +-
 .../src/test/java/rx/test/OperatorTester.java |  13 +-
 150 files changed, 1276 insertions(+), 1760 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java

diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 8203ec567b..5cb539ffd0 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -17,157 +17,100 @@
 
 import java.util.concurrent.TimeUnit;
 
-import rx.functions.Action1;
+import rx.functions.Action0;
+import rx.schedulers.Schedulers;
 
 /**
  * Represents an object that schedules units of work.
  * <p>
- * The methods left to implement are:
- * <ul>
- * <li>{@code <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action, long delayTime, TimeUnit unit)}</li>
- * <li>{@code <T> Subscription schedule(T state, Func2<Scheduler, T, Subscription> action)}</li>
- * </ul>
+ * Common implementations can be found in {@link Schedulers}.
  * <p>
  * Why is this an abstract class instead of an interface?
  * <p>
  * <ol>
  * <li>Java doesn't support extension methods and there are many overload methods needing default
- *     implementations.</li>
+ * implementations.</li>
  * <li>Virtual extension methods aren't available until Java8 which RxJava will not set as a minimum target for
- *     a long time.</li>
+ * a long time.</li>
  * <li>If only an interface were used Scheduler implementations would then need to extend from an
- *     AbstractScheduler pair that gives all of the functionality unless they intend on copy/pasting the
- *     functionality.</li>
+ * AbstractScheduler pair that gives all of the functionality unless they intend on copy/pasting the
+ * functionality.</li>
  * <li>Without virtual extension methods even additive changes are breaking and thus severely impede library
- *     maintenance.</li>
+ * maintenance.</li>
  * </ol>
  */
 public abstract class Scheduler {
 
     /**
-     * Schedules an Action on a new Scheduler instance (typically another thread) for execution.
-     * 
-     * @param action
-     *            Action to schedule
-     * @return a subscription to be able to unsubscribe from action
-     */
-
-    public abstract Subscription schedule(Action1<Scheduler.Inner> action);
-
-    /**
-     * Schedules an Action on a new Scheduler instance (typically another thread) for execution at some point
-     * in the future.
+     * Retrieve or create a new {@link Scheduler.Inner} that represents serial execution of actions.
+     * <p>
+     * When work is completed it should be unsubscribed. Work on a {@link Scheduler.Inner} is guaranteed to be sequential.
      * 
-     * @param action
-     *            the Action to schedule
-     * @param delayTime
-     *            time to wait before executing the action
-     * @param unit
-     *            the time unit the delay time is given in
-     * @return a subscription to be able to unsubscribe from action
+     * @return Inner representing a serial queue of actions to be executed
      */
-    public abstract Subscription schedule(final Action1<Scheduler.Inner> action, final long delayTime, final TimeUnit unit);
+    public abstract Inner inner();
 
     /**
-     * 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
-     * @param unit
-     *            the time unit the interval above is given in
-     * @return a subscription to be able to unsubscribe from action
+     * Sequential Scheduler for executing actions on a single thread or event loop.
+     * <p>
+     * Unsubscribing the {@Inner} unschedules all outstanding work and allows resources cleanup.
      */
-    public Subscription schedulePeriodically(final Action1<Scheduler.Inner> action, long initialDelay, long period, TimeUnit unit) {
-        final long periodInNanos = unit.toNanos(period);
-
-        final Action1<Scheduler.Inner> recursiveAction = new Action1<Scheduler.Inner>() {
-            @Override
-            public void call(Inner inner) {
-                if (!inner.isUnsubscribed()) {
-                    long startedAt = now();
-                    action.call(inner);
-                    long timeTakenByActionInNanos = TimeUnit.MILLISECONDS.toNanos(now() - startedAt);
-                    inner.schedule(this, periodInNanos - timeTakenByActionInNanos, TimeUnit.NANOSECONDS);
-                }
-            }
-        };
-        return schedule(recursiveAction, initialDelay, unit);
-    }
-
-    public final Subscription scheduleRecursive(final Action1<Recurse> action) {
-        return schedule(new Action1<Inner>() {
-
-            @Override
-            public void call(Inner inner) {
-                action.call(new Recurse(inner, action));
-            }
-
-        });
-    }
-
-    public static final class Recurse {
-        private final Action1<Recurse> action;
-        private final Inner inner;
-
-        private Recurse(Inner inner, Action1<Recurse> 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<Inner>() {
-
-                @Override
-                public void call(Inner _inner) {
-                    action.call(self);
-                }
-
-            });
-        }
+    public abstract static class Inner implements Subscription {
 
         /**
-         * Schedule the current function for execution in the future.
+         * Schedules an Action for execution.
+         * 
+         * @param action
+         *            Action to schedule
+         * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
          */
-        public final void schedule(long delay, TimeUnit unit) {
-            final Recurse self = this;
-            inner.schedule(new Action1<Inner>() {
-
-                @Override
-                public void call(Inner _inner) {
-                    action.call(self);
-                }
 
-            }, delay, unit);
-        }
-    }
-
-    public abstract static class Inner implements Subscription {
+        public abstract Subscription schedule(Action0 action);
 
         /**
-         * Schedules an action to be executed in delayTime.
+         * Schedules an Action for execution at some point in the future.
          * 
+         * @param action
+         *            the Action to schedule
          * @param delayTime
-         *            time the action is to be delayed before executing
+         *            time to wait before executing the action
          * @param unit
-         *            time unit of the delay time
+         *            the time unit the delay time is given in
+         * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
          */
-        public abstract void schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit);
+        public abstract Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit);
 
         /**
-         * Schedules a cancelable action to be executed in delayTime.
+         * 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
+         * @param unit
+         *            the time unit the interval above is given in
+         * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
          */
-        public abstract void schedule(Action1<Scheduler.Inner> action);
+        public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
+            final long periodInNanos = unit.toNanos(period);
+
+            final Action0 recursiveAction = new Action0() {
+                @Override
+                public void call() {
+                    if (!isUnsubscribed()) {
+                        long startedAt = now();
+                        action.call();
+                        long timeTakenByActionInNanos = TimeUnit.MILLISECONDS.toNanos(now() - startedAt);
+                        schedule(this, periodInNanos - timeTakenByActionInNanos, TimeUnit.NANOSECONDS);
+                    }
+                }
+            };
+            return schedule(recursiveAction, initialDelay, unit);
+        }
 
         /**
          * @return the scheduler's notion of current absolute time in milliseconds.
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 46e1ea0846..c6604ea381 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -30,10 +30,11 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.MultipleAssignmentSubscription;
 
 /**
  * The base class for operations that break observables into "chunks". Currently buffers and windows.
@@ -154,7 +155,7 @@ protected static class TimeAndSizeBasedChunks<T, C> extends Chunks<T, C> impleme
 
         private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
 
-        private final Scheduler scheduler;
+        private final Scheduler.Inner scheduler;
         private final long maxTime;
         private final TimeUnit unit;
         private final int maxSize;
@@ -165,15 +166,15 @@ public TimeAndSizeBasedChunks(Observer<? super C> observer, Func0<? extends Chun
             this.maxSize = maxSize;
             this.maxTime = maxTime;
             this.unit = unit;
-            this.scheduler = scheduler;
+            this.scheduler = scheduler.inner();
         }
 
         @Override
         public Chunk<T, C> createChunk() {
             final Chunk<T, C> chunk = super.createChunk();
-            subscriptions.put(chunk, scheduler.schedule(new Action1<Inner>() {
+            subscriptions.put(chunk, scheduler.schedule(new Action0() {
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     emitChunk(chunk);
                 }
             }, maxTime, unit));
@@ -217,6 +218,7 @@ public void unsubscribe() {
             for (Subscription s : subscriptions.values()) {
                 s.unsubscribe();
             }
+            scheduler.unsubscribe();
         }
 
         @Override
@@ -238,7 +240,7 @@ protected static class TimeBasedChunks<T, C> extends OverlappingChunks<T, C> imp
 
         private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
 
-        private final Scheduler scheduler;
+        private final Scheduler.Inner scheduler;
         private final long time;
         private final TimeUnit unit;
         private volatile boolean unsubscribed = false;
@@ -247,15 +249,15 @@ public TimeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>
             super(observer, chunkMaker);
             this.time = time;
             this.unit = unit;
-            this.scheduler = scheduler;
+            this.scheduler = scheduler.inner();
         }
 
         @Override
         public Chunk<T, C> createChunk() {
             final Chunk<T, C> chunk = super.createChunk();
-            subscriptions.put(chunk, scheduler.schedule(new Action1<Inner>() {
+            subscriptions.put(chunk, scheduler.schedule(new Action0() {
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     emitChunk(chunk);
                 }
             }, time, unit));
@@ -274,6 +276,7 @@ public void unsubscribe() {
             for (Subscription s : subscriptions.values()) {
                 s.unsubscribe();
             }
+            scheduler.unsubscribe();
         }
 
         @Override
@@ -498,20 +501,20 @@ private void listenForChunkEnd() {
 
                 @Override
                 public void onCompleted() {
-                    
+
                 }
 
                 @Override
                 public void onError(Throwable e) {
-                    
+
                 }
 
                 @Override
                 public void onNext(TClosing t) {
                     chunks.emitAndReplaceChunk();
-                    listenForChunkEnd();                    
+                    listenForChunkEnd();
                 }
-                
+
             });
         }
 
@@ -545,12 +548,12 @@ public ObservableBasedMultiChunkCreator(final OverlappingChunks<T, C> chunks, Ob
 
                 @Override
                 public void onCompleted() {
-                    
+
                 }
 
                 @Override
                 public void onError(Throwable e) {
-                    
+
                 }
 
                 @Override
@@ -562,22 +565,22 @@ public void onNext(TOpening opening) {
 
                         @Override
                         public void onCompleted() {
-                            
+
                         }
 
                         @Override
                         public void onError(Throwable e) {
-                            
+
                         }
 
                         @Override
                         public void onNext(TClosing t) {
-                            chunks.emitChunk(chunk);                            
+                            chunks.emitChunk(chunk);
                         }
-                        
-                    });                    
+
+                    });
                 }
-                
+
             });
         }
 
@@ -602,24 +605,28 @@ public void stop() {
      */
     protected static class TimeBasedChunkCreator<T, C> implements ChunkCreator {
 
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
+        private final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription();
 
         public TimeBasedChunkCreator(final NonOverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            this.subscription.wrap(scheduler.schedulePeriodically(new Action1<Inner>() {
+            Inner inner = scheduler.inner();
+            this.subscription.set(inner);
+            inner.schedulePeriodically(new Action0() {
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     chunks.emitAndReplaceChunk();
                 }
-            }, 0, time, unit));
+            }, 0, time, unit);
         }
 
         public TimeBasedChunkCreator(final OverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            this.subscription.wrap(scheduler.schedulePeriodically(new Action1<Inner>() {
+            Inner inner = scheduler.inner();
+            this.subscription.set(inner);
+            inner.schedulePeriodically(new Action0() {
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     chunks.createChunk();
                 }
-            }, 0, time, unit));
+            }, 0, time, unit);
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 48c502d0b5..691fd80203 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -22,10 +22,9 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.observers.SerializedObserver;
 import rx.schedulers.Schedulers;
@@ -105,7 +104,7 @@ private static class DebounceObserver<T> extends Subscriber<T> {
         private final Observer<? super T> observer;
         private final long timeout;
         private final TimeUnit unit;
-        private final Scheduler scheduler;
+        private final Scheduler.Inner scheduler;
 
         private final AtomicReference<Subscription> lastScheduledNotification = new AtomicReference<Subscription>();
 
@@ -115,7 +114,7 @@ public DebounceObserver(Observer<? super T> observer, long timeout, TimeUnit uni
             this.observer = new SerializedObserver<T>(observer);
             this.timeout = timeout;
             this.unit = unit;
-            this.scheduler = scheduler;
+            this.scheduler = scheduler.inner();
         }
 
         @Override
@@ -142,10 +141,10 @@ public void onError(Throwable e) {
 
         @Override
         public void onNext(final T v) {
-            Subscription previousSubscription = lastScheduledNotification.getAndSet(scheduler.schedule(new Action1<Inner>() {
+            Subscription previousSubscription = lastScheduledNotification.getAndSet(scheduler.schedule(new Action0() {
 
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     observer.onNext(v);
                 }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index b996197a54..1e2dd0210f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -21,10 +21,9 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
@@ -62,13 +61,13 @@ public static <T> OnSubscribeFunc<T> delaySubscription(Observable<? extends T> s
     /** Subscribe function which schedules the actual subscription to source on a scheduler at a later time. */
     private static final class DelaySubscribeFunc<T> implements OnSubscribeFunc<T> {
         final Observable<? extends T> source;
-        final Scheduler scheduler;
+        final Scheduler.Inner scheduler;
         final long time;
         final TimeUnit unit;
 
         public DelaySubscribeFunc(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
             this.source = source;
-            this.scheduler = scheduler;
+            this.scheduler = scheduler.inner();
             this.time = time;
             this.unit = unit;
         }
@@ -77,9 +76,9 @@ public DelaySubscribeFunc(Observable<? extends T> source, long time, TimeUnit un
         public Subscription onSubscribe(final Observer<? super T> t1) {
             final SerialSubscription ssub = new SerialSubscription();
 
-            ssub.set(scheduler.schedule(new Action1<Inner>() {
+            ssub.set(scheduler.schedule(new Action0() {
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     if (!ssub.isUnsubscribed()) {
                         ssub.set(source.unsafeSubscribe(Subscribers.from(t1)));
                     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
index a0cd28537c..594bc6f984 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
@@ -23,9 +23,7 @@
 import rx.Scheduler.Inner;
 import rx.Subscription;
 import rx.functions.Action0;
-import rx.functions.Action1;
 import rx.schedulers.Schedulers;
-import rx.subscriptions.Subscriptions;
 
 /**
  * Returns an observable sequence that produces a value after each period.
@@ -68,20 +66,15 @@ private Interval(long period, TimeUnit unit, Scheduler scheduler) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> observer) {
-            final Subscription wrapped = scheduler.schedulePeriodically(new Action1<Inner>() {
+            Inner inner = scheduler.inner();
+            inner.schedulePeriodically(new Action0() {
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     observer.onNext(currentValue);
                     currentValue++;
                 }
             }, period, period, unit);
-
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    wrapped.unsubscribe();
-                }
-            });
+            return inner;
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 0696c86792..a583b2fc18 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -25,7 +25,7 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.subscriptions.CompositeSubscription;
 
 /**
@@ -60,16 +60,13 @@ public SkipTimed(Observable<? extends T> source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
-
-            SafeObservableSubscription timer = new SafeObservableSubscription();
-            SafeObservableSubscription data = new SafeObservableSubscription();
-
-            CompositeSubscription csub = new CompositeSubscription(timer, data);
-
+            Inner inner = scheduler.inner();
+            CompositeSubscription csub = new CompositeSubscription(inner);
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
-            data.wrap(source.unsafeSubscribe(so));
-            if (!data.isUnsubscribed()) {
-                timer.wrap(scheduler.schedule(so, time, unit));
+            csub.add(so);
+            source.unsafeSubscribe(so);
+            if (!so.isUnsubscribed()) {
+                inner.schedule(so, time, unit);
             }
 
             return csub;
@@ -81,7 +78,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
          * @param <T>
          *            the observed value type
          */
-        private static final class SourceObserver<T> extends Subscriber<T> implements Action1<Inner> {
+        private static final class SourceObserver<T> extends Subscriber<T> implements Action0 {
             final AtomicBoolean gate;
             final Observer<? super T> observer;
             final Subscription cancel;
@@ -119,7 +116,7 @@ public void onCompleted() {
             }
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 gate.set(true);
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
index cd52a04762..101cd7006a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
@@ -25,7 +25,7 @@
 import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 
@@ -191,16 +191,13 @@ public TakeTimed(Observable<? extends T> source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
-
-            SafeObservableSubscription timer = new SafeObservableSubscription();
-            SafeObservableSubscription data = new SafeObservableSubscription();
-
-            CompositeSubscription csub = new CompositeSubscription(timer, data);
-
+            Inner inner = scheduler.inner();
+            CompositeSubscription csub = new CompositeSubscription(inner);
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
-            data.wrap(source.unsafeSubscribe(so));
-            if (!data.isUnsubscribed()) {
-                timer.wrap(scheduler.schedule(so, time, unit));
+            csub.add(so);
+            source.unsafeSubscribe(so);
+            if (!so.isUnsubscribed()) {
+                inner.schedule(so, time, unit);
             }
 
             return csub;
@@ -212,7 +209,7 @@ public Subscription onSubscribe(Observer<? super T> t1) {
          * @param <T>
          *            the observed value type
          */
-        private static final class SourceObserver<T> extends Subscriber<T> implements Action1<Inner> {
+        private static final class SourceObserver<T> extends Subscriber<T> implements Action0 {
             final Observer<? super T> observer;
             final Subscription cancel;
             final AtomicInteger state = new AtomicInteger();
@@ -283,7 +280,7 @@ public void onCompleted() {
             }
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 onCompleted();
             }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
index 16f745129f..03353dcf2f 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.functions.Action1;
+import rx.functions.Action0;
 
 /**
  * Operation Timer with several overloads.
@@ -50,9 +50,9 @@ public TimerOnce(long dueTime, TimeUnit unit, Scheduler scheduler) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> t1) {
-            return scheduler.schedule(new Action1<Inner>() {
+            return scheduler.inner().schedule(new Action0() {
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     t1.onNext(0L);
                     t1.onCompleted();
                 }
@@ -79,14 +79,16 @@ public TimerPeriodically(long initialDelay, long period, TimeUnit unit, Schedule
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> t1) {
-            return scheduler.schedulePeriodically(new Action1<Inner>() {
+            Inner inner = scheduler.inner();
+            inner.schedulePeriodically(new Action0() {
                 long count;
 
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     t1.onNext(count++);
                 }
             }, initialDelay, period, unit);
+            return inner;
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 9a3b6937f5..45281cb831 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -20,9 +20,8 @@
 
 import rx.Observable.Operator;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.schedulers.ImmediateScheduler;
 import rx.schedulers.TrampolineScheduler;
 
@@ -51,23 +50,24 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
             // avoid overhead, execute directly
             return child;
         } else {
-            return new ObserveOnSubscriber(child);
+            return new ObserveOnSubscriber<T>(scheduler, child);
         }
     }
 
-    private final NotificationLite<T> on = NotificationLite.instance();
-
     /** Observe through individual queue per observer. */
-    private class ObserveOnSubscriber extends Subscriber<T> {
+    private static class ObserveOnSubscriber<T> extends Subscriber<T> {
+        private final NotificationLite<T> on = NotificationLite.instance();
         final Subscriber<? super T> observer;
-        private volatile Scheduler.Inner recursiveScheduler;
+        private final Scheduler.Inner recursiveScheduler;
 
         private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
         final AtomicLong counter = new AtomicLong(0);
 
-        public ObserveOnSubscriber(Subscriber<? super T> observer) {
-            super(observer);
-            this.observer = observer;
+        public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> subscriber) {
+            super(subscriber);
+            this.observer = subscriber;
+            this.recursiveScheduler = scheduler.inner();
+            subscriber.add(recursiveScheduler);
         }
 
         @Override
@@ -90,30 +90,17 @@ public void onError(final Throwable e) {
 
         protected void schedule() {
             if (counter.getAndIncrement() == 0) {
-                if (recursiveScheduler == null) {
-                    add(scheduler.schedule(new Action1<Inner>() {
-
-                        @Override
-                        public void call(Inner inner) {
-                            recursiveScheduler = inner;
-                            pollQueue();
-                        }
-
-                    }));
-                } else {
-                    recursiveScheduler.schedule(new Action1<Inner>() {
-
-                        @Override
-                        public void call(Inner inner) {
-                            pollQueue();
-                        }
-
-                    });
-                }
+                recursiveScheduler.schedule(new Action0() {
+
+                    @Override
+                    public void call() {
+                        pollQueue();
+                    }
+
+                });
             }
         }
 
-        @SuppressWarnings("unchecked")
         private void pollQueue() {
             do {
                 Object v = queue.poll();
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
deleted file mode 100644
index 7901a86f4f..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOnBounded.java
+++ /dev/null
@@ -1,310 +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.Semaphore;
-import java.util.concurrent.atomic.AtomicLong;
-
-import rx.Observable.Operator;
-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;
-
-/**
- * Delivers events on the specified Scheduler.
- * <p>
- * This provides backpressure by blocking the incoming onNext when there is already one in the
- * queue.
- * <p>
- * 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.
- * 
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/observeOn.png">
- */
-public class OperatorObserveOnBounded<T> implements Operator<T, T> {
-
-    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<? super T> call(Subscriber<? super T> 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 final NotificationLite<T> on = NotificationLite.instance();
-
-    /** Observe through individual queue per observer. */
-    private class ObserveOnSubscriber extends Subscriber<T> {
-        final Subscriber<? super T> observer;
-        private volatile Scheduler.Inner recursiveScheduler;
-
-        private final InterruptibleBlockingQueue<Object> queue = new InterruptibleBlockingQueue<Object>(bufferSize);
-        final AtomicLong counter = new AtomicLong(0);
-
-        public ObserveOnSubscriber(Subscriber<? super T> 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
-                queue.addBlocking(on.next(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(on.completed());
-                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(on.error(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<Inner>() {
-
-                        @Override
-                        public void call(Inner inner) {
-                            recursiveScheduler = inner;
-                            pollQueue();
-                        }
-
-                    }));
-                } else {
-                    recursiveScheduler.schedule(new Action1<Inner>() {
-
-                        @Override
-                        public void call(Inner inner) {
-                            pollQueue();
-                        }
-
-                    });
-                }
-            }
-        }
-
-        @SuppressWarnings("unchecked")
-        private void pollQueue() {
-            do {
-                Object v = queue.poll();
-                on.accept(observer, 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 <E>
-     */
-    private static class InterruptibleBlockingQueue<E> {
-
-        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/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index 3c0b08b5f3..48acabea23 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -21,7 +21,7 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.observers.Subscribers;
 import rx.schedulers.Schedulers;
 
@@ -70,12 +70,16 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(final Observable<T> t) {
-                scheduler.schedule(new Action1<Inner>() {
+                // will only be invoked once since we're nested
+                final Inner inner = scheduler.inner();
+                // cleanup on unsubscribe
+                add(inner);
+                inner.schedule(new Action0() {
 
-                    final Action1<Inner> self = this;
+                    final Action0 self = this;
 
                     @Override
-                    public void call(final Inner inner) {
+                    public void call() {
                         executionCount++;
                         t.unsafeSubscribe(new Subscriber<T>(child) {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index ca5e7da892..94760f01b9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -35,13 +35,11 @@
 
 import rx.Observable;
 import rx.Observable.Operator;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscriber;
 import rx.functions.Action0;
-import rx.functions.Action1;
 import rx.schedulers.Schedulers;
 import rx.subscriptions.SerialSubscription;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorRetry<T> implements Operator<T, Observable<T>> {
 
@@ -49,6 +47,8 @@ public class OperatorRetry<T> implements Operator<T, Observable<T>> {
 
     private final int retryCount;
 
+    private static Scheduler scheduler = Schedulers.trampoline();
+
     public OperatorRetry(int retryCount) {
         this.retryCount = retryCount;
     }
@@ -59,6 +59,9 @@ public OperatorRetry() {
 
     @Override
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> child) {
+        final Scheduler.Inner inner = scheduler.inner();
+        child.add(inner);
+        
         final SerialSubscription serialSubscription = new SerialSubscription();
         // add serialSubscription so it gets unsubscribed if child is unsubscribed
         child.add(serialSubscription);
@@ -77,11 +80,11 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(final Observable<T> o) {
-                Schedulers.trampoline().schedule(new Action1<Inner>() {
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(final Inner inner) {
-                        final Action1<Inner> _self = this;
+                    public void call() {
+                        final Action0 _self = this;
                         attempts.incrementAndGet();
 
                         // new subscription each time so if it unsubscribes itself it does not prevent retries
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 29e01fd369..409a6e1e4d 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.functions.Action1;
+import rx.functions.Action0;
 
 /**
  * Subscribes Observers on the specified Scheduler.
@@ -37,6 +37,8 @@ public OperatorSubscribeOn(Scheduler scheduler) {
 
     @Override
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> subscriber) {
+        final Inner inner = scheduler.inner();
+        subscriber.add(inner);
         return new Subscriber<Observable<T>>(subscriber) {
 
             @Override
@@ -51,13 +53,13 @@ public void onError(Throwable e) {
 
             @Override
             public void onNext(final Observable<T> o) {
-                subscriber.add(scheduler.schedule(new Action1<Inner>() {
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(final Inner inner) {
+                    public void call() {
                         o.unsafeSubscribe(subscriber);
                     }
-                }));
+                });
             }
 
         };
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
index eb5debfcd5..0048810bd9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
@@ -19,9 +19,8 @@
 
 import rx.Observable;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 
 /**
  * Applies a timeout policy for each element in the observable sequence, using
@@ -32,17 +31,14 @@
  */
 public final class OperatorTimeout<T> extends OperatorTimeoutBase<T> {
 
-    public OperatorTimeout(final long timeout, final TimeUnit timeUnit,
-            Observable<? extends T> other, final Scheduler scheduler) {
+    public OperatorTimeout(final long timeout, final TimeUnit timeUnit, Observable<? extends T> other, Scheduler scheduler) {
         super(new FirstTimeoutStub<T>() {
 
             @Override
-            public Subscription call(
-                    final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId) {
-                return scheduler.schedule(new Action1<Inner>() {
+            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, Scheduler.Inner inner) {
+                return inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         timeoutSubscriber.onTimeout(seqId);
                     }
                 }, timeout, timeUnit);
@@ -50,16 +46,14 @@ public void call(Inner inner) {
         }, new TimeoutStub<T>() {
 
             @Override
-            public Subscription call(
-                    final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId, T value) {
-                return scheduler.schedule(new Action1<Inner>() {
+            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, T value, Scheduler.Inner inner) {
+                return inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         timeoutSubscriber.onTimeout(seqId);
                     }
                 }, timeout, timeUnit);
             }
-        }, other);
+        }, other, scheduler);
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index 52069a20f6..edb6139eb6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -21,10 +21,12 @@
 
 import rx.Observable;
 import rx.Observable.Operator;
+import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func2;
 import rx.functions.Func3;
+import rx.functions.Func4;
 import rx.observers.SerializedSubscriber;
 import rx.subscriptions.SerialSubscription;
 
@@ -36,7 +38,7 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
      * @param <T>
      */
     /* package-private */static interface FirstTimeoutStub<T> extends
-            Func2<TimeoutSubscriber<T>, Long, Subscription> {
+            Func3<TimeoutSubscriber<T>, Long, Scheduler.Inner, Subscription> {
     }
 
     /**
@@ -45,23 +47,25 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
      * @param <T>
      */
     /* package-private */static interface TimeoutStub<T> extends
-            Func3<TimeoutSubscriber<T>, Long, T, Subscription> {
+            Func4<TimeoutSubscriber<T>, Long, T, Scheduler.Inner, Subscription> {
     }
 
     private final FirstTimeoutStub<T> firstTimeoutStub;
     private final TimeoutStub<T> timeoutStub;
     private final Observable<? extends T> other;
+    private final Scheduler scheduler;
 
-    /* package-private */OperatorTimeoutBase(
-            FirstTimeoutStub<T> firstTimeoutStub, TimeoutStub<T> timeoutStub,
-            Observable<? extends T> other) {
+    /* package-private */OperatorTimeoutBase(FirstTimeoutStub<T> firstTimeoutStub, TimeoutStub<T> timeoutStub, Observable<? extends T> other, Scheduler scheduler) {
         this.firstTimeoutStub = firstTimeoutStub;
         this.timeoutStub = timeoutStub;
         this.other = other;
+        this.scheduler = scheduler;
     }
 
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
+        Scheduler.Inner inner = scheduler.inner();
+        subscriber.add(inner);
         final SerialSubscription serial = new SerialSubscription();
         subscriber.add(serial);
         // Use SynchronizedSubscriber for safe memory access
@@ -69,9 +73,8 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         // scheduler or other Observables.
         final SerializedSubscriber<T> synchronizedSubscriber = new SerializedSubscriber<T>(subscriber);
 
-        TimeoutSubscriber<T> timeoutSubscriber = new TimeoutSubscriber<T>(
-                synchronizedSubscriber, timeoutStub, serial, other);
-        serial.set(firstTimeoutStub.call(timeoutSubscriber, 0L));
+        TimeoutSubscriber<T> timeoutSubscriber = new TimeoutSubscriber<T>(synchronizedSubscriber, timeoutStub, serial, other, inner);
+        serial.set(firstTimeoutStub.call(timeoutSubscriber, 0L, inner));
         return timeoutSubscriber;
     }
 
@@ -88,16 +91,19 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         private final TimeoutStub<T> timeoutStub;
 
         private final Observable<? extends T> other;
+        private final Scheduler.Inner inner;
 
         private TimeoutSubscriber(
                 SerializedSubscriber<T> serializedSubscriber,
                 TimeoutStub<T> timeoutStub, SerialSubscription serial,
-                Observable<? extends T> other) {
+                Observable<? extends T> other,
+                Scheduler.Inner inner) {
             super(serializedSubscriber);
             this.serializedSubscriber = serializedSubscriber;
             this.timeoutStub = timeoutStub;
             this.serial = serial;
             this.other = other;
+            this.inner = inner;
         }
 
         @Override
@@ -111,7 +117,7 @@ public void onNext(T value) {
             }
             if (onNextWins) {
                 serializedSubscriber.onNext(value);
-                serial.set(timeoutStub.call(this, actual.get(), value));
+                serial.set(timeoutStub.call(this, actual.get(), value, inner));
             }
         }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
index 95505f87e3..cefbed566d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
@@ -16,11 +16,13 @@
 package rx.operators;
 
 import rx.Observable;
+import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.exceptions.Exceptions;
 import rx.functions.Func0;
 import rx.functions.Func1;
+import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -41,7 +43,7 @@ public OperatorTimeoutWithSelector(
             @Override
             public Subscription call(
                     final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId) {
+                    final Long seqId, Scheduler.Inner inner) {
                 if (firstTimeoutSelector != null) {
                     Observable<U> o = null;
                     try {
@@ -78,7 +80,7 @@ public void onNext(U t) {
             @Override
             public Subscription call(
                     final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId, T value) {
+                    final Long seqId, T value, Scheduler.Inner inner) {
                 Observable<V> o = null;
                 try {
                     o = timeoutSelector.call(value);
@@ -106,7 +108,7 @@ public void onNext(V t) {
 
                 });
             }
-        }, other);
+        }, other, Schedulers.immediate());
     }
 
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
index c48e0bc69f..a0eac086ed 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
@@ -17,12 +17,9 @@
 
 import rx.Observable.Operator;
 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;
 
 /**
@@ -44,15 +41,15 @@ public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
 
             @Override
             public void call() {
-                final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
-                mas.set(scheduler.schedule(new Action1<Inner>() {
+                final Scheduler.Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(final Inner inner) {
+                    public void call() {
                         parentSubscription.unsubscribe();
-                        mas.unsubscribe();
+                        inner.unsubscribe();
                     }
-                }));
+                });
             }
 
         }));
diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
index ff994f0759..4a69b45a57 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
@@ -24,13 +24,12 @@
 
 import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.subscriptions.MultipleAssignmentSubscription;
 import rx.subscriptions.Subscriptions;
 
 /**
- * A {@link Scheduler} implementation that uses an {@link Executor} or {@link ScheduledExecutorService}
- * implementation.
+ * A {@link Scheduler} implementation that uses an {@link Executor} or {@link ScheduledExecutorService} implementation.
  * <p>
  * Note that if an {@link Executor} implementation is used instead of {@link ScheduledExecutorService} then a
  * system-wide Timer will be used to handle delayed events.
@@ -55,39 +54,8 @@ public ExecutorScheduler(ScheduledExecutorService executor) {
     }
 
     @Override
-    public Subscription schedule(Action1<Scheduler.Inner> action) {
-        InnerExecutorScheduler inner = new InnerExecutorScheduler();
-        inner.schedule(action);
-        return inner.innerSubscription;
-    }
-
-    @Override
-    public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        InnerExecutorScheduler inner = new InnerExecutorScheduler();
-        inner.schedule(action, delayTime, unit);
-        return inner.innerSubscription;
-    }
-
-    @Override
-    public Subscription schedulePeriodically(final Action1<Scheduler.Inner> action, long initialDelay, long period, TimeUnit unit) {
-        if (executor instanceof ScheduledExecutorService) {
-            final InnerExecutorScheduler inner = new InnerExecutorScheduler();
-            ScheduledFuture<?> f = ((ScheduledExecutorService) executor).scheduleAtFixedRate(new Runnable() {
-                @Override
-                public void run() {
-                    if (inner.isUnsubscribed()) {
-                        // don't execute if unsubscribed
-                        return;
-                    }
-                    action.call(inner);
-                }
-            }, initialDelay, period, unit);
-
-            inner.innerSubscription.set(Subscriptions.from(f));
-            return inner;
-        } else {
-            return super.schedulePeriodically(action, initialDelay, period, unit);
-        }
+    public Inner inner() {
+        return new InnerExecutorScheduler();
     }
 
     private class InnerExecutorScheduler extends Scheduler.Inner {
@@ -95,13 +63,12 @@ private class InnerExecutorScheduler extends Scheduler.Inner {
         private final MultipleAssignmentSubscription innerSubscription = new MultipleAssignmentSubscription();
 
         @Override
-        public void schedule(final Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit) {
+        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
             if (innerSubscription.isUnsubscribed()) {
                 // don't schedule, we are unsubscribed
-                return;
+                return Subscriptions.empty();
             }
 
-            final Inner _inner = this;
             if (executor instanceof ScheduledExecutorService) {
                 // we are a ScheduledExecutorService so can do proper scheduling
                 ScheduledFuture<?> f = ((ScheduledExecutorService) executor).schedule(new Runnable() {
@@ -112,16 +79,18 @@ public void run() {
                             return;
                         }
                         // when the delay has passed we now do the work on the actual scheduler
-                        action.call(_inner);
+                        action.call();
                     }
                 }, delayTime, unit);
                 // add the ScheduledFuture as a subscription so we can cancel the scheduled action if an unsubscribe happens
-                innerSubscription.set(Subscriptions.from(f));
+                Subscription s = Subscriptions.from(f);
+                innerSubscription.set(s);
+                return s;
             } else {
                 // we are not a ScheduledExecutorService so can't directly schedule
                 if (delayTime == 0) {
                     // no delay so put on the thread-pool right now
-                    schedule(action);
+                    return schedule(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
@@ -138,20 +107,21 @@ public void run() {
                         }
                     }, delayTime, unit);
                     // add the ScheduledFuture as a subscription so we can cancel the scheduled action if an unsubscribe happens
-                    innerSubscription.set(Subscriptions.from(f));
+                    Subscription s = Subscriptions.from(f);
+                    innerSubscription.set(s);
+                    return s;
                 }
             }
         }
 
         @Override
-        public void schedule(final Action1<Scheduler.Inner> action) {
+        public Subscription schedule(final Action0 action) {
             if (innerSubscription.isUnsubscribed()) {
                 // don't schedule, we are unsubscribed
-                return;
+                return Subscriptions.empty();
             }
 
             // work to be done on a thread
-            final Inner _inner = this;
             Runnable r = new Runnable() {
                 @Override
                 public void run() {
@@ -159,7 +129,7 @@ public void run() {
                         // don't execute if unsubscribed
                         return;
                     }
-                    action.call(_inner);
+                    action.call();
                 }
             };
 
@@ -168,10 +138,35 @@ public void run() {
                 // 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
-                innerSubscription.set(Subscriptions.from(f));
+                Subscription s = Subscriptions.from(f);
+                innerSubscription.set(s);
+                return s;
             } else {
                 // we are the lowest common denominator so can't unsubscribe once we execute
                 executor.execute(r);
+                return Subscriptions.empty();
+            }
+        }
+
+        @Override
+        public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
+            if (executor instanceof ScheduledExecutorService) {
+                ScheduledFuture<?> f = ((ScheduledExecutorService) executor).scheduleAtFixedRate(new Runnable() {
+                    @Override
+                    public void run() {
+                        if (isUnsubscribed()) {
+                            // don't execute if unsubscribed
+                            return;
+                        }
+                        action.call();
+                    }
+                }, initialDelay, period, unit);
+
+                Subscription s = Subscriptions.from(f);
+                innerSubscription.set(s);
+                return s;
+            } else {
+                return super.schedulePeriodically(action, initialDelay, period, unit);
             }
         }
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
index e5f5ca6e8a..ea7681ba13 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -19,8 +19,9 @@
 
 import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.Subscriptions;
 
 /**
  * Executes work immediately on the current thread.
@@ -45,17 +46,8 @@ public static ImmediateScheduler getInstance() {
     }
 
     @Override
-    public Subscription schedule(Action1<Scheduler.Inner> action) {
-        InnerImmediateScheduler inner = new InnerImmediateScheduler();
-        inner.schedule(action);
-        return inner.innerSubscription;
-    }
-
-    @Override
-    public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        InnerImmediateScheduler inner = new InnerImmediateScheduler();
-        inner.schedule(action, delayTime, unit);
-        return inner.innerSubscription;
+    public Inner inner() {
+        return new InnerImmediateScheduler();
     }
 
     private class InnerImmediateScheduler extends Scheduler.Inner implements Subscription {
@@ -63,16 +55,17 @@ private class InnerImmediateScheduler extends Scheduler.Inner implements Subscri
         final BooleanSubscription innerSubscription = new BooleanSubscription();
 
         @Override
-        public void schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit) {
+        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             // since we are executing immediately on this thread we must cause this thread to sleep
             long execTime = now() + unit.toMillis(delayTime);
 
-            schedule(new SleepingAction(action, ImmediateScheduler.this, execTime));
+            return schedule(new SleepingAction(action, this, execTime));
         }
 
         @Override
-        public void schedule(Action1<Scheduler.Inner> action) {
-            action.call(this);
+        public Subscription schedule(Action0 action) {
+            action.call();
+            return Subscriptions.empty();
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 975918f292..32271a8e71 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -25,7 +25,7 @@
 
 import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 
@@ -64,33 +64,23 @@ private NewThreadScheduler() {
     }
 
     @Override
-    public Subscription schedule(Action1<Scheduler.Inner> action) {
-        EventLoopScheduler innerScheduler = new EventLoopScheduler();
-        innerScheduler.schedule(action);
-        return innerScheduler.innerSubscription;
-    }
-
-    @Override
-    public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        EventLoopScheduler innerScheduler = new EventLoopScheduler();
-        innerScheduler.schedule(action, delayTime, unit);
-        return innerScheduler.innerSubscription;
+    public Inner inner() {
+        return new EventLoopScheduler();
     }
 
     private class EventLoopScheduler extends Scheduler.Inner implements Subscription {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
         private final ExecutorService executor;
-        private final Inner _inner = this;
 
         private EventLoopScheduler() {
             executor = Executors.newSingleThreadExecutor(THREAD_FACTORY);
         }
 
         @Override
-        public void schedule(final Action1<Scheduler.Inner> action) {
+        public Subscription schedule(final Action0 action) {
             if (innerSubscription.isUnsubscribed()) {
                 // don't schedule, we are unsubscribed
-                return;
+                return Subscriptions.empty();
             }
 
             final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
@@ -102,7 +92,7 @@ public void run() {
                         if (innerSubscription.isUnsubscribed()) {
                             return;
                         }
-                        action.call(_inner);
+                        action.call();
                     } finally {
                         // remove the subscription now that we're completed
                         Subscription s = sf.get();
@@ -115,10 +105,11 @@ public void run() {
 
             sf.set(s);
             innerSubscription.add(s);
+            return s;
         }
 
         @Override
-        public void schedule(final Action1<Inner> action, long delayTime, TimeUnit unit) {
+        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
             final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
             // 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
@@ -146,6 +137,7 @@ public void run() {
             Subscription s = Subscriptions.from(f);
             sf.set(s);
             innerSubscription.add(s);
+            return s;
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
index cd4a39e046..3748b053ce 100644
--- a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
+++ b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
@@ -16,27 +16,26 @@
 package rx.schedulers;
 
 import rx.Scheduler;
-import rx.Scheduler.Inner;
-import rx.functions.Action1;
+import rx.functions.Action0;
 
-/* package */class SleepingAction implements Action1<Scheduler.Inner> {
-    private final Action1<Scheduler.Inner> underlying;
-    private final Scheduler scheduler;
+/* package */class SleepingAction implements Action0 {
+    private final Action0 underlying;
+    private final Scheduler.Inner innerScheduler;
     private final long execTime;
 
-    public SleepingAction(Action1<Scheduler.Inner> underlying, Scheduler scheduler, long execTime) {
+    public SleepingAction(Action0 underlying, Scheduler.Inner scheduler, long execTime) {
         this.underlying = underlying;
-        this.scheduler = scheduler;
+        this.innerScheduler = scheduler;
         this.execTime = execTime;
     }
 
     @Override
-    public void call(Inner s) {
-        if (s.isUnsubscribed()) {
+    public void call() {
+        if (innerScheduler.isUnsubscribed()) {
             return;
         }
-        if (execTime > scheduler.now()) {
-            long delay = execTime - scheduler.now();
+        if (execTime > innerScheduler.now()) {
+            long delay = execTime - innerScheduler.now();
             if (delay > 0) {
                 try {
                     Thread.sleep(delay);
@@ -48,9 +47,9 @@ public void call(Inner s) {
         }
 
         // after waking up check the subscription
-        if (s.isUnsubscribed()) {
+        if (innerScheduler.isUnsubscribed()) {
             return;
         }
-        underlying.call(s);
+        underlying.call();
     }
 }
diff --git a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
index 1231c71fa4..1c9f67d229 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
@@ -22,8 +22,9 @@
 
 import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.Subscriptions;
 
 public class TestScheduler extends Scheduler {
     private final Queue<TimedAction> queue = new PriorityQueue<TimedAction>(11, new CompareActionsByTime());
@@ -32,11 +33,11 @@ public class TestScheduler extends Scheduler {
     private static class TimedAction {
 
         private final long time;
-        private final Action1<Inner> action;
+        private final Action0 action;
         private final Inner scheduler;
         private final long count = counter++; // for differentiating tasks at same time
 
-        private TimedAction(Inner scheduler, long time, Action1<Inner> action) {
+        private TimedAction(Inner scheduler, long time, Action0 action) {
             this.time = time;
             this.action = action;
             this.scheduler = scheduler;
@@ -91,30 +92,15 @@ private void triggerActions(long targetTimeInNanos) {
 
             // Only execute if not unsubscribed
             if (!current.scheduler.isUnsubscribed()) {
-                current.action.call(current.scheduler);
+                current.action.call();
             }
         }
         time = targetTimeInNanos;
     }
 
-    public Inner createInnerScheduler() {
-        return new InnerTestScheduler();
-    }
-
     @Override
-    public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        Inner inner = createInnerScheduler();
-        final TimedAction timedAction = new TimedAction(inner, time + unit.toNanos(delayTime), action);
-        queue.add(timedAction);
-        return inner;
-    }
-
-    @Override
-    public Subscription schedule(Action1<Inner> action) {
-        Inner inner = createInnerScheduler();
-        final TimedAction timedAction = new TimedAction(inner, 0, action);
-        queue.add(timedAction);
-        return inner;
+    public Inner inner() {
+        return new InnerTestScheduler();
     }
 
     private final class InnerTestScheduler extends Inner {
@@ -132,15 +118,36 @@ public boolean isUnsubscribed() {
         }
 
         @Override
-        public void schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
+        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             final TimedAction timedAction = new TimedAction(this, time + unit.toNanos(delayTime), action);
             queue.add(timedAction);
+            return Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    queue.remove(timedAction);
+                }
+
+            });
         }
 
         @Override
-        public void schedule(Action1<Inner> action) {
+        public Subscription schedule(Action0 action) {
             final TimedAction timedAction = new TimedAction(this, 0, action);
             queue.add(timedAction);
+            return Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    queue.remove(timedAction);
+                }
+
+            });
+        }
+
+        @Override
+        public long now() {
+            return TestScheduler.this.now();
         }
 
     }
diff --git a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
index 314a43dc7d..6d9bc580cb 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -21,8 +21,9 @@
 
 import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.Subscriptions;
 
 /**
  * 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.
@@ -38,23 +39,14 @@ public class TrampolineScheduler extends Scheduler {
     public static TrampolineScheduler getInstance() {
         return INSTANCE;
     }
-    
-    /* package */ static TrampolineScheduler instance() {
-        return INSTANCE;
-    }
 
-    @Override
-    public Subscription schedule(Action1<Scheduler.Inner> action) {
-        InnerCurrentThreadScheduler inner = new InnerCurrentThreadScheduler();
-        inner.schedule(action);
-        return inner.innerSubscription;
+    /* package */static TrampolineScheduler instance() {
+        return INSTANCE;
     }
 
     @Override
-    public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        InnerCurrentThreadScheduler inner = new InnerCurrentThreadScheduler();
-        inner.schedule(action, delayTime, unit);
-        return inner.innerSubscription;
+    public Inner inner() {
+        return new InnerCurrentThreadScheduler();
     }
 
     /* package accessible for unit tests */TrampolineScheduler() {
@@ -69,20 +61,20 @@ private class InnerCurrentThreadScheduler extends Scheduler.Inner implements Sub
         private final BooleanSubscription innerSubscription = new BooleanSubscription();
 
         @Override
-        public void schedule(Action1<Scheduler.Inner> action) {
-            enqueue(action, now());
+        public Subscription schedule(Action0 action) {
+            return enqueue(action, now());
         }
 
         @Override
-        public void schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit) {
+        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             long execTime = now() + unit.toMillis(delayTime);
 
-            enqueue(new SleepingAction(action, TrampolineScheduler.this, execTime), execTime);
+            return enqueue(new SleepingAction(action, this, execTime), execTime);
         }
 
-        private void enqueue(Action1<Scheduler.Inner> action, long execTime) {
+        private Subscription enqueue(Action0 action, long execTime) {
             if (innerSubscription.isUnsubscribed()) {
-                return;
+                return Subscriptions.empty();
             }
             PriorityQueue<TimedAction> queue = QUEUE.get();
             boolean exec = queue == null;
@@ -92,17 +84,31 @@ private void enqueue(Action1<Scheduler.Inner> action, long execTime) {
                 QUEUE.set(queue);
             }
 
-            queue.add(new TimedAction(action, execTime, counter.incrementAndGet()));
+            final TimedAction timedAction = new TimedAction(action, execTime, counter.incrementAndGet());
+            queue.add(timedAction);
 
             if (exec) {
                 while (!queue.isEmpty()) {
                     if (innerSubscription.isUnsubscribed()) {
-                        return;
+                        return Subscriptions.empty();
                     }
-                    queue.poll().action.call(this);
+                    queue.poll().action.call();
                 }
 
                 QUEUE.set(null);
+                return Subscriptions.empty();
+            } else {
+                return Subscriptions.create(new Action0() {
+
+                    @Override
+                    public void call() {
+                        PriorityQueue<TimedAction> _q = QUEUE.get();
+                        if (_q != null) {
+                            _q.remove(timedAction);
+                        }
+                    }
+
+                });
             }
         }
 
@@ -120,11 +126,11 @@ public boolean isUnsubscribed() {
     }
 
     private static class TimedAction implements Comparable<TimedAction> {
-        final Action1<Scheduler.Inner> action;
+        final Action0 action;
         final Long execTime;
         final Integer count; // In case if time between enqueueing took less than 1ms
 
-        private TimedAction(Action1<Scheduler.Inner> action, Long execTime, Integer count) {
+        private TimedAction(Action0 action, Long execTime, Integer count) {
             this.action = action;
             this.execTime = execTime;
             this.count = count;
diff --git a/rxjava-core/src/main/java/rx/subjects/TestSubject.java b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
index 002b904e23..5a006ab84d 100644
--- a/rxjava-core/src/main/java/rx/subjects/TestSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
@@ -22,7 +22,6 @@
 import rx.Notification;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.schedulers.TestScheduler;
@@ -97,7 +96,7 @@ protected TestSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T>
         super(onSubscribe);
         this.subscriptionManager = subscriptionManager;
         this.lastNotification = lastNotification;
-        this.innerScheduler = scheduler.createInnerScheduler();
+        this.innerScheduler = scheduler.inner();
     }
 
     @Override
@@ -121,10 +120,10 @@ public void call() {
     }
 
     public void onCompleted(long timeInMilliseconds) {
-        innerScheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
 
             @Override
-            public void call(Inner t1) {
+            public void call() {
                 _onCompleted();
             }
 
@@ -153,10 +152,10 @@ public void call() {
     }
 
     public void onError(final Throwable e, long timeInMilliseconds) {
-        innerScheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
 
             @Override
-            public void call(Inner t1) {
+            public void call() {
                 _onError(e);
             }
 
@@ -175,10 +174,10 @@ private void _onNext(T v) {
     }
 
     public void onNext(final T v, long timeInMilliseconds) {
-        innerScheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
 
             @Override
-            public void call(Inner t1) {
+            public void call() {
                 _onNext(v);
             }
 
diff --git a/rxjava-core/src/perf/java/rx/archive/operators/OperatorObserveOnPerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorObserveOnPerformance.java
index e86f112990..26f8d3611c 100644
--- a/rxjava-core/src/perf/java/rx/archive/operators/OperatorObserveOnPerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorObserveOnPerformance.java
@@ -4,7 +4,6 @@
 import rx.archive.perf.AbstractPerformanceTester;
 import rx.archive.perf.IntegerSumObserver;
 import rx.functions.Action0;
-import rx.operators.OperatorObserveOnBounded;
 import rx.schedulers.Schedulers;
 
 public class OperatorObserveOnPerformance extends AbstractPerformanceTester {
@@ -23,7 +22,7 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    spt.timeObserveOnUnbounded();
+                    spt.timeObserveOn();
                 }
             });
         } catch (Exception e) {
@@ -54,54 +53,11 @@ public void call() {
      * Run: 14 - 43,290,043 ops/sec
      * 
      */
-    public long timeObserveOnUnbounded() {
+    public long timeObserveOn() {
         Observable<Integer> s = Observable.range(1, (int) reps).observeOn(Schedulers.immediate());
         IntegerSumObserver o = new IntegerSumObserver();
         s.subscribe(o);
         return o.sum;
     }
 
-    /**
-     * 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 timeObserveOnBounded() {
-        Observable<Integer> s = Observable.range(1, (int) reps).lift(new OperatorObserveOnBounded<Integer>(Schedulers.newThread(), 16));
-        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/archive/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
index 2e120596ee..26e48fafc2 100644
--- a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
@@ -20,7 +20,7 @@
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.schedulers.Schedulers;
 
 /**
@@ -29,78 +29,82 @@
  */
 public class TestRecursionMemoryUsage {
 
-	public static void main(String args[]) {
-		usingFunc2(Schedulers.newThread());
-		usingAction0(Schedulers.newThread());
+    public static void main(String args[]) {
+        usingFunc2(Schedulers.newThread());
+        usingAction0(Schedulers.newThread());
 
-		usingFunc2(Schedulers.currentThread());
-		usingAction0(Schedulers.currentThread());
+        usingFunc2(Schedulers.immediate());
+        usingAction0(Schedulers.immediate());
 
-		usingFunc2(Schedulers.computation());
-		usingAction0(Schedulers.computation());
+        usingFunc2(Schedulers.computation());
+        usingAction0(Schedulers.computation());
 
-		System.exit(0);
-	}
+        System.exit(0);
+    }
 
-	protected static void usingFunc2(final Scheduler scheduler) {
-		System.out.println("************ usingFunc2: " + scheduler);
-		Observable.create(new OnSubscribe<Long>() {
+    protected static void usingFunc2(final Scheduler scheduler) {
+        System.out.println("************ usingFunc2: " + scheduler);
+        Observable.create(new OnSubscribe<Long>() {
 
-			@Override
-			public void call(final Subscriber<? super Long> o) {
-				o.add(scheduler.schedule(new Action1<Inner>() {
-					long i = 0;
+            @Override
+            public void call(final Subscriber<? super Long> o) {
+                final Inner inner = scheduler.inner();
+                o.add(inner);
+                inner.schedule(new Action0() {
+                    long i = 0;
 
-					@Override
-					public void call(Inner inner) {
-						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;
-						}
+                    @Override
+                    public void call() {
+                        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;
+                        }
 
-						inner.schedule(this);
-					}
-				}));
-			}
-		}).toBlockingObservable().last();
-	}
+                        inner.schedule(this);
+                    }
+                });
+            }
+        }).toBlockingObservable().last();
+    }
 
-	protected static void usingAction0(final Scheduler scheduler) {
-		System.out.println("************ usingAction0: " + scheduler);
-		Observable.create(new OnSubscribe<Long>() {
+    protected static void usingAction0(final Scheduler scheduler) {
+        System.out.println("************ usingAction0: " + scheduler);
+        Observable.create(new OnSubscribe<Long>() {
 
-			@Override
-			public void call(final Subscriber<? super Long> o) {
-				o.add(scheduler.schedule(new Action1<Inner>() {
+            @Override
+            public void call(final Subscriber<? super Long> o) {
+                final Inner inner = scheduler.inner();
+                o.add(inner);
+                inner.schedule(new Action0() {
 
-					private long i = 0;
+                    private long i = 0;
 
-					@Override
-					public void call(Inner inner) {
-						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;
-						}
-						inner.schedule(this);
-					}
-				}));
-			}
-		}).toBlockingObservable().last();
-	}
+                    @Override
+                    public void call() {
+                        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;
+                        }
+                        inner.schedule(this);
+                    }
+                });
+            }
+        }).toBlockingObservable().last();
+    }
 }
diff --git a/rxjava-core/src/test/java/rx/ConcatTests.java b/rxjava-core/src/test/java/rx/ConcatTests.java
index 9fbb926350..cf5cc5bd33 100644
--- a/rxjava-core/src/test/java/rx/ConcatTests.java
+++ b/rxjava-core/src/test/java/rx/ConcatTests.java
@@ -15,7 +15,8 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/ErrorHandlingTests.java b/rxjava-core/src/test/java/rx/ErrorHandlingTests.java
index 7e30305d0b..3facbb1fa0 100644
--- a/rxjava-core/src/test/java/rx/ErrorHandlingTests.java
+++ b/rxjava-core/src/test/java/rx/ErrorHandlingTests.java
@@ -15,7 +15,7 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertNotNull;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
diff --git a/rxjava-core/src/test/java/rx/EventStream.java b/rxjava-core/src/test/java/rx/EventStream.java
index ad92262695..abdcf82ca6 100644
--- a/rxjava-core/src/test/java/rx/EventStream.java
+++ b/rxjava-core/src/test/java/rx/EventStream.java
@@ -19,9 +19,9 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Scheduler.Inner;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.schedulers.Schedulers;
 
 /**
@@ -30,32 +30,27 @@
 public class EventStream {
 
     public static Observable<Event> getEventStream(final String type, final int numInstances) {
-        return Observable.create(new OnSubscribeFunc<Event>() {
+        return Observable.create(new OnSubscribe<Event>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super Event> observer) {
+            public void call(final Subscriber<? super Event> subscriber) {
+                Inner inner = Schedulers.newThread().inner();
+                subscriber.add(inner);
                 // run on a background thread inside the OnSubscribeFunc so unsubscribe works
-                return Schedulers.newThread().schedule(new Action1<Inner>() {
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(Inner inner) {
-                        inner.schedule(new Action1<Inner>() {
-
-                            @Override
-                            public void call(Inner inner) {
-                                while (!(inner.isUnsubscribed() || Thread.currentThread().isInterrupted())) {
-                                    observer.onNext(randomEvent(type, numInstances));
-                                    try {
-                                        // slow it down somewhat
-                                        Thread.sleep(50);
-                                    } catch (InterruptedException e) {
-                                        observer.onError(e);
-                                    }
-                                }
-                                observer.onCompleted();
+                    public void call() {
+                        while (!(subscriber.isUnsubscribed() || Thread.currentThread().isInterrupted())) {
+                            subscriber.onNext(randomEvent(type, numInstances));
+                            try {
+                                // slow it down somewhat
+                                Thread.sleep(50);
+                            } catch (InterruptedException e) {
+                                subscriber.onError(e);
                             }
-
-                        });
+                        }
+                        subscriber.onCompleted();
                     }
 
                 });
diff --git a/rxjava-core/src/test/java/rx/MergeTests.java b/rxjava-core/src/test/java/rx/MergeTests.java
index 67c0daccd2..9b1020a0ac 100644
--- a/rxjava-core/src/test/java/rx/MergeTests.java
+++ b/rxjava-core/src/test/java/rx/MergeTests.java
@@ -15,7 +15,7 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import java.util.List;
 
diff --git a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
index 9e6968f652..bbbe88943e 100644
--- a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
+++ b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
@@ -15,7 +15,10 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index e4a84c15ac..616cd9383d 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -15,9 +15,19 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+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.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/ObservableWindowTests.java b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
index f6380cb92a..abcd053663 100644
--- a/rxjava-core/src/test/java/rx/ObservableWindowTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
@@ -15,7 +15,8 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/ReduceTests.java b/rxjava-core/src/test/java/rx/ReduceTests.java
index 5e79fe0a98..906591d5ef 100644
--- a/rxjava-core/src/test/java/rx/ReduceTests.java
+++ b/rxjava-core/src/test/java/rx/ReduceTests.java
@@ -15,7 +15,7 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java
index e88454b672..524c2e61fe 100644
--- a/rxjava-core/src/test/java/rx/RefCountTests.java
+++ b/rxjava-core/src/test/java/rx/RefCountTests.java
@@ -15,8 +15,8 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/StartWithTests.java b/rxjava-core/src/test/java/rx/StartWithTests.java
index 4ea4c7cde0..33f7e15d92 100644
--- a/rxjava-core/src/test/java/rx/StartWithTests.java
+++ b/rxjava-core/src/test/java/rx/StartWithTests.java
@@ -15,7 +15,7 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java b/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
index b0902f5f1b..ee0d1e7c93 100644
--- a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
+++ b/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
@@ -15,7 +15,8 @@
  */
 package rx;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
 
 import java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/ThrottleLastTests.java b/rxjava-core/src/test/java/rx/ThrottleLastTests.java
index 7c1a3c301b..73cfe27485 100644
--- a/rxjava-core/src/test/java/rx/ThrottleLastTests.java
+++ b/rxjava-core/src/test/java/rx/ThrottleLastTests.java
@@ -15,7 +15,8 @@
  */
 package rx;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
 
 import java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java b/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java
index c023d0b174..0782b4ca6b 100644
--- a/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/ThrottleWithTimeoutTests.java
@@ -15,7 +15,8 @@
  */
 package rx;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
 
 import java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/ZipTests.java b/rxjava-core/src/test/java/rx/ZipTests.java
index 8735cb2e66..37232f8461 100644
--- a/rxjava-core/src/test/java/rx/ZipTests.java
+++ b/rxjava-core/src/test/java/rx/ZipTests.java
@@ -15,7 +15,8 @@
  */
 package rx;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
 
 import java.util.Collection;
 import java.util.Collections;
diff --git a/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
index 070fa8aaab..c0fa66b537 100644
--- a/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
@@ -15,7 +15,7 @@
  */
 package rx.exceptions;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
index 50b3d8f161..c3c6ba5a67 100644
--- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
@@ -15,7 +15,8 @@
  */
 package rx.observables;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
index e3b7a6d9e5..7cd36caf71 100644
--- a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
@@ -15,9 +15,15 @@
  */
 package rx.observers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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.mockito.Matchers.any;
+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.Random;
 import java.util.concurrent.ExecutorService;
diff --git a/rxjava-core/src/test/java/rx/observers/TestObserverTest.java b/rxjava-core/src/test/java/rx/observers/TestObserverTest.java
index 67883043bd..9cfd547657 100644
--- a/rxjava-core/src/test/java/rx/observers/TestObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/TestObserverTest.java
@@ -15,8 +15,10 @@
  */
 package rx.observers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 
 import java.util.Arrays;
 
diff --git a/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java b/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java
index 1cda136fe6..c728e79cda 100644
--- a/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java
+++ b/rxjava-core/src/test/java/rx/observers/TestSubscriberTest.java
@@ -15,8 +15,10 @@
  */
 package rx.observers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 
 import java.util.Arrays;
 
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
index 9ac1a358c3..b841fab2fa 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static rx.operators.BlockingOperatorMostRecent.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static rx.operators.BlockingOperatorMostRecent.mostRecent;
 
 import java.util.Iterator;
 import java.util.concurrent.TimeUnit;
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
index 36bba0948a..28cc6bbecb 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static rx.operators.BlockingOperatorNext.*;
+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 rx.operators.BlockingOperatorNext.next;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
index d10c5269db..fce243f192 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
@@ -15,8 +15,8 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static rx.operators.BlockingOperatorToIterator.*;
+import static org.junit.Assert.assertEquals;
+import static rx.operators.BlockingOperatorToIterator.toIterator;
 
 import java.util.Iterator;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
index afa35ca0be..0da2a6f405 100644
--- a/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OnSubscribeRangeTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+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.atomic.AtomicInteger;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java b/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
index e7940a0583..c76fad7a13 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationAll.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static rx.operators.OperationAll.all;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
index eaeca1cad9..d2687a90f7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
@@ -15,8 +15,13 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationAny.*;
+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.OperationAny.any;
+import static rx.operators.OperationAny.exists;
+import static rx.operators.OperationAny.isEmpty;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
index 88f4477aaa..fb93d6c916 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
@@ -15,9 +15,20 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationAverage.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyDouble;
+import static org.mockito.Matchers.anyFloat;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.isA;
+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.OperationAverage.average;
+import static rx.operators.OperationAverage.averageDoubles;
+import static rx.operators.OperationAverage.averageFloats;
+import static rx.operators.OperationAverage.averageLongs;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index 04944498b2..2fd78e8f54 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -15,10 +15,13 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationBuffer.*;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.Matchers.any;
+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.OperationBuffer.buffer;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -33,8 +36,9 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -46,12 +50,14 @@ public class OperationBufferTest {
 
     private Observer<List<String>> observer;
     private TestScheduler scheduler;
+    private Scheduler.Inner innerScheduler;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         observer = Mockito.mock(Observer.class);
         scheduler = new TestScheduler();
+        innerScheduler = scheduler.inner();
     }
 
     @Test
@@ -347,18 +353,18 @@ private List<String> list(String... args) {
     }
 
     private <T> void push(final Observer<T> observer, final T value, int delay) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onNext(value);
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private void complete(final Observer<?> observer, int delay) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onCompleted();
             }
         }, delay, TimeUnit.MILLISECONDS);
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
index c58c05a7e2..a6fe434526 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
@@ -15,9 +15,14 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationCombineLatest.*;
+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.OperationCombineLatest.combineLatest;
 
 import java.util.Arrays;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
index 5cc1a588c1..557b0b5aff 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
@@ -15,10 +15,15 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationConcat.*;
+import static org.junit.Assert.fail;
+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.OperationConcat.concat;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
index 1f23264ae8..e4252f4b38 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
@@ -15,8 +15,13 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 java.util.concurrent.TimeUnit;
 
@@ -26,9 +31,9 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
@@ -38,12 +43,14 @@ public class OperationDebounceTest {
 
     private TestScheduler scheduler;
     private Observer<String> observer;
+    private Scheduler.Inner innerScheduler;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
         observer = mock(Observer.class);
+        innerScheduler = scheduler.inner();
     }
 
     @Test
@@ -132,27 +139,27 @@ public Subscription onSubscribe(Observer<? super String> observer) {
     }
 
     private <T> void publishCompleted(final Observer<T> observer, long delay) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onCompleted();
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private <T> void publishError(final Observer<T> observer, long delay, final Exception error) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onError(error);
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private <T> void publishNext(final Observer<T> observer, final long delay, final T value) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onNext(value);
             }
         }, delay, TimeUnit.MILLISECONDS);
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java b/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
index 50c86bde17..ecc7174d65 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationDefaultIfEmpty.*;
+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.OperationDefaultIfEmpty.defaultIfEmpty;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java b/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
index a33736acb1..d6e0f5cef0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
@@ -15,7 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
index df75fc4d25..1bc8cd0bfc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
@@ -15,9 +15,14 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static org.mockito.MockitoAnnotations.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
+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.MockitoAnnotations.initMocks;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java b/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
index 9be2508c40..b33f602dce 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
@@ -15,10 +15,14 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static org.mockito.MockitoAnnotations.*;
-import static rx.operators.OperationDistinct.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+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 static rx.operators.OperationDistinct.distinct;
 
 import java.util.Comparator;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java b/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
index dcd1176f58..cc6184001b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
@@ -15,10 +15,14 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static org.mockito.MockitoAnnotations.*;
-import static rx.operators.OperationDistinctUntilChanged.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+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 static rx.operators.OperationDistinctUntilChanged.distinctUntilChanged;
 
 import java.util.Comparator;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java b/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
index c8e1e622bf..2db5f7722f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationFinally.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static rx.operators.OperationFinally.finallyDo;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
index 84f1b6aee0..e04ce9f748 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java
@@ -15,9 +15,15 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static org.mockito.MockitoAnnotations.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+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.MockitoAnnotations.initMocks;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
index 5b199e4a6e..8eb9ec7960 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
@@ -15,8 +15,11 @@
  */
 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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.Arrays;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
index af1fc94365..1d384e7ea0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+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 java.util.Arrays;
 import java.util.HashMap;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
index 5e02219178..3085c3c633 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.Arrays;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
index 0240796f18..19224c1be7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
@@ -15,8 +15,13 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
+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.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
index 9cfc68e033..4dded27527 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationJoinTest.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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java b/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
index 85a0890b15..beeff72fe6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+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 java.util.Arrays;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
index 6cb6d44ff5..642582e939 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationLastTest.java
@@ -15,9 +15,11 @@
  */
 package rx.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.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;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
index 30ce59117a..5d18afd363 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
@@ -15,10 +15,14 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationMergeDelayError.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static rx.operators.OperationMergeDelayError.mergeDelayError;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java b/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
index 786dd6821e..c82b830603 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
@@ -15,7 +15,8 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
index cad4805c7c..0858dc4c7a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
@@ -15,9 +15,14 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationMinMax.*;
+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 java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java b/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
index bd1450f2f9..5440d1f282 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
@@ -15,7 +15,10 @@
  */
 package rx.operators;
 
-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 org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
index 1c9be8f069..193b9c9b5a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
@@ -15,10 +15,12 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationOnErrorResumeNextViaObservable.*;
+import static org.junit.Assert.fail;
+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 rx.operators.OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable;
 
 import org.junit.Test;
 import org.mockito.Mockito;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
index 356c680470..32e75a3a48 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
@@ -15,10 +15,13 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationOnErrorReturn.*;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+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 rx.operators.OperationOnErrorReturn.onErrorReturn;
 
 import java.util.concurrent.atomic.AtomicReference;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
index f2b4b6ff16..576c12d5f9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
@@ -15,10 +15,14 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationOnExceptionResumeNextViaObservable.*;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+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 rx.operators.OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable;
 
 import org.junit.Test;
 import org.mockito.Mockito;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
index 9bdac54407..06e404f8cb 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
@@ -16,8 +16,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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
index a0214fef82..10ebf8cc5f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
@@ -15,8 +15,12 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 java.util.Arrays;
 import java.util.concurrent.TimeUnit;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
index f925de54cb..492c3d14c5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
@@ -15,8 +15,12 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 java.util.concurrent.TimeUnit;
 
@@ -26,15 +30,16 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 
 public class OperationSampleTest {
     private TestScheduler scheduler;
+    private Scheduler.Inner innerScheduler;
     private Observer<Long> observer;
     private Observer<Object> observer2;
 
@@ -43,6 +48,7 @@ public class OperationSampleTest {
     // due to mocking
     public void before() {
         scheduler = new TestScheduler();
+        innerScheduler = scheduler.inner();
         observer = mock(Observer.class);
         observer2 = mock(Observer.class);
     }
@@ -52,21 +58,21 @@ public void testSample() {
         Observable<Long> source = Observable.create(new Observable.OnSubscribeFunc<Long>() {
             @Override
             public Subscription onSubscribe(final Observer<? super Long> observer1) {
-                scheduler.schedule(new Action1<Inner>() {
+                innerScheduler.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         observer1.onNext(1L);
                     }
                 }, 1, TimeUnit.SECONDS);
-                scheduler.schedule(new Action1<Inner>() {
+                innerScheduler.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         observer1.onNext(2L);
                     }
                 }, 2, TimeUnit.SECONDS);
-                scheduler.schedule(new Action1<Inner>() {
+                innerScheduler.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         observer1.onCompleted();
                     }
                 }, 3, TimeUnit.SECONDS);
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java b/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
index a3abc4c2b7..94619c028f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
index dee0f1eb88..f462b6a861 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSingleTest.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
index 59026c99df..95441419aa 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
@@ -15,9 +15,13 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationSkipLast.*;
+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 rx.operators.OperationSkipLast.skipLast;
 
 import java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
index c7dad11ce1..53cfaf63f3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java
index 6d5b187dbd..82d5030019 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
index b769f4f453..e26d3b5ee2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
@@ -15,7 +15,13 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+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 org.junit.Test;
 import org.mockito.InOrder;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
index 5553723e00..b8dc9d16bf 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
@@ -15,9 +15,19 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationSum.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyDouble;
+import static org.mockito.Matchers.anyFloat;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyLong;
+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.OperationSum.sumDoubles;
+import static rx.operators.OperationSum.sumFloats;
+import static rx.operators.OperationSum.sumIntegers;
+import static rx.operators.OperationSum.sumLongs;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
index b09d06abc2..fd2678ee5f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
@@ -15,8 +15,13 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 java.util.concurrent.TimeUnit;
 
@@ -26,21 +31,23 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
 
 public class OperationSwitchTest {
 
     private TestScheduler scheduler;
+    private Scheduler.Inner innerScheduler;
     private Observer<String> observer;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
+        innerScheduler = scheduler.inner();
         observer = mock(Observer.class);
     }
 
@@ -352,27 +359,27 @@ public Subscription onSubscribe(Observer<? super String> observer) {
     }
 
     private <T> void publishCompleted(final Observer<T> observer, long delay) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onCompleted();
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private <T> void publishError(final Observer<T> observer, long delay, final Throwable error) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onError(error);
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private <T> void publishNext(final Observer<T> observer, long delay, final T value) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onNext(value);
             }
         }, delay, TimeUnit.MILLISECONDS);
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
index 0751213269..241e319ee3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
@@ -15,9 +15,13 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationTakeLast.*;
+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 rx.operators.OperationTakeLast.takeLast;
 
 import java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
index e150dbc44b..856aef6ea3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
index df0c395d73..8c41a57c29 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
@@ -15,8 +15,10 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationTakeUntil.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static rx.operators.OperationTakeUntil.takeUntil;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
index fafb23b4ff..434b2d1ab4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
@@ -15,10 +15,14 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationTakeWhile.*;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+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.OperationTakeWhile.takeWhile;
+import static rx.operators.OperationTakeWhile.takeWhileWithIndex;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
index 6172b7dfb3..89f4eee5e7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.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.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 
 import java.util.concurrent.TimeUnit;
 
@@ -26,21 +28,23 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
 
 public class OperationThrottleFirstTest {
 
     private TestScheduler scheduler;
+    private Scheduler.Inner innerScheduler;
     private Observer<String> observer;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
+        innerScheduler = scheduler.inner();
         observer = mock(Observer.class);
     }
 
@@ -99,27 +103,27 @@ public Subscription onSubscribe(Observer<? super String> observer) {
     }
 
     private <T> void publishCompleted(final Observer<T> observer, long delay) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onCompleted();
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private <T> void publishError(final Observer<T> observer, long delay, final Exception error) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onError(error);
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private <T> void publishNext(final Observer<T> observer, long delay, final T value) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onNext(value);
             }
         }, delay, TimeUnit.MILLISECONDS);
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
index e1aabf52a6..1fc1a646f1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
@@ -15,7 +15,8 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.times;
 
 import java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java b/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
index 33c29589c9..59c3983dc5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+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 java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java b/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
index a3d13b0910..da6b316133 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToMapTest.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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
index be4a59654c..2eb608d851 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java b/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
index b79de2a69e..087fd1b6f4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
@@ -15,7 +15,11 @@
  */
 package rx.operators;
 
-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 static org.mockito.Mockito.when;
 
 import java.util.concurrent.Future;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java b/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
index 3d4f628d67..dc3b83deb0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
@@ -15,9 +15,13 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationUsing.*;
+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 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 16ac7579d3..00b72c17c7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -15,10 +15,13 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.operators.OperationWindow.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static rx.operators.OperationWindow.window;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -29,8 +32,9 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -42,10 +46,12 @@
 public class OperationWindowTest {
 
     private TestScheduler scheduler;
+    private Scheduler.Inner innerScheduler;
 
     @Before
     public void before() {
         scheduler = new TestScheduler();
+        innerScheduler = scheduler.inner();
     }
 
     private static <T> List<List<T>> toLists(Observable<Observable<T>> observables) {
@@ -80,7 +86,7 @@ public void testNonOverlappingWindows() {
     }
 
     @Test
-    public void testSkipAndCountGaplessEindows() {
+    public void testSkipAndCountGaplessWindows() {
         Observable<String> subject = Observable.from("one", "two", "three", "four", "five");
         Observable<Observable<String>> windowed = Observable.create(window(subject, 3, 3));
 
@@ -285,18 +291,18 @@ private List<String> list(String... args) {
     }
 
     private <T> void push(final Observer<T> observer, final T value, int delay) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onNext(value);
             }
         }, delay, TimeUnit.MILLISECONDS);
     }
 
     private void complete(final Observer<?> observer, int delay) {
-        scheduler.schedule(new Action1<Inner>() {
+        innerScheduler.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 observer.onCompleted();
             }
         }, delay, TimeUnit.MILLISECONDS);
diff --git a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
index 088b83e499..f776e88106 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
@@ -15,7 +15,9 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
index 323eda3ca5..f77a696af5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
@@ -30,19 +30,21 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscriber;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.CompositeSubscription;
 
 public class OperatorAmbTest {
 
     private TestScheduler scheduler;
+    private Scheduler.Inner innerScheduler;
 
     @Before
     public void setUp() {
         scheduler = new TestScheduler();
+        innerScheduler = scheduler.inner();
     }
 
     private Observable<String> createObservable(final String[] values,
@@ -55,17 +57,17 @@ public void call(final Subscriber<? super String> subscriber) {
                 subscriber.add(parentSubscription);
                 long delay = interval;
                 for (final String value : values) {
-                    parentSubscription.add(scheduler.schedule(new Action1<Inner>() {
+                    parentSubscription.add(innerScheduler.schedule(new Action0() {
                         @Override
-                        public void call(Inner inner) {
+                        public void call() {
                             subscriber.onNext(value);
                         }
                     }, delay, TimeUnit.MILLISECONDS));
                     delay += interval;
                 }
-                parentSubscription.add(scheduler.schedule(new Action1<Inner>() {
+                parentSubscription.add(innerScheduler.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         if (e == null) {
                             subscriber.onCompleted();
                         } else {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java b/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
index 3a6c170c56..43ae5fb2f9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
@@ -15,9 +15,11 @@
  */
 package rx.operators;
 
-import java.util.Arrays;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
+import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorCastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorCastTest.java
index 7ef8c90408..9753243274 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorCastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorCastTest.java
@@ -15,7 +15,10 @@
  */
 package rx.operators;
 
-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 org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.java
index 95dfee2ddd..dd4f66fbec 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDoOnEachTest.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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
index 4950520a94..c09ee47004 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorFilterTest.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 org.junit.Test;
 import org.mockito.Mockito;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFromIterableTest.java
index b3c081a25c..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;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
index fd091bdaef..926321310e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.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.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
index ffcfca150e..5be5dcbccc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
@@ -15,8 +15,9 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static rx.operators.OperatorMaterialize.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import java.util.List;
 import java.util.Vector;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index 934513d0db..782f79474a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -485,10 +485,12 @@ public void testConcurrency() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Schedulers.newThread().schedule(new Action1<Inner>() {
+                Inner inner = Schedulers.newThread().inner();
+                s.add(inner);
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         for (int i = 0; i < 10000; i++) {
                             s.onNext(1);
                         }
@@ -519,10 +521,12 @@ public void testConcurrencyWithSleeping() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Schedulers.newThread().schedule(new Action1<Inner>() {
+                Inner inner = Schedulers.newThread().inner();
+                s.add(inner);
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         for (int i = 0; i < 100; i++) {
                             s.onNext(1);
                             try {
@@ -558,10 +562,12 @@ public void testConcurrencyWithBrokenOnCompleteContract() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Schedulers.newThread().schedule(new Action1<Inner>() {
+                Inner inner = Schedulers.newThread().inner();
+                s.add(inner);
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         for (int i = 0; i < 10000; i++) {
                             s.onNext(1);
                         }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java
deleted file mode 100644
index 45bf287dab..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnBoundedTest.java
+++ /dev/null
@@ -1,461 +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.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.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;
-
-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<Integer> observer = mock(Observer.class);
-        Observable.from(1, 2, 3).lift(new OperatorObserveOnBounded<Integer>(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<String> obs = Observable.from("one", null, "two", "three", "four");
-
-        Observer<String> observer = mock(Observer.class);
-
-        InOrder inOrder = inOrder(observer);
-
-        final CountDownLatch completedLatch = new CountDownLatch(1);
-        doAnswer(new Answer<Void>() {
-
-            @Override
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                completedLatch.countDown();
-                return null;
-            }
-        }).when(observer).onCompleted();
-
-        obs.lift(new OperatorObserveOnBounded<String>(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<String> obs = Observable.from("one", null, "two", "three", "four");
-
-        Observer<String> 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<String>() {
-
-            @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<String>(Schedulers.newThread(), 1)).doOnNext(new Action1<String>() {
-
-            @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<Integer> o = Observable.from(1, 2, 3);
-        Observable<Integer> o2 = o.lift(new OperatorObserveOnBounded<Integer>(scheduler, 1));
-
-        @SuppressWarnings("unchecked")
-        Observer<Object> observer1 = mock(Observer.class);
-        @SuppressWarnings("unchecked")
-        Observer<Object> 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<Integer> o = Observable.from(1, 2, 3);
-        Observable<Integer> o1 = o.lift(new OperatorObserveOnBounded<Integer>(scheduler1, 1));
-        Observable<Integer> o2 = o.lift(new OperatorObserveOnBounded<Integer>(scheduler2, 1));
-
-        @SuppressWarnings("unchecked")
-        Observer<Object> observer1 = mock(Observer.class);
-        @SuppressWarnings("unchecked")
-        Observer<Object> 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<Integer, Integer>() {
-
-            @Override
-            public Integer call(Integer t1) {
-                return t1 * _multiple;
-            }
-
-        }).lift(new OperatorObserveOnBounded<Integer>(Schedulers.newThread(), 1))
-                .toBlockingObservable().forEach(new Action1<Integer>() {
-
-                    @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<Integer, Integer>() {
-
-            @Override
-            public Integer call(Integer t1) {
-                return t1 * _multiple;
-            }
-
-        }).lift(new OperatorObserveOnBounded<Integer>(Schedulers.computation(), 1))
-                .toBlockingObservable().forEach(new Action1<Integer>() {
-
-                    @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<Integer, Integer>() {
-
-            @Override
-            public Integer call(Integer t1) {
-                if (randomIntFrom0to100() > 98) {
-                    try {
-                        Thread.sleep(2);
-                    } catch (InterruptedException e) {
-                        e.printStackTrace();
-                    }
-                }
-                return t1 * _multiple;
-            }
-
-        }).lift(new OperatorObserveOnBounded<Integer>(Schedulers.computation(), 1))
-                .toBlockingObservable().forEach(new Action1<Integer>() {
-
-                    @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<Integer>(Schedulers.newThread(), 1)).subscribe(new Observer<Integer>() {
-
-            @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<Integer>() {
-
-            @Override
-            public Subscription onSubscribe(final Observer<? super Integer> 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<Integer>() {
-
-            @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<Integer>(scheduler, bufferSize)).doOnNext(new Action1<Integer>() {
-
-            @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<Integer>() {
-
-            @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 037060298b..b556653b5a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -15,9 +15,16 @@
  */
 package rx.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.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+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.times;
+import static org.mockito.Mockito.verify;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java
index 5fc9b62866..38f6523e5e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorFlatMapTest.java
@@ -15,7 +15,7 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.Arrays;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index 7c7d7207e9..a7533d3d69 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -15,9 +15,12 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+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;
 import java.util.concurrent.atomic.AtomicReference;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
index 37c0578e19..b0b3ebd712 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
@@ -15,7 +15,7 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
index ba668c125a..7c35bd27fe 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
@@ -15,9 +15,13 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+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.atomic.AtomicInteger;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
index 535478f080..3f6efc4a72 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorScanTest.java
@@ -15,8 +15,13 @@
  */
 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.anyString;
+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 org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
index 6e396b2139..0f54774f9c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
@@ -15,9 +15,14 @@
  */
 package rx.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.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+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.Random;
 import java.util.concurrent.ExecutorService;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
index f0a9706786..d2889c5d39 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
@@ -1,11 +1,16 @@
 package rx.operators;
 
+import static org.mockito.Matchers.any;
+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 org.junit.Test;
+
 import rx.Observable;
 import rx.Observer;
 
-import static org.mockito.Mockito.*;
-
 public class OperatorSkipTest {
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index ba9d171ccc..65d95c4a25 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -15,7 +15,7 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
@@ -29,7 +29,7 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.observers.TestObserver;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
@@ -94,16 +94,42 @@ public SlowScheduler(Scheduler actual, long delay, TimeUnit unit) {
         }
 
         @Override
-        public Subscription schedule(final Action1<Scheduler.Inner> action) {
-            return actual.schedule(action, delay, unit);
+        public Inner inner() {
+            return new SlowInner(actual.inner());
         }
 
-        @Override
-        public Subscription schedule(final Action1<Scheduler.Inner> 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);
+        private class SlowInner extends Inner {
+
+            private final Scheduler.Inner actualInner;
+
+            private SlowInner(Inner actual) {
+                this.actualInner = actual;
+            }
+
+            @Override
+            public void unsubscribe() {
+                actualInner.unsubscribe();
+            }
+
+            @Override
+            public boolean isUnsubscribed() {
+                return actualInner.isUnsubscribed();
+            }
+
+            @Override
+            public Subscription schedule(final Action0 action) {
+                return actualInner.schedule(action, delay, unit);
+            }
+
+            @Override
+            public Subscription schedule(final Action0 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 actualInner.schedule(action, t, common);
+            }
+
         }
+
     }
 
     @Test(timeout = 5000)
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java
index 9ec9396f5b..a134bb3c9d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java
@@ -15,9 +15,14 @@
  */
 package rx.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.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+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.Random;
 import java.util.concurrent.ExecutorService;
@@ -36,7 +41,6 @@
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.observers.TestSubscriber;
 
 public class OperatorSynchronizeTest {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
index 7df0ae3b32..7a77dded65 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
@@ -15,9 +15,17 @@
  */
 package rx.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.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+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 org.mockito.Mockito.verifyNoMoreInteractions;
 
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicBoolean;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
index 6702024636..11ae3bd37e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutTests.java
@@ -15,8 +15,13 @@
  */
 package rx.operators;
 
-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.io.IOException;
 import java.util.concurrent.CountDownLatch;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 0d1421115c..1776c00434 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -15,9 +15,14 @@
  */
 package rx.operators;
 
-import static org.junit.Assert.*;
-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;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java
index a4225cee0a..6421579bb3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimestampTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+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 java.util.concurrent.TimeUnit;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorToObservableListTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToObservableListTest.java
index 980800a193..7c90822378 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorToObservableListTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToObservableListTest.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;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.java
index dae17cf4a1..4cbc3951a3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToObservableSortedListTest.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;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
index b86a015b2c..59e26e4b46 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
@@ -1,6 +1,8 @@
 package rx.operators;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
@@ -15,7 +17,6 @@
 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;
@@ -143,17 +144,19 @@ public static class UIEventLoopScheduler extends Scheduler {
         private volatile Thread t;
 
         public UIEventLoopScheduler() {
+
+            eventLoop = Schedulers.newThread().inner();
+            s = eventLoop;
+
             /*
              * DON'T DO THIS IN PRODUCTION CODE
              */
-            final AtomicReference<Scheduler.Inner> innerScheduler = new AtomicReference<Scheduler.Inner>();
             final CountDownLatch latch = new CountDownLatch(1);
-            s = Schedulers.newThread().schedule(new Action1<Inner>() {
+            eventLoop.schedule(new Action0() {
 
                 @Override
-                public void call(Inner inner) {
+                public void call() {
                     t = Thread.currentThread();
-                    innerScheduler.set(inner);
                     latch.countDown();
                 }
 
@@ -161,21 +164,13 @@ public void call(Inner inner) {
             try {
                 latch.await();
             } catch (InterruptedException e) {
-                throw new RuntimeException("failed to initialize and get inner scheduler");
+                throw new RuntimeException("failed to initialize and get inner thread");
             }
-            eventLoop = innerScheduler.get();
-        }
-
-        @Override
-        public Subscription schedule(Action1<Inner> action) {
-            eventLoop.schedule(action);
-            return Subscriptions.empty();
         }
-
+        
         @Override
-        public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-            eventLoop.schedule(action);
-            return Subscriptions.empty();
+        public Inner inner() {
+            return eventLoop;
         }
 
         public void shutdown() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
index 543cf531cc..37e8f7c6c1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
@@ -15,8 +15,11 @@
  */
 package rx.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 java.util.Arrays;
 import java.util.Iterator;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
index 7862c9f49a..1bcbef66f8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -15,9 +15,14 @@
  */
 package rx.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.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 java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java b/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
index c0a0f87669..86f9893962 100644
--- a/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
@@ -15,7 +15,9 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java b/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
index 7f23a8379a..dde3f93b99 100644
--- a/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
+++ b/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.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 org.junit.Test;
 import org.mockito.Mockito;
diff --git a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
index 5a9a070680..ecf2aacfdc 100644
--- a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -15,7 +15,9 @@
  */
 package rx.plugins;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import org.junit.After;
 import org.junit.Before;
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 39cac1740b..9f08b3f439 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -15,7 +15,10 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.*;
+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 java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -25,8 +28,7 @@
 import org.junit.Test;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
+import rx.Observable.OnSubscribe;
 import rx.Scheduler;
 import rx.Scheduler.Inner;
 import rx.Subscriber;
@@ -98,16 +100,18 @@ public void testUnsubscribeRecursiveScheduleFromOutside() throws InterruptedExce
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        Subscription s = getScheduler().schedule(new Action1<Inner>() {
+        final Inner inner = getScheduler().inner();
+
+        inner.schedule(new Action0() {
 
             @Override
-            public void call(final Inner inner) {
-                inner.schedule(new Action1<Inner>() {
+            public void call() {
+                inner.schedule(new Action0() {
 
                     int i = 0;
 
                     @Override
-                    public void call(Inner s) {
+                    public void call() {
                         System.out.println("Run: " + i++);
                         if (i == 10) {
                             latch.countDown();
@@ -131,7 +135,7 @@ public void call(Inner s) {
         });
 
         latch.await();
-        s.unsubscribe();
+        inner.unsubscribe();
         unsubscribeLatch.countDown();
         Thread.sleep(200); // let time pass to see if the scheduler is still doing work
         assertEquals(10, counter.get());
@@ -141,16 +145,17 @@ public void call(Inner s) {
     public void testUnsubscribeRecursiveScheduleFromInside() throws InterruptedException {
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        getScheduler().schedule(new Action1<Inner>() {
+        final Inner inner = getScheduler().inner();
+        inner.schedule(new Action0() {
 
             @Override
-            public void call(Inner inner) {
-                inner.schedule(new Action1<Inner>() {
+            public void call() {
+                inner.schedule(new Action0() {
 
                     int i = 0;
 
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         System.out.println("Run: " + i++);
                         if (i == 10) {
                             inner.unsubscribe();
@@ -174,16 +179,17 @@ public void testUnsubscribeRecursiveScheduleWithDelay() throws InterruptedExcept
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        Subscription s = getScheduler().schedule(new Action1<Inner>() {
+        final Inner inner = getScheduler().inner();
+        inner.schedule(new Action0() {
 
             @Override
-            public void call(final Inner innerScheduler) {
-                innerScheduler.schedule(new Action1<Inner>() {
+            public void call() {
+                inner.schedule(new Action0() {
 
                     long i = 1L;
 
                     @Override
-                    public void call(Inner s) {
+                    public void call() {
                         if (i++ == 10) {
                             latch.countDown();
                             try {
@@ -198,14 +204,14 @@ public void call(Inner s) {
                         }
 
                         counter.incrementAndGet();
-                        innerScheduler.schedule(this, 10, TimeUnit.MILLISECONDS);
+                        inner.schedule(this, 10, TimeUnit.MILLISECONDS);
                     }
                 }, 10, TimeUnit.MILLISECONDS);
             }
         });
 
         latch.await();
-        s.unsubscribe();
+        inner.unsubscribe();
         unsubscribeLatch.countDown();
         Thread.sleep(200); // let time pass to see if the scheduler is still doing work
         assertEquals(10, counter.get());
@@ -214,12 +220,13 @@ public void call(Inner s) {
     @Test
     public void recursionFromOuterActionAndUnsubscribeInside() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        getScheduler().schedule(new Action1<Inner>() {
+        final Inner inner = getScheduler().inner();
+        inner.schedule(new Action0() {
 
             int i = 0;
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 i++;
                 if (i % 100000 == 0) {
                     System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
@@ -238,12 +245,13 @@ public void call(Inner inner) {
     @Test
     public void testRecursion() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        getScheduler().schedule(new Action1<Inner>() {
+        final Inner inner = getScheduler().inner();
+        inner.schedule(new Action0() {
 
             private long i = 0;
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 i++;
                 if (i % 100000 == 0) {
                     System.out.println(i + "  Total Memory: " + Runtime.getRuntime().totalMemory() + "  Free: " + Runtime.getRuntime().freeMemory());
@@ -265,13 +273,13 @@ public void testRecursionAndOuterUnsubscribe() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(10);
         final CountDownLatch completionLatch = new CountDownLatch(1);
 
-        Observable<Integer> obs = Observable.create(new OnSubscribeFunc<Integer>() {
+        Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
             @Override
-            public Subscription onSubscribe(final Observer<? super Integer> observer) {
-
-                final Subscription s = getScheduler().schedule(new Action1<Inner>() {
+            public void call(final Subscriber<? super Integer> observer) {
+                final Inner inner = getScheduler().inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         observer.onNext(42);
                         latch.countDown();
 
@@ -280,16 +288,16 @@ public void call(Inner inner) {
                     }
                 });
 
-                return Subscriptions.create(new Action0() {
+                observer.add(Subscriptions.create(new Action0() {
 
                     @Override
                     public void call() {
-                        s.unsubscribe();
+                        inner.unsubscribe();
                         observer.onCompleted();
                         completionLatch.countDown();
                     }
 
-                });
+                }));
 
             }
         });
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 0947bcd884..53f5900ed4 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -15,9 +15,14 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doAnswer;
+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 java.util.Arrays;
 import java.util.List;
@@ -32,10 +37,10 @@
 import org.mockito.stubbing.Answer;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -56,6 +61,7 @@ public abstract class AbstractSchedulerTests {
     @Test
     public void testNestedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
+        final Scheduler.Inner inner = scheduler.inner();
         final CountDownLatch latch = new CountDownLatch(1);
 
         final Action0 firstStepStart = mock(Action0.class);
@@ -67,26 +73,26 @@ public void testNestedActions() throws InterruptedException {
         final Action0 thirdStepStart = mock(Action0.class);
         final Action0 thirdStepEnd = mock(Action0.class);
 
-        final Action1<Inner> firstAction = new Action1<Inner>() {
+        final Action0 firstAction = new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 firstStepStart.call();
                 firstStepEnd.call();
                 latch.countDown();
             }
         };
-        final Action1<Inner> secondAction = new Action1<Inner>() {
+        final Action0 secondAction = new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 secondStepStart.call();
                 inner.schedule(firstAction);
                 secondStepEnd.call();
 
             }
         };
-        final Action1<Inner> thirdAction = new Action1<Inner>() {
+        final Action0 thirdAction = new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 thirdStepStart.call();
                 inner.schedule(secondAction);
                 thirdStepEnd.call();
@@ -95,7 +101,7 @@ public void call(Inner inner) {
 
         InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
 
-        scheduler.schedule(thirdAction);
+        inner.schedule(thirdAction);
 
         latch.await();
 
@@ -147,10 +153,11 @@ public String call(String s) {
     @Test
     public final void testSequenceOfActions() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
-
+        final Scheduler.Inner inner = scheduler.inner();
+        
         final CountDownLatch latch = new CountDownLatch(2);
-        final Action1<Inner> first = mock(Action1.class);
-        final Action1<Inner> second = mock(Action1.class);
+        final Action0 first = mock(Action0.class);
+        final Action0 second = mock(Action0.class);
 
         // make it wait until both the first and second are called
         doAnswer(new Answer() {
@@ -163,7 +170,7 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
                     latch.countDown();
                 }
             }
-        }).when(first).call(any(Inner.class));
+        }).when(first).call();
         doAnswer(new Answer() {
 
             @Override
@@ -174,35 +181,36 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
                     latch.countDown();
                 }
             }
-        }).when(second).call(any(Inner.class));
+        }).when(second).call();
 
-        scheduler.schedule(first);
-        scheduler.schedule(second);
+        inner.schedule(first);
+        inner.schedule(second);
 
         latch.await();
 
-        verify(first, times(1)).call(any(Inner.class));
-        verify(second, times(1)).call(any(Inner.class));
+        verify(first, times(1)).call();
+        verify(second, times(1)).call();
 
     }
 
     @Test
     public void testSequenceOfDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-
+        final Scheduler.Inner inner = scheduler.inner();
+        
         final CountDownLatch latch = new CountDownLatch(1);
-        final Action1<Inner> first = mock(Action1.class);
-        final Action1<Inner> second = mock(Action1.class);
+        final Action0 first = mock(Action0.class);
+        final Action0 second = mock(Action0.class);
 
-        scheduler.schedule(new Action1<Inner>() {
+        inner.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 inner.schedule(first, 30, TimeUnit.MILLISECONDS);
                 inner.schedule(second, 10, TimeUnit.MILLISECONDS);
-                inner.schedule(new Action1<Inner>() {
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         latch.countDown();
                     }
                 }, 40, TimeUnit.MILLISECONDS);
@@ -212,32 +220,33 @@ public void call(Inner inner) {
         latch.await();
         InOrder inOrder = inOrder(first, second);
 
-        inOrder.verify(second, times(1)).call(any(Inner.class));
-        inOrder.verify(first, times(1)).call(any(Inner.class));
+        inOrder.verify(second, times(1)).call();
+        inOrder.verify(first, times(1)).call();
 
     }
 
     @Test
     public void testMixOfDelayedAndNonDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-
+        final Scheduler.Inner inner = scheduler.inner();
+        
         final CountDownLatch latch = new CountDownLatch(1);
-        final Action1<Inner> first = mock(Action1.class);
-        final Action1<Inner> second = mock(Action1.class);
-        final Action1<Inner> third = mock(Action1.class);
-        final Action1<Inner> fourth = mock(Action1.class);
+        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 Action1<Inner>() {
+        inner.schedule(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 inner.schedule(first);
                 inner.schedule(second, 300, TimeUnit.MILLISECONDS);
                 inner.schedule(third, 100, TimeUnit.MILLISECONDS);
                 inner.schedule(fourth);
-                inner.schedule(new Action1<Inner>() {
+                inner.schedule(new Action0() {
 
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         latch.countDown();
                     }
                 }, 400, TimeUnit.MILLISECONDS);
@@ -247,21 +256,22 @@ public void call(Inner inner) {
         latch.await();
         InOrder inOrder = inOrder(first, second, third, fourth);
 
-        inOrder.verify(first, times(1)).call(any(Inner.class));
-        inOrder.verify(fourth, times(1)).call(any(Inner.class));
-        inOrder.verify(third, times(1)).call(any(Inner.class));
-        inOrder.verify(second, times(1)).call(any(Inner.class));
+        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 testRecursiveExecution() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
+        final Scheduler.Inner inner = scheduler.inner();
         final AtomicInteger i = new AtomicInteger();
         final CountDownLatch latch = new CountDownLatch(1);
-        scheduler.schedule(new Action1<Inner>() {
+        inner.schedule(new Action0() {
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 if (i.incrementAndGet() < 100) {
                     inner.schedule(this);
                 } else {
@@ -277,15 +287,16 @@ public void call(Inner inner) {
     @Test
     public final void testRecursiveExecutionWithDelayTime() throws InterruptedException {
         Scheduler scheduler = getScheduler();
+        final Scheduler.Inner inner = scheduler.inner();
         final AtomicInteger i = new AtomicInteger();
         final CountDownLatch latch = new CountDownLatch(1);
 
-        scheduler.schedule(new Action1<Inner>() {
+        inner.schedule(new Action0() {
 
             int state = 0;
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 i.set(state);
                 if (state++ < 100) {
                     inner.schedule(this, 1, TimeUnit.MILLISECONDS);
@@ -302,14 +313,16 @@ public void call(Inner inner) {
 
     @Test
     public final void testRecursiveSchedulerInObservable() {
-        Observable<Integer> obs = Observable.create(new OnSubscribeFunc<Integer>() {
+        Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
             @Override
-            public Subscription onSubscribe(final Observer<? super Integer> observer) {
-                return getScheduler().schedule(new Action1<Inner>() {
+            public void call(final Subscriber<? super Integer> observer) {
+                final Scheduler.Inner inner = getScheduler().inner();
+                observer.add(inner);
+                inner.schedule(new Action0() {
                     int i = 0;
 
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         if (i > 42) {
                             observer.onCompleted();
                             return;
diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
index bb217ad2ca..2f2bd9214a 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
@@ -15,7 +15,9 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import java.util.HashMap;
 import java.util.concurrent.CountDownLatch;
@@ -24,7 +26,7 @@
 
 import rx.Observable;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
 
@@ -43,13 +45,15 @@ public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() {
         final CountDownLatch latch = new CountDownLatch(1);
         final HashMap<String, Integer> map = new HashMap<String, Integer>();
         
-        Schedulers.computation().schedule(new Action1<Inner>() {
+        final Scheduler.Inner inner = Schedulers.computation().inner();
+        
+        inner.schedule(new Action0() {
 
             private HashMap<String, Integer> statefulMap = map;
             int nonThreadSafeCounter = 0;
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 Integer i = statefulMap.get("a");
                 if (i == null) {
                     i = 1;
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index 9f729ea0d3..622f190798 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -15,7 +15,7 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
index 09adaa7e28..8bc5297aa1 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -15,9 +15,12 @@
  */
 package rx.schedulers;
 
-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.anyLong;
+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.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -26,9 +29,9 @@
 import org.mockito.InOrder;
 import org.mockito.Mockito;
 
-import rx.Scheduler.Inner;
+import rx.Scheduler;
 import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 import rx.functions.Func1;
 
 public class TestSchedulerTest {
@@ -40,9 +43,11 @@ public final void testPeriodicScheduling() {
         final Func1<Long, Void> calledOp = mock(Func1.class);
 
         final TestScheduler scheduler = new TestScheduler();
-        Subscription subscription = scheduler.schedulePeriodically(new Action1<Inner>() {
+        final Scheduler.Inner inner = scheduler.inner();
+        
+        inner.schedulePeriodically(new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 System.out.println(scheduler.now());
                 calledOp.call(scheduler.now());
             }
@@ -68,7 +73,7 @@ public void call(Inner inner) {
         inOrder.verify(calledOp, times(1)).call(5000L);
         inOrder.verify(calledOp, times(1)).call(7000L);
 
-        subscription.unsubscribe();
+        inner.unsubscribe();
         scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
         inOrder.verify(calledOp, never()).call(anyLong());
     }
@@ -76,20 +81,20 @@ public void call(Inner inner) {
     @Test
     public final void testImmediateUnsubscribes() {
         TestScheduler s = new TestScheduler();
-
+        final Scheduler.Inner inner = s.inner();
         final AtomicInteger counter = new AtomicInteger(0);
-
-        Subscription subscription = s.schedule(new Action1<Inner>() {
+        
+        inner.schedule(new Action0() {
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 counter.incrementAndGet();
                 System.out.println("counter: " + counter.get());
                 inner.schedule(this);
             }
 
         });
-        subscription.unsubscribe();
+        inner.unsubscribe();
         assertEquals(0, counter.get());
     }
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
index efea8d874e..e936e8caef 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
@@ -15,7 +15,7 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
index 90eda0ad16..b6e5606dd7 100644
--- a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
@@ -15,9 +15,14 @@
  */
 package rx.subjects;
 
-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.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 java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index c3e6974f71..e4ec1e9fef 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -15,14 +15,18 @@
  */
 package rx.subjects;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+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 org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
-import rx.Observable;
 
+import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.util.functions.Func1;
diff --git a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
index a5bd5d7579..cbd7b8b90f 100644
--- a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -15,8 +15,13 @@
  */
 package rx.subjects;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+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 java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 3f032b19d0..ced51e9608 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -15,7 +15,7 @@
  */
 package rx.subjects;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import java.util.ArrayList;
 import java.util.Collections;
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index 9cb0e81cfd..e0726b33e6 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -15,8 +15,14 @@
  */
 package rx.subjects;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+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.Mockito.verifyNoMoreInteractions;
 
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
@@ -24,8 +30,8 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
-import rx.Observable;
 
+import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index d61929096c..2e44a69d30 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -15,7 +15,10 @@
  */
 package rx.subscriptions;
 
-import static org.junit.Assert.*;
+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 java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
index f7b8e0b7c3..d9563b001f 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/MultipleAssignmentSubscriptionTest.java
@@ -15,8 +15,11 @@
  */
 package rx.subscriptions;
 
-import static org.mockito.Mockito.*;
-import static rx.subscriptions.Subscriptions.*;
+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.subscriptions.Subscriptions.create;
 import junit.framework.Assert;
 
 import org.junit.Before;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
index 1d0e36d424..ce62f29e96 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/RefCountSubscriptionTest.java
@@ -15,8 +15,11 @@
  */
 package rx.subscriptions;
 
-import static org.mockito.Mockito.*;
-import static rx.subscriptions.Subscriptions.*;
+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 rx.subscriptions.Subscriptions.create;
 
 import org.junit.Before;
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
index 084323a19c..8c4482ce54 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/SerialSubscriptionTests.java
@@ -15,8 +15,12 @@
  */
 package rx.subscriptions;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+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 java.util.ArrayList;
 import java.util.List;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java b/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
index adf9ee4477..767985ddfe 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/SubscriptionsTest.java
@@ -15,8 +15,10 @@
  */
 package rx.subscriptions;
 
-import static org.mockito.Mockito.*;
-import static rx.subscriptions.Subscriptions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static rx.subscriptions.Subscriptions.create;
 
 import org.junit.Test;
 
diff --git a/rxjava-core/src/test/java/rx/test/OperatorTester.java b/rxjava-core/src/test/java/rx/test/OperatorTester.java
index b6239130e9..d5d556f851 100644
--- a/rxjava-core/src/test/java/rx/test/OperatorTester.java
+++ b/rxjava-core/src/test/java/rx/test/OperatorTester.java
@@ -15,11 +15,7 @@
  */
 package rx.test;
 
-import java.util.concurrent.TimeUnit;
-
 import rx.Scheduler;
-import rx.Subscription;
-import rx.functions.Action1;
 
 /**
  * Common utility functions for testing operator implementations.
@@ -56,13 +52,8 @@ public ForwardingScheduler(Scheduler underlying) {
         }
 
         @Override
-        public Subscription schedule(Action1<Inner> action) {
-            return underlying.schedule(action);
-        }
-
-        @Override
-        public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-            return underlying.schedule(action, delayTime, unit);
+        public Inner inner() {
+            return underlying.inner();
         }
 
     }

From 5604c180f173603a8385b130a2b5e5b60e00439c Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 17 Apr 2014 22:17:31 -0700
Subject: [PATCH 228/422] Scheduler.inner() for Language and Contrib Modules

---
 .../main/scala/rx/lang/scala/Scheduler.scala  |  50 ++------
 .../schedulers/HandlerThreadScheduler.java    |  68 ++++-------
 .../subscriptions/AndroidSubscriptions.java   |   6 +-
 .../HandlerThreadSchedulerTest.java           |  15 ++-
 .../src/main/java/rx/util/async/Async.java    | 113 ++++++++++++------
 .../rx/util/async/operators/Functionals.java  |  18 ++-
 .../rx/operators/OperationConditionals.java   |  83 +++++++++----
 .../operators/OperationConditionalsTest.java  |   5 +-
 .../java/rx/quasar/NewFiberScheduler.java     |  49 +++++---
 .../java/rx/schedulers/SwingScheduler.java    |  81 +++++--------
 .../rx/subscriptions/SwingSubscriptions.java  |   9 +-
 .../rx/swing/sources/SwingTestHelper.java     |  10 +-
 .../rx/schedulers/SwingSchedulerTest.java     |  93 +++++++-------
 13 files changed, 312 insertions(+), 288 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 1bfbb69c4e..3316b8adc9 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.functions.Action1
+import rx.functions.Action0
 import rx.lang.scala.schedulers._
 import scala.concurrent.duration
 import rx.lang.scala.JavaConversions._
@@ -42,42 +42,8 @@ trait Scheduler {
    */
   def now: Long = this.asJavaScheduler.now()
 
-  /**
-   * Schedules a cancelable action to be executed.
-   *
-   * @param action Action to schedule.
-   * @return a subscription to be able to unsubscribe from action.
-   */
-  def schedule(action: Inner => Unit): Subscription = this.asJavaScheduler.schedule(action)
+  def inner: Inner = this.asJavaScheduler.inner()
 
-  /**
-   * 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 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
-     )
-
-  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) }
-    }))
-  }
 }
 
 object Inner {
@@ -90,10 +56,10 @@ trait Inner extends Subscription {
   /**
    * Schedules a cancelable action to be executed in delayTime.
    */
-  def schedule(action: Inner => Unit, delayTime: Duration): Unit =
+  def schedule(action: Unit => Unit, delayTime: Duration): Subscription =
     this.asJavaInner.schedule(
-      new Action1[rx.Scheduler.Inner] {
-        override def call(inner: rx.Scheduler.Inner): Unit = action(javaInnerToScalaInner(inner))
+      new Action0 {
+        override def call(): Unit = action()
       },
       delayTime.length,
       delayTime.unit)
@@ -101,9 +67,9 @@ trait Inner extends Subscription {
   /**
    * Schedules a cancelable action to be executed immediately.
    */
-  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))
+  def schedule(action: Unit => Unit): Subscription = this.asJavaInner.schedule(
+    new Action0 {
+      override def call(): Unit = action()
     }
   )
 
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 9bfa548880..93822f6395 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,10 @@
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.Subscriptions;
 import android.os.Handler;
 
 /**
@@ -40,43 +42,15 @@ public HandlerThreadScheduler(Handler handler) {
         this.handler = handler;
     }
 
-    /**
-     * Calls {@link HandlerThreadScheduler#schedule(Object, rx.functions.Func2, long, java.util.concurrent.TimeUnit)} with a delay of zero milliseconds.
-     * 
-     * See {@link #schedule(Object, rx.functions.Func2, long, java.util.concurrent.TimeUnit)}
-     */
-    @Override
-    public Subscription schedule(Action1<Inner> action) {
-        InnerHandlerThreadScheduler inner = new InnerHandlerThreadScheduler(handler);
-        inner.schedule(action);
-        return inner;
-    }
-
-    /**
-     * 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(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        InnerHandlerThreadScheduler inner = new InnerHandlerThreadScheduler(handler);
-        inner.schedule(action, delayTime, unit);
-        return inner;
+    public Inner inner() {
+        return new InnerHandlerThreadScheduler(handler);
     }
-
+    
     private static class InnerHandlerThreadScheduler extends Inner {
 
         private final Handler handler;
         private BooleanSubscription innerSubscription = new BooleanSubscription();
-        private Inner _inner = this;
 
         public InnerHandlerThreadScheduler(Handler handler) {
             this.handler = handler;
@@ -93,31 +67,31 @@ public boolean isUnsubscribed() {
         }
 
         @Override
-        public void schedule(final Action1<Inner> action, long delayTime, TimeUnit unit) {
-            handler.postDelayed(new Runnable() {
+        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
+            final Runnable runnable = new Runnable() {
                 @Override
                 public void run() {
-                    if (_inner.isUnsubscribed()) {
+                    if (isUnsubscribed()) {
                         return;
                     }
-                    action.call(_inner);
+                    action.call();
                 }
-            }, unit.toMillis(delayTime));
-        }
-
-        @Override
-        public void schedule(final Action1<Inner> action) {
-            handler.postDelayed(new Runnable() {
+            };
+            handler.postDelayed(runnable, unit.toMillis(delayTime));
+            return Subscriptions.create(new Action0() {
 
                 @Override
-                public void run() {
-                    if (_inner.isUnsubscribed()) {
-                        return;
-                    }
-                    action.call(_inner);
+                public void call() {
+                    handler.removeCallbacks(runnable);
+                    
                 }
+                
+            });
+        }
 
-            }, 0L);
+        @Override
+        public Subscription schedule(final Action0 action) {
+            return schedule(action, 0, TimeUnit.MILLISECONDS);
         }
 
     }
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
index 8e2f54ab3e..cc365b3f46 100644
--- 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
@@ -42,10 +42,12 @@ public void call() {
                 if (Looper.getMainLooper() == Looper.myLooper()) {
                     unsubscribe.call();
                 } else {
-                    AndroidSchedulers.mainThread().schedule(new Action1<Inner>() {
+                    final Inner inner = AndroidSchedulers.mainThread().inner();
+                    inner.schedule(new Action0() {
                         @Override
-                        public void call(Inner inner) {
+                        public void call() {
                             unsubscribe.call();
+                            inner.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
index d68bd258f0..98ec8838e4 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
@@ -30,6 +30,7 @@
 
 import rx.Scheduler;
 import rx.Scheduler.Inner;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import android.os.Handler;
 
@@ -41,10 +42,11 @@ public class HandlerThreadSchedulerTest {
     public void shouldScheduleImmediateActionOnHandlerThread() {
         final Handler handler = mock(Handler.class);
         @SuppressWarnings("unchecked")
-        final Action1<Inner> action = mock(Action1.class);
+        final Action0 action = mock(Action0.class);
 
         Scheduler scheduler = new HandlerThreadScheduler(handler);
-        scheduler.schedule(action);
+        Inner inner = scheduler.inner();
+        inner.schedule(action);
 
         // verify that we post to the given Handler
         ArgumentCaptor<Runnable> runnable = ArgumentCaptor.forClass(Runnable.class);
@@ -52,17 +54,18 @@ public void shouldScheduleImmediateActionOnHandlerThread() {
 
         // verify that the given handler delegates to our action
         runnable.getValue().run();
-        verify(action).call(any(Inner.class));
+        verify(action).call();
     }
 
     @Test
     public void shouldScheduleDelayedActionOnHandlerThread() {
         final Handler handler = mock(Handler.class);
         @SuppressWarnings("unchecked")
-        final Action1<Inner> action = mock(Action1.class);
+        final Action0 action = mock(Action0.class);
 
         Scheduler scheduler = new HandlerThreadScheduler(handler);
-        scheduler.schedule(action, 1L, TimeUnit.SECONDS);
+        Inner inner = scheduler.inner();
+        inner.schedule(action, 1L, TimeUnit.SECONDS);
 
         // verify that we post to the given Handler
         ArgumentCaptor<Runnable> runnable = ArgumentCaptor.forClass(Runnable.class);
@@ -70,6 +73,6 @@ public void shouldScheduleDelayedActionOnHandlerThread() {
 
         // verify that the given handler delegates to our action
         runnable.getValue().run();
-        verify(action).call(any(Inner.class));
+        verify(action).call();
     }
 }
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 d4ca377a04..782ff69abb 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
@@ -599,15 +599,18 @@ public static <R> Func0<Observable<R>> toAsync(final Func0<? extends R> func, fi
             @Override
             public Observable<R> call() {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call();
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -656,15 +659,18 @@ public static <T1, R> Func1<T1, Observable<R>> toAsync(final Func1<? super T1, ?
             @Override
             public Observable<R> call(final T1 t1) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -715,15 +721,18 @@ public static <T1, T2, R> Func2<T1, T2, Observable<R>> toAsync(final Func2<? sup
             @Override
             public Observable<R> call(final T1 t1, final T2 t2) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -776,15 +785,18 @@ public static <T1, T2, T3, R> Func3<T1, T2, T3, Observable<R>> toAsync(final Fun
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2, t3);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -839,15 +851,18 @@ public static <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, Observable<R>> toAsync(f
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2, t3, t4);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -904,15 +919,18 @@ public static <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, Observable<R>> t
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2, t3, t4, t5);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -971,15 +989,18 @@ public static <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, Observab
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2, t3, t4, t5, t6);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -1040,15 +1061,18 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2, t3, t4, t5, t6, t7);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -1111,15 +1135,18 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7, final T8 t8) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2, t3, t4, t5, t6, t7, t8);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -1184,15 +1211,18 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func9<T1, T2, T3, T4, T5,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7, final T8 t8, final T9 t9) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(t1, t2, t3, t4, t5, t6, t7, t8, t9);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -1237,15 +1267,18 @@ public static <R> FuncN<Observable<R>> toAsync(final FuncN<? extends R> func, fi
             @Override
             public Observable<R> call(final Object... args) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                scheduler.schedule(new Action1<Inner>() {
+                final Inner inner = scheduler.inner();
+                inner.schedule(new Action0() {
                     @Override
-                    public void call(Inner inner) {
+                    public void call() {
                         R result;
                         try {
                             result = func.call(args);
                         } catch (Throwable t) {
                             subject.onError(t);
                             return;
+                        } finally {
+                            inner.unsubscribe();
                         }
                         subject.onNext(result);
                         subject.onCompleted();
@@ -1498,11 +1531,12 @@ public static <T> FutureTask<Void> forEachFuture(
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
-        Observable<? extends T> source,
-        Action1<? super T> onNext,
-        Scheduler scheduler) {
-        FutureTask < Void > task = OperationForEachFuture.forEachFuture(source, onNext);
-        scheduler.schedule(Functionals.fromRunnable(task));
+            Observable<? extends T> source,
+            Action1<? super T> onNext,
+            Scheduler scheduler) {
+        FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext);
+        final Inner inner = scheduler.inner();
+        inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
     
@@ -1524,12 +1558,13 @@ public static <T> FutureTask<Void> forEachFuture(
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
-        Observable<? extends T> source,
-        Action1<? super T> onNext,
-        Action1<? super Throwable> onError,
-        Scheduler scheduler) {
-        FutureTask < Void > task = OperationForEachFuture.forEachFuture(source, onNext, onError);
-        scheduler.schedule(Functionals.fromRunnable(task));
+            Observable<? extends T> source,
+            Action1<? super T> onNext,
+            Action1<? super Throwable> onError,
+            Scheduler scheduler) {
+        FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError);
+        final Inner inner = scheduler.inner();
+        inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
     
@@ -1558,7 +1593,8 @@ public static <T> FutureTask<Void> forEachFuture(
             Action0 onCompleted,
             Scheduler scheduler) {
         FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
-        scheduler.schedule(Functionals.fromRunnable(task));
+        final Inner inner = scheduler.inner();
+        inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
     
@@ -1764,14 +1800,17 @@ public void call(Subscriber<? super U> t1) {
             }
         }, csub);
         
-        csub.set(scheduler.schedule(new Action1<Inner>() {
+        final Inner inner = scheduler.inner();
+        csub.set(inner);
+        
+        inner.schedule(new Action0() {
             @Override
-            public void call(Inner t1) {
+            public void call() {
                 if (!csub.isUnsubscribed()) {
                     action.call(subject, csub);
                 }
             }
-        }));
+        });
         
         return co;
     }
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 037c7b8573..b3c460ca2f 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
@@ -66,23 +66,29 @@ public void call() {
      * @param run the Runnable to run when the Action0 is called
      * @return the Action0 wrapping the Runnable
      */
-    public static Action1<Inner> fromRunnable(Runnable run) {
+    public static Action0 fromRunnable(Runnable run, Inner inner) {
         if (run == null) {
             throw new NullPointerException("run");
         }
-        return new ActionWrappingRunnable(run);
+        return new ActionWrappingRunnable(run, inner);
     }
     /** An Action1 which wraps and calls a Runnable. */
-    private static final class ActionWrappingRunnable implements Action1<Inner> {
+    private static final class ActionWrappingRunnable implements Action0 {
         final Runnable run;
+        final Inner inner;
 
-        public ActionWrappingRunnable(Runnable run) {
+        public ActionWrappingRunnable(Runnable run, Inner inner) {
             this.run = run;
+            this.inner = inner;
         }
 
         @Override
-        public void call(Inner inner) {
-            run.run();
+        public void call() {
+            try {
+                run.run();
+            } finally {
+                inner.unsubscribe();
+            }
         }
         
     }
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 902d202727..61eb86c77a 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
@@ -18,11 +18,14 @@
 import java.util.Map;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func0;
 import rx.subscriptions.MultipleAssignmentSubscription;
+import rx.subscriptions.SerialSubscription;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -92,7 +95,7 @@ public static <R> OnSubscribeFunc<R> ifThen(
      *            the post condition after the source completes
      * @return a subscription function.
      */
-    public static <T> OnSubscribeFunc<T> doWhile(Observable<? extends T> source, Func0<Boolean> postCondition) {
+    public static <T> OnSubscribe<T> doWhile(Observable<? extends T> source, Func0<Boolean> postCondition) {
         return new WhileDoWhile<T>(source, TRUE, postCondition);
     }
 
@@ -109,7 +112,7 @@ public static <T> OnSubscribeFunc<T> doWhile(Observable<? extends T> source, Fun
      *            and subscribe to source if it returns {@code true}
      * @return a subscription function.
      */
-    public static <T> OnSubscribeFunc<T> whileDo(Observable<? extends T> source, Func0<Boolean> preCondition) {
+    public static <T> OnSubscribe<T> whileDo(Observable<? extends T> source, Func0<Boolean> preCondition) {
         return new WhileDoWhile<T>(source, preCondition, preCondition);
     }
 
@@ -209,7 +212,7 @@ public Subscription onSubscribe(Observer<? super R> t1) {
      * @param <T>
      *            the result value type
      */
-    private static final class WhileDoWhile<T> implements OnSubscribeFunc<T> {
+    private static final class WhileDoWhile<T> implements OnSubscribe<T> {
         final Func0<Boolean> preCondition;
         final Func0<Boolean> postCondition;
         final Observable<? extends T> source;
@@ -222,45 +225,62 @@ public WhileDoWhile(Observable<? extends T> source,
         }
 
         @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
+        public void call(Subscriber<? super T> child) {
             boolean first;
             try {
                 first = preCondition.call();
             } catch (Throwable t) {
-                t1.onError(t);
-                return Subscriptions.empty();
+                child.onError(t);
+                return;
             }
+
+            SerialSubscription cancel = new SerialSubscription();
+            final WhileDoWhile<T>.SourceObserver sourceObserver = new SourceObserver(child, cancel);
+
             if (first) {
-                MultipleAssignmentSubscription ssub = new MultipleAssignmentSubscription();
+                Subscriber<T> firstSubscription = new Subscriber<T>() {
+
+                    @Override
+                    public void onCompleted() {
+                        sourceObserver.onCompleted();
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        sourceObserver.onError(e);
+                    }
 
-                ssub.set(source.subscribe(new SourceObserver(t1, ssub)));
+                    @Override
+                    public void onNext(T t) {
+                        sourceObserver.onNext(t);
+                    }
 
-                return ssub;
+                };
+                cancel.set(firstSubscription);
+                source.unsafeSubscribe(firstSubscription);
             } else {
-                t1.onCompleted();
+                child.onCompleted();
             }
-            return Subscriptions.empty();
         }
 
         /** Observe the source. */
         final class SourceObserver implements Observer<T> {
-            final MultipleAssignmentSubscription cancel;
-            final Observer<? super T> observer;
+            final Subscriber<? super T> actual;
+            final SerialSubscription cancel;
 
-            public SourceObserver(Observer<? super T> observer, MultipleAssignmentSubscription cancel) {
-                this.observer = observer;
+            public SourceObserver(Subscriber<? super T> actual, SerialSubscription cancel) {
+                this.actual = actual;
                 this.cancel = cancel;
             }
 
             @Override
             public void onNext(T args) {
-                observer.onNext(args);
+                actual.onNext(args);
             }
 
             @Override
             public void onError(Throwable e) {
-                observer.onError(e);
-                cancel.unsubscribe();
+                actual.onError(e);
             }
 
             @Override
@@ -269,14 +289,33 @@ public void onCompleted() {
                 try {
                     next = postCondition.call();
                 } catch (Throwable t) {
-                    observer.onError(t);
+                    actual.onError(t);
                     return;
                 }
                 if (next) {
-                    cancel.set(source.subscribe(this));
+                    Subscriber<T> newSubscription = new Subscriber<T>() {
+
+                        @Override
+                        public void onCompleted() {
+                            SourceObserver.this.onCompleted();
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            SourceObserver.this.onError(e);
+                        }
+
+                        @Override
+                        public void onNext(T t) {
+                            SourceObserver.this.onNext(t);
+                        }
+
+                    };
+                    cancel.set(newSubscription);
+                    source.unsafeSubscribe(newSubscription);
+
                 } else {
-                    observer.onCompleted();
-                    cancel.unsubscribe();
+                    actual.onCompleted();
                 }
             }
 
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 f96d28bd09..7c49a28cf9 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
@@ -128,7 +128,8 @@ <T> void observe(Observable<? extends T> source, T... values) {
     <T> void observeSequence(Observable<? extends T> source, Iterable<? extends T> values) {
         Observer<T> o = mock(Observer.class);
 
-        Subscription s = source.subscribe(new TestObserver<T>(o));
+        TestObserver<T> testObserver = new TestObserver<T>(o);
+        Subscription s = source.subscribe(testObserver);
 
         InOrder inOrder = inOrder(o);
 
@@ -401,7 +402,7 @@ public Boolean call() {
 
     @Test
     public void testDoWhileManyTimes() {
-        Observable<Integer> source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.currentThread());
+        Observable<Integer> source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.trampoline());
 
         List<Integer> expected = new ArrayList<Integer>(numRecursion * 3);
         for (int i = 0; i < numRecursion; i++) {
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
index f5edc254f6..e368b9ce77 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
@@ -20,12 +20,15 @@
 import co.paralleluniverse.fibers.FiberScheduler;
 import co.paralleluniverse.fibers.SuspendExecution;
 import co.paralleluniverse.strands.SuspendableRunnable;
+
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+
 import rx.Scheduler;
 import rx.Subscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
+import rx.functions.Action0;
 import rx.functions.Action1;
 
 /**
@@ -51,21 +54,13 @@ public NewFiberScheduler(FiberScheduler fiberScheduler) {
     private NewFiberScheduler() {
         this(DefaultFiberScheduler.getInstance());
     }
-
-    @Override
-    public Subscription schedule(Action1<Scheduler.Inner> action) {
-        EventLoopScheduler innerScheduler = new EventLoopScheduler();
-        innerScheduler.schedule(action);
-        return innerScheduler.innerSubscription;
-    }
     
     @Override
-    public Subscription schedule(Action1<Scheduler.Inner> action, long delayTime, TimeUnit unit) {
-        EventLoopScheduler innerScheduler = new EventLoopScheduler();
-        innerScheduler.schedule(action, delayTime, unit);
-        return innerScheduler.innerSubscription;
+    public Inner inner() {
+        return new EventLoopScheduler();
     }
 
+
     private class EventLoopScheduler extends Scheduler.Inner implements Subscription {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
 
@@ -73,14 +68,14 @@ private EventLoopScheduler() {
         }
 
         @Override
-        public void schedule(final Action1<Scheduler.Inner> action) {
+        public Subscription schedule(final Action0 action) {
             if (innerSubscription.isUnsubscribed()) {
                 // don't schedule, we are unsubscribed
-                return;
+                return Subscriptions.empty();
             }
 
             final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
-            Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
+            final Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
 
                 @Override
                 public void run() throws SuspendExecution {
@@ -88,7 +83,7 @@ public void run() throws SuspendExecution {
                         if (innerSubscription.isUnsubscribed()) {
                             return;
                         }
-                        action.call(EventLoopScheduler.this);
+                        action.call();
                     } finally {
                         // remove the subscription now that we're completed
                         Subscription s = sf.get();
@@ -101,13 +96,22 @@ public void run() throws SuspendExecution {
 
             sf.set(s);
             innerSubscription.add(s);
+            return Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    s.unsubscribe();
+                    innerSubscription.remove(s);
+                }
+                
+            });
         }
 
         @Override
-        public void schedule(final Action1<Scheduler.Inner> action, final long delayTime, final TimeUnit unit) {
+        public Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit) {
             final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
 
-            Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
+            final Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
 
                 @Override
                 public void run() throws InterruptedException, SuspendExecution  {
@@ -117,7 +121,7 @@ public void run() throws InterruptedException, SuspendExecution  {
                             return;
                         }
                         // now that the delay is past schedule the work to be done for real on the UI thread
-                        action.call(EventLoopScheduler.this);
+                        action.call();
                     } finally {
                         // remove the subscription now that we're completed
                         Subscription s = sf.get();
@@ -130,6 +134,15 @@ public void run() throws InterruptedException, SuspendExecution  {
 
             sf.set(s);
             innerSubscription.add(s);
+            return Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    s.unsubscribe();
+                    innerSubscription.remove(s);
+                }
+                
+            });
         }
 
         @Override
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 1854db762b..f6cd4d172d 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
@@ -19,14 +19,13 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
 
 import javax.swing.Timer;
 
 import rx.Scheduler;
 import rx.Subscription;
 import rx.functions.Action0;
-import rx.functions.Action1;
+import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 
@@ -45,24 +44,12 @@ public static SwingScheduler getInstance() {
     }
 
     @Override
-    public Subscription schedule(Action1<Inner> action) {
-        InnerSwingScheduler inner = new InnerSwingScheduler();
-        inner.schedule(action);
-        return inner;
-    }
-
-    @Override
-    public Subscription schedule(Action1<Inner> action, long delayTime, TimeUnit unit) {
-        long delay = unit.toMillis(delayTime);
-        assertThatTheDelayIsValidForTheSwingTimer(delay);
-        InnerSwingScheduler inner = new InnerSwingScheduler();
-        inner.schedule(action, delayTime, unit);
-        return inner;
+    public Inner inner() {
+        return new InnerSwingScheduler();
     }
 
     private static class InnerSwingScheduler extends Inner {
 
-        private final Inner _inner = this;
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
 
         @Override
@@ -76,12 +63,10 @@ public boolean isUnsubscribed() {
         }
 
         @Override
-        public void schedule(final Action1<Inner> action, long delayTime, TimeUnit unit) {
-            final AtomicReference<Subscription> sub = new AtomicReference<Subscription>();
+        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
             long delay = unit.toMillis(delayTime);
             assertThatTheDelayIsValidForTheSwingTimer(delay);
-
-            final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
+            final BooleanSubscription s = BooleanSubscription.create();
             class ExecuteOnceAction implements ActionListener {
                 private Timer timer;
 
@@ -92,14 +77,11 @@ private void setTimer(Timer timer) {
                 @Override
                 public void actionPerformed(ActionEvent e) {
                     timer.stop();
-                    if (innerSubscription.isUnsubscribed()) {
+                    if (innerSubscription.isUnsubscribed() || s.isUnsubscribed()) {
                         return;
                     }
-                    action.call(_inner);
-                    Subscription s = sf.get();
-                    if (s != null) {
-                        innerSubscription.remove(s);
-                    }
+                    action.call();
+                    innerSubscription.remove(s);
                 }
             }
 
@@ -108,53 +90,46 @@ public void actionPerformed(ActionEvent e) {
             executeOnce.setTimer(timer);
             timer.start();
 
-            Subscription s = Subscriptions.create(new Action0() {
+            innerSubscription.add(s);
+
+            // wrap for returning so it also removes it from the 'innerSubscription'
+            return Subscriptions.create(new Action0() {
+
                 @Override
                 public void call() {
                     timer.stop();
-
-                    Subscription subscription = sub.get();
-                    if (subscription != null) {
-                        subscription.unsubscribe();
-                    }
+                    s.unsubscribe();
+                    innerSubscription.remove(s);
                 }
-            });
 
-            sf.set(s);
-            innerSubscription.add(s);
+            });
         }
 
         @Override
-        public void schedule(final Action1<Inner> action) {
-            final AtomicReference<Subscription> sub = new AtomicReference<Subscription>();
-
-            final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
+        public Subscription schedule(final Action0 action) {
+            final BooleanSubscription s = BooleanSubscription.create();
             EventQueue.invokeLater(new Runnable() {
                 @Override
                 public void run() {
-                    if (innerSubscription.isUnsubscribed()) {
+                    if (innerSubscription.isUnsubscribed() || s.isUnsubscribed()) {
                         return;
                     }
-                    action.call(_inner);
-                    Subscription s = sf.get();
-                    if (s != null) {
-                        innerSubscription.remove(s);
-                    }
+                    action.call();
+                    innerSubscription.remove(s);
                 }
             });
 
-            Subscription s = Subscriptions.create(new Action0() {
+            innerSubscription.add(s);
+            // wrap for returning so it also removes it from the 'innerSubscription'
+            return Subscriptions.create(new Action0() {
+
                 @Override
                 public void call() {
-                    Subscription subscription = sub.get();
-                    if (subscription != null) {
-                        subscription.unsubscribe();
-                    }
+                    s.unsubscribe();
+                    innerSubscription.remove(s);
                 }
-            });
 
-            sf.set(s);
-            innerSubscription.add(s);
+            });
         }
 
     }
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
index ce3c18e2d8..2a9bfcd563 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
@@ -19,9 +19,8 @@
 
 import rx.Scheduler.Inner;
 import rx.Subscription;
-import rx.schedulers.SwingScheduler;
 import rx.functions.Action0;
-import rx.functions.Action1;
+import rx.schedulers.SwingScheduler;
 
 public final class SwingSubscriptions {
 
@@ -42,10 +41,12 @@ public void call() {
                 if (SwingUtilities.isEventDispatchThread()) {
                     unsubscribe.call();
                 } else {
-                    SwingScheduler.getInstance().schedule(new Action1<Inner>() {
+                    final Inner inner = SwingScheduler.getInstance().inner();
+                    inner.schedule(new Action0() {
                         @Override
-                        public void call(Inner inner) {
+                        public void call() {
                             unsubscribe.call();
+                            inner.unsubscribe();
                         }
                     });
                 }
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
index 1b1053ec75..8e458ac632 100644
--- 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
@@ -19,11 +19,10 @@
 import java.util.concurrent.TimeUnit;
 
 import rx.Scheduler.Inner;
-import rx.schedulers.SwingScheduler;
 import rx.functions.Action0;
-import rx.functions.Action1;
+import rx.schedulers.SwingScheduler;
 
-/* package-private */ final class SwingTestHelper { // only for test
+/* package-private */final class SwingTestHelper { // only for test
 
     private final CountDownLatch latch = new CountDownLatch(1);
     private volatile Throwable error;
@@ -36,10 +35,11 @@ public static SwingTestHelper create() {
     }
 
     public SwingTestHelper runInEventDispatchThread(final Action0 action) {
-        SwingScheduler.getInstance().schedule(new Action1<Inner>() {
+        Inner inner = SwingScheduler.getInstance().inner();
+        inner.schedule(new Action0() {
 
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 try {
                     action.call();
                 } catch (Throwable e) {
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 afe6951e5b..416f54eec9 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
@@ -15,9 +15,12 @@
  */
 package rx.schedulers;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertTrue;
+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 java.awt.EventQueue;
 import java.util.concurrent.CountDownLatch;
@@ -31,8 +34,7 @@
 import org.mockito.InOrder;
 
 import rx.Scheduler.Inner;
-import rx.Subscription;
-import rx.functions.Action1;
+import rx.functions.Action0;
 
 /**
  * Executes work on the Swing UI thread.
@@ -46,33 +48,35 @@ public final class SwingSchedulerTest {
     @Test
     public void testInvalidDelayValues() {
         final SwingScheduler scheduler = new SwingScheduler();
-        final Action1<Inner> action = mock(Action1.class);
+        final Inner inner = scheduler.inner();
+        final Action0 action = mock(Action0.class);
 
         exception.expect(IllegalArgumentException.class);
-        scheduler.schedulePeriodically(action, -1L, 100L, TimeUnit.SECONDS);
+        inner.schedulePeriodically(action, -1L, 100L, TimeUnit.SECONDS);
 
         exception.expect(IllegalArgumentException.class);
-        scheduler.schedulePeriodically(action, 100L, -1L, TimeUnit.SECONDS);
+        inner.schedulePeriodically(action, 100L, -1L, TimeUnit.SECONDS);
 
         exception.expect(IllegalArgumentException.class);
-        scheduler.schedulePeriodically(action, 1L + Integer.MAX_VALUE, 100L, TimeUnit.MILLISECONDS);
+        inner.schedulePeriodically(action, 1L + Integer.MAX_VALUE, 100L, TimeUnit.MILLISECONDS);
 
         exception.expect(IllegalArgumentException.class);
-        scheduler.schedulePeriodically(action, 100L, 1L + Integer.MAX_VALUE / 1000, TimeUnit.SECONDS);
+        inner.schedulePeriodically(action, 100L, 1L + Integer.MAX_VALUE / 1000, TimeUnit.SECONDS);
     }
 
     @Test
     public void testPeriodicScheduling() throws Exception {
         final SwingScheduler scheduler = new SwingScheduler();
+        final Inner inner = scheduler.inner();
 
         final CountDownLatch latch = new CountDownLatch(4);
 
-        final Action1<Inner> innerAction = mock(Action1.class);
-        final Action1<Inner> action = new Action1<Inner>() {
+        final Action0 innerAction = mock(Action0.class);
+        final Action0 action = new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 try {
-                    innerAction.call(inner);
+                    innerAction.call();
                     assertTrue(SwingUtilities.isEventDispatchThread());
                 } finally {
                     latch.countDown();
@@ -80,68 +84,69 @@ public void call(Inner inner) {
             }
         };
 
-        Subscription sub = scheduler.schedulePeriodically(action, 50, 200, TimeUnit.MILLISECONDS);
+        inner.schedulePeriodically(action, 50, 200, TimeUnit.MILLISECONDS);
 
         if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
             fail("timed out waiting for tasks to execute");
         }
 
-        sub.unsubscribe();
+        inner.unsubscribe();
         waitForEmptyEventQueue();
-        verify(innerAction, times(4)).call(any(Inner.class));
+        verify(innerAction, times(4)).call();
     }
 
     @Test
     public void testNestedActions() throws Exception {
         final SwingScheduler scheduler = new SwingScheduler();
+        final Inner inner = scheduler.inner();
 
-        final Action1<Inner> firstStepStart = mock(Action1.class);
-        final Action1<Inner> firstStepEnd = mock(Action1.class);
+        final Action0 firstStepStart = mock(Action0.class);
+        final Action0 firstStepEnd = mock(Action0.class);
 
-        final Action1<Inner> secondStepStart = mock(Action1.class);
-        final Action1<Inner> secondStepEnd = mock(Action1.class);
+        final Action0 secondStepStart = mock(Action0.class);
+        final Action0 secondStepEnd = mock(Action0.class);
 
-        final Action1<Inner> thirdStepStart = mock(Action1.class);
-        final Action1<Inner> thirdStepEnd = mock(Action1.class);
+        final Action0 thirdStepStart = mock(Action0.class);
+        final Action0 thirdStepEnd = mock(Action0.class);
 
-        final Action1<Inner> firstAction = new Action1<Inner>() {
+        final Action0 firstAction = new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 assertTrue(SwingUtilities.isEventDispatchThread());
-                firstStepStart.call(inner);
-                firstStepEnd.call(inner);
+                firstStepStart.call();
+                firstStepEnd.call();
             }
         };
-        final Action1<Inner> secondAction = new Action1<Inner>() {
+        final Action0 secondAction = new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 assertTrue(SwingUtilities.isEventDispatchThread());
-                secondStepStart.call(inner);
-                scheduler.schedule(firstAction);
-                secondStepEnd.call(inner);
+                secondStepStart.call();
+                inner.schedule(firstAction);
+                secondStepEnd.call();
             }
         };
-        final Action1<Inner> thirdAction = new Action1<Inner>() {
+        final Action0 thirdAction = new Action0() {
             @Override
-            public void call(Inner inner) {
+            public void call() {
                 assertTrue(SwingUtilities.isEventDispatchThread());
-                thirdStepStart.call(inner);
-                scheduler.schedule(secondAction);
-                thirdStepEnd.call(inner);
+                thirdStepStart.call();
+                inner.schedule(secondAction);
+                thirdStepEnd.call();
             }
         };
 
         InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
 
-        scheduler.schedule(thirdAction);
+        inner.schedule(thirdAction);
         waitForEmptyEventQueue();
 
-        inOrder.verify(thirdStepStart, times(1)).call(any(Inner.class));
-        inOrder.verify(thirdStepEnd, times(1)).call(any(Inner.class));
-        inOrder.verify(secondStepStart, times(1)).call(any(Inner.class));
-        inOrder.verify(secondStepEnd, times(1)).call(any(Inner.class));
-        inOrder.verify(firstStepStart, times(1)).call(any(Inner.class));
-        inOrder.verify(firstStepEnd, times(1)).call(any(Inner.class));
+        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 {

From e79790556db6c66e22958e2aab7b47e1a6bf6b5a Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 18 Apr 2014 09:19:33 -0700
Subject: [PATCH 229/422] inner() -> createInner()

See https://github.com/Netflix/RxJava/issues/997#issuecomment-40818768
---
 .../main/scala/rx/lang/scala/Scheduler.scala  |  2 +-
 .../schedulers/HandlerThreadScheduler.java    |  2 +-
 .../subscriptions/AndroidSubscriptions.java   |  2 +-
 .../HandlerThreadSchedulerTest.java           |  4 +--
 .../src/main/java/rx/util/async/Async.java    | 30 +++++++++----------
 .../java/rx/quasar/NewFiberScheduler.java     |  3 +-
 .../java/rx/schedulers/SwingScheduler.java    |  2 +-
 .../rx/subscriptions/SwingSubscriptions.java  |  2 +-
 .../rx/swing/sources/SwingTestHelper.java     |  2 +-
 .../rx/schedulers/SwingSchedulerTest.java     |  6 ++--
 rxjava-core/src/main/java/rx/Scheduler.java   |  2 +-
 .../java/rx/operators/ChunkedOperation.java   |  8 ++---
 .../java/rx/operators/OperationDebounce.java  |  2 +-
 .../java/rx/operators/OperationDelay.java     |  2 +-
 .../java/rx/operators/OperationInterval.java  |  2 +-
 .../main/java/rx/operators/OperationSkip.java |  2 +-
 .../java/rx/operators/OperationTakeTimed.java |  2 +-
 .../java/rx/operators/OperationTimer.java     |  4 +--
 .../java/rx/operators/OperatorObserveOn.java  |  2 +-
 .../java/rx/operators/OperatorRepeat.java     |  2 +-
 .../main/java/rx/operators/OperatorRetry.java |  2 +-
 .../rx/operators/OperatorSubscribeOn.java     |  2 +-
 .../rx/operators/OperatorTimeoutBase.java     |  2 +-
 .../rx/operators/OperatorUnsubscribeOn.java   |  2 +-
 .../java/rx/schedulers/ExecutorScheduler.java |  2 +-
 .../rx/schedulers/ImmediateScheduler.java     |  4 +--
 .../rx/schedulers/NewThreadScheduler.java     |  2 +-
 .../java/rx/schedulers/TestScheduler.java     |  2 +-
 .../rx/schedulers/TrampolineScheduler.java    |  2 +-
 .../main/java/rx/subjects/TestSubject.java    |  2 +-
 .../schedulers/TestRecursionMemoryUsage.java  |  4 +--
 rxjava-core/src/test/java/rx/EventStream.java |  2 +-
 .../rx/operators/OperationBufferTest.java     |  2 +-
 .../rx/operators/OperationDebounceTest.java   |  2 +-
 .../rx/operators/OperationSampleTest.java     |  2 +-
 .../rx/operators/OperationSwitchTest.java     |  2 +-
 .../operators/OperationThrottleFirstTest.java |  2 +-
 .../rx/operators/OperationWindowTest.java     |  2 +-
 .../java/rx/operators/OperatorAmbTest.java    |  2 +-
 .../java/rx/operators/OperatorMergeTest.java  |  6 ++--
 .../rx/operators/OperatorSubscribeOnTest.java |  4 +--
 .../operators/OperatorUnsubscribeOnTest.java  |  4 +--
 .../AbstractSchedulerConcurrencyTests.java    | 12 ++++----
 .../rx/schedulers/AbstractSchedulerTests.java | 14 ++++-----
 .../rx/schedulers/ExecutorSchedulerTests.java |  2 +-
 .../java/rx/schedulers/TestSchedulerTest.java |  4 +--
 .../src/test/java/rx/test/OperatorTester.java |  4 +--
 47 files changed, 87 insertions(+), 88 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 3316b8adc9..c88ca3c875 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
@@ -42,7 +42,7 @@ trait Scheduler {
    */
   def now: Long = this.asJavaScheduler.now()
 
-  def inner: Inner = this.asJavaScheduler.inner()
+  def createInner: Inner = this.asJavaScheduler.createInner()
 
 }
 
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 93822f6395..316480a5c2 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
@@ -43,7 +43,7 @@ public HandlerThreadScheduler(Handler handler) {
     }
 
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new InnerHandlerThreadScheduler(handler);
     }
     
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
index cc365b3f46..7d5b622c64 100644
--- 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
@@ -42,7 +42,7 @@ public void call() {
                 if (Looper.getMainLooper() == Looper.myLooper()) {
                     unsubscribe.call();
                 } else {
-                    final Inner inner = AndroidSchedulers.mainThread().inner();
+                    final Inner inner = AndroidSchedulers.mainThread().createInner();
                     inner.schedule(new Action0() {
                         @Override
                         public void call() {
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 98ec8838e4..14299340ca 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
@@ -45,7 +45,7 @@ public void shouldScheduleImmediateActionOnHandlerThread() {
         final Action0 action = mock(Action0.class);
 
         Scheduler scheduler = new HandlerThreadScheduler(handler);
-        Inner inner = scheduler.inner();
+        Inner inner = scheduler.createInner();
         inner.schedule(action);
 
         // verify that we post to the given Handler
@@ -64,7 +64,7 @@ public void shouldScheduleDelayedActionOnHandlerThread() {
         final Action0 action = mock(Action0.class);
 
         Scheduler scheduler = new HandlerThreadScheduler(handler);
-        Inner inner = scheduler.inner();
+        Inner inner = scheduler.createInner();
         inner.schedule(action, 1L, TimeUnit.SECONDS);
 
         // verify that we post to the given Handler
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 782ff69abb..acd4a86eee 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
@@ -599,7 +599,7 @@ public static <R> Func0<Observable<R>> toAsync(final Func0<? extends R> func, fi
             @Override
             public Observable<R> call() {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -659,7 +659,7 @@ public static <T1, R> Func1<T1, Observable<R>> toAsync(final Func1<? super T1, ?
             @Override
             public Observable<R> call(final T1 t1) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -721,7 +721,7 @@ public static <T1, T2, R> Func2<T1, T2, Observable<R>> toAsync(final Func2<? sup
             @Override
             public Observable<R> call(final T1 t1, final T2 t2) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -785,7 +785,7 @@ public static <T1, T2, T3, R> Func3<T1, T2, T3, Observable<R>> toAsync(final Fun
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -851,7 +851,7 @@ public static <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, Observable<R>> toAsync(f
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -919,7 +919,7 @@ public static <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, Observable<R>> t
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -989,7 +989,7 @@ public static <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, Observab
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1061,7 +1061,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1135,7 +1135,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7, final T8 t8) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1211,7 +1211,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func9<T1, T2, T3, T4, T5,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7, final T8 t8, final T9 t9) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1267,7 +1267,7 @@ public static <R> FuncN<Observable<R>> toAsync(final FuncN<? extends R> func, fi
             @Override
             public Observable<R> call(final Object... args) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1535,7 +1535,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action1<? super T> onNext,
             Scheduler scheduler) {
         FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext);
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
@@ -1563,7 +1563,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action1<? super Throwable> onError,
             Scheduler scheduler) {
         FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError);
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
@@ -1593,7 +1593,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action0 onCompleted,
             Scheduler scheduler) {
         FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
@@ -1800,7 +1800,7 @@ public void call(Subscriber<? super U> t1) {
             }
         }, csub);
         
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
         csub.set(inner);
         
         inner.schedule(new Action0() {
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
index e368b9ce77..ee473f296b 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
@@ -29,7 +29,6 @@
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 import rx.functions.Action0;
-import rx.functions.Action1;
 
 /**
  * Schedules work on a new fiber.
@@ -56,7 +55,7 @@ private NewFiberScheduler() {
     }
     
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new EventLoopScheduler();
     }
 
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 f6cd4d172d..a7d4fff65d 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
@@ -44,7 +44,7 @@ public static SwingScheduler getInstance() {
     }
 
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new InnerSwingScheduler();
     }
 
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
index 2a9bfcd563..7f8d08b040 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
@@ -41,7 +41,7 @@ public void call() {
                 if (SwingUtilities.isEventDispatchThread()) {
                     unsubscribe.call();
                 } else {
-                    final Inner inner = SwingScheduler.getInstance().inner();
+                    final Inner inner = SwingScheduler.getInstance().createInner();
                     inner.schedule(new Action0() {
                         @Override
                         public void call() {
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
index 8e458ac632..5a15b28c7b 100644
--- 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
@@ -35,7 +35,7 @@ public static SwingTestHelper create() {
     }
 
     public SwingTestHelper runInEventDispatchThread(final Action0 action) {
-        Inner inner = SwingScheduler.getInstance().inner();
+        Inner inner = SwingScheduler.getInstance().createInner();
         inner.schedule(new Action0() {
 
             @Override
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 416f54eec9..9ba0dff645 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
@@ -48,7 +48,7 @@ public final class SwingSchedulerTest {
     @Test
     public void testInvalidDelayValues() {
         final SwingScheduler scheduler = new SwingScheduler();
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
         final Action0 action = mock(Action0.class);
 
         exception.expect(IllegalArgumentException.class);
@@ -67,7 +67,7 @@ public void testInvalidDelayValues() {
     @Test
     public void testPeriodicScheduling() throws Exception {
         final SwingScheduler scheduler = new SwingScheduler();
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
 
         final CountDownLatch latch = new CountDownLatch(4);
 
@@ -98,7 +98,7 @@ public void call() {
     @Test
     public void testNestedActions() throws Exception {
         final SwingScheduler scheduler = new SwingScheduler();
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
 
         final Action0 firstStepStart = mock(Action0.class);
         final Action0 firstStepEnd = mock(Action0.class);
diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 5cb539ffd0..704c8c941a 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -48,7 +48,7 @@ public abstract class Scheduler {
      * 
      * @return Inner representing a serial queue of actions to be executed
      */
-    public abstract Inner inner();
+    public abstract Inner createInner();
 
     /**
      * Sequential Scheduler for executing actions on a single thread or event loop.
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index c6604ea381..6548b65d65 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -166,7 +166,7 @@ public TimeAndSizeBasedChunks(Observer<? super C> observer, Func0<? extends Chun
             this.maxSize = maxSize;
             this.maxTime = maxTime;
             this.unit = unit;
-            this.scheduler = scheduler.inner();
+            this.scheduler = scheduler.createInner();
         }
 
         @Override
@@ -249,7 +249,7 @@ public TimeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>
             super(observer, chunkMaker);
             this.time = time;
             this.unit = unit;
-            this.scheduler = scheduler.inner();
+            this.scheduler = scheduler.createInner();
         }
 
         @Override
@@ -608,7 +608,7 @@ protected static class TimeBasedChunkCreator<T, C> implements ChunkCreator {
         private final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription();
 
         public TimeBasedChunkCreator(final NonOverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            Inner inner = scheduler.inner();
+            Inner inner = scheduler.createInner();
             this.subscription.set(inner);
             inner.schedulePeriodically(new Action0() {
                 @Override
@@ -619,7 +619,7 @@ public void call() {
         }
 
         public TimeBasedChunkCreator(final OverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            Inner inner = scheduler.inner();
+            Inner inner = scheduler.createInner();
             this.subscription.set(inner);
             inner.schedulePeriodically(new Action0() {
                 @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 691fd80203..1d1913f4e0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -114,7 +114,7 @@ public DebounceObserver(Observer<? super T> observer, long timeout, TimeUnit uni
             this.observer = new SerializedObserver<T>(observer);
             this.timeout = timeout;
             this.unit = unit;
-            this.scheduler = scheduler.inner();
+            this.scheduler = scheduler.createInner();
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index 1e2dd0210f..bd9d7e9400 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -67,7 +67,7 @@ private static final class DelaySubscribeFunc<T> implements OnSubscribeFunc<T> {
 
         public DelaySubscribeFunc(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
             this.source = source;
-            this.scheduler = scheduler.inner();
+            this.scheduler = scheduler.createInner();
             this.time = time;
             this.unit = unit;
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
index 594bc6f984..2adbb3480f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
@@ -66,7 +66,7 @@ private Interval(long period, TimeUnit unit, Scheduler scheduler) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> observer) {
-            Inner inner = scheduler.inner();
+            Inner inner = scheduler.createInner();
             inner.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index a583b2fc18..4a2684d873 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -60,7 +60,7 @@ public SkipTimed(Observable<? extends T> source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
-            Inner inner = scheduler.inner();
+            Inner inner = scheduler.createInner();
             CompositeSubscription csub = new CompositeSubscription(inner);
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
             csub.add(so);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
index 101cd7006a..a8f203089d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
@@ -191,7 +191,7 @@ public TakeTimed(Observable<? extends T> source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
-            Inner inner = scheduler.inner();
+            Inner inner = scheduler.createInner();
             CompositeSubscription csub = new CompositeSubscription(inner);
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
             csub.add(so);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
index 03353dcf2f..663ba359eb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
@@ -50,7 +50,7 @@ public TimerOnce(long dueTime, TimeUnit unit, Scheduler scheduler) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> t1) {
-            return scheduler.inner().schedule(new Action0() {
+            return scheduler.createInner().schedule(new Action0() {
                 @Override
                 public void call() {
                     t1.onNext(0L);
@@ -79,7 +79,7 @@ public TimerPeriodically(long initialDelay, long period, TimeUnit unit, Schedule
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> t1) {
-            Inner inner = scheduler.inner();
+            Inner inner = scheduler.createInner();
             inner.schedulePeriodically(new Action0() {
                 long count;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 45281cb831..1424c3719f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -66,7 +66,7 @@ private static class ObserveOnSubscriber<T> extends Subscriber<T> {
         public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> subscriber) {
             super(subscriber);
             this.observer = subscriber;
-            this.recursiveScheduler = scheduler.inner();
+            this.recursiveScheduler = scheduler.createInner();
             subscriber.add(recursiveScheduler);
         }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index 48acabea23..5e335117d8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -71,7 +71,7 @@ public void onError(Throwable e) {
             @Override
             public void onNext(final Observable<T> t) {
                 // will only be invoked once since we're nested
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 // cleanup on unsubscribe
                 add(inner);
                 inner.schedule(new Action0() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index 94760f01b9..bcd0c0965c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -59,7 +59,7 @@ public OperatorRetry() {
 
     @Override
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> child) {
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         child.add(inner);
         
         final SerialSubscription serialSubscription = new SerialSubscription();
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index 409a6e1e4d..bd095d196a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -37,7 +37,7 @@ public OperatorSubscribeOn(Scheduler scheduler) {
 
     @Override
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> subscriber) {
-        final Inner inner = scheduler.inner();
+        final Inner inner = scheduler.createInner();
         subscriber.add(inner);
         return new Subscriber<Observable<T>>(subscriber) {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index edb6139eb6..5b58bd882a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -64,7 +64,7 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
 
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
-        Scheduler.Inner inner = scheduler.inner();
+        Scheduler.Inner inner = scheduler.createInner();
         subscriber.add(inner);
         final SerialSubscription serial = new SerialSubscription();
         subscriber.add(serial);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
index a0eac086ed..f7ddd8da99 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
@@ -41,7 +41,7 @@ public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
 
             @Override
             public void call() {
-                final Scheduler.Inner inner = scheduler.inner();
+                final Scheduler.Inner inner = scheduler.createInner();
                 inner.schedule(new Action0() {
 
                     @Override
diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
index 4a69b45a57..abf29a8684 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
@@ -54,7 +54,7 @@ public ExecutorScheduler(ScheduledExecutorService executor) {
     }
 
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new InnerExecutorScheduler();
     }
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
index ea7681ba13..bff77eb0b8 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -46,7 +46,7 @@ public static ImmediateScheduler getInstance() {
     }
 
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new InnerImmediateScheduler();
     }
 
@@ -57,7 +57,7 @@ private class InnerImmediateScheduler extends Scheduler.Inner implements Subscri
         @Override
         public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             // since we are executing immediately on this thread we must cause this thread to sleep
-            long execTime = now() + unit.toMillis(delayTime);
+            long execTime = ImmediateScheduler.this.now() + unit.toMillis(delayTime);
 
             return schedule(new SleepingAction(action, this, execTime));
         }
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 32271a8e71..0aa112df4d 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -64,7 +64,7 @@ private NewThreadScheduler() {
     }
 
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new EventLoopScheduler();
     }
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
index 1c9f67d229..524f29fcd8 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
@@ -99,7 +99,7 @@ private void triggerActions(long targetTimeInNanos) {
     }
 
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new InnerTestScheduler();
     }
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
index 6d9bc580cb..c915d7a481 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -45,7 +45,7 @@ public static TrampolineScheduler getInstance() {
     }
 
     @Override
-    public Inner inner() {
+    public Inner createInner() {
         return new InnerCurrentThreadScheduler();
     }
 
diff --git a/rxjava-core/src/main/java/rx/subjects/TestSubject.java b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
index 5a006ab84d..ef5fc99370 100644
--- a/rxjava-core/src/main/java/rx/subjects/TestSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
@@ -96,7 +96,7 @@ protected TestSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T>
         super(onSubscribe);
         this.subscriptionManager = subscriptionManager;
         this.lastNotification = lastNotification;
-        this.innerScheduler = scheduler.inner();
+        this.innerScheduler = scheduler.createInner();
     }
 
     @Override
diff --git a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
index 26e48fafc2..4e1e51f432 100644
--- a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
@@ -48,7 +48,7 @@ protected static void usingFunc2(final Scheduler scheduler) {
 
             @Override
             public void call(final Subscriber<? super Long> o) {
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 o.add(inner);
                 inner.schedule(new Action0() {
                     long i = 0;
@@ -81,7 +81,7 @@ protected static void usingAction0(final Scheduler scheduler) {
 
             @Override
             public void call(final Subscriber<? super Long> o) {
-                final Inner inner = scheduler.inner();
+                final Inner inner = scheduler.createInner();
                 o.add(inner);
                 inner.schedule(new Action0() {
 
diff --git a/rxjava-core/src/test/java/rx/EventStream.java b/rxjava-core/src/test/java/rx/EventStream.java
index abdcf82ca6..a300fc977c 100644
--- a/rxjava-core/src/test/java/rx/EventStream.java
+++ b/rxjava-core/src/test/java/rx/EventStream.java
@@ -34,7 +34,7 @@ public static Observable<Event> getEventStream(final String type, final int numI
 
             @Override
             public void call(final Subscriber<? super Event> subscriber) {
-                Inner inner = Schedulers.newThread().inner();
+                Inner inner = Schedulers.newThread().createInner();
                 subscriber.add(inner);
                 // run on a background thread inside the OnSubscribeFunc so unsubscribe works
                 inner.schedule(new Action0() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index 2fd78e8f54..695379b840 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -57,7 +57,7 @@ public class OperationBufferTest {
     public void before() {
         observer = Mockito.mock(Observer.class);
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.inner();
+        innerScheduler = scheduler.createInner();
     }
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
index e4252f4b38..ab6ff62c31 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
@@ -50,7 +50,7 @@ public class OperationDebounceTest {
     public void before() {
         scheduler = new TestScheduler();
         observer = mock(Observer.class);
-        innerScheduler = scheduler.inner();
+        innerScheduler = scheduler.createInner();
     }
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
index 492c3d14c5..39dae6778d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
@@ -48,7 +48,7 @@ public class OperationSampleTest {
     // due to mocking
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.inner();
+        innerScheduler = scheduler.createInner();
         observer = mock(Observer.class);
         observer2 = mock(Observer.class);
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
index fd2678ee5f..8ee61765ed 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
@@ -47,7 +47,7 @@ public class OperationSwitchTest {
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.inner();
+        innerScheduler = scheduler.createInner();
         observer = mock(Observer.class);
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
index 89f4eee5e7..73833e4b40 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
@@ -44,7 +44,7 @@ public class OperationThrottleFirstTest {
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.inner();
+        innerScheduler = scheduler.createInner();
         observer = mock(Observer.class);
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index 00b72c17c7..988f5bc0c0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -51,7 +51,7 @@ public class OperationWindowTest {
     @Before
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.inner();
+        innerScheduler = scheduler.createInner();
     }
 
     private static <T> List<List<T>> toLists(Observable<Observable<T>> observables) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
index f77a696af5..fae9a5d4a6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
@@ -44,7 +44,7 @@ public class OperatorAmbTest {
     @Before
     public void setUp() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.inner();
+        innerScheduler = scheduler.createInner();
     }
 
     private Observable<String> createObservable(final String[] values,
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index 782f79474a..63cefade79 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -485,7 +485,7 @@ public void testConcurrency() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Inner inner = Schedulers.newThread().inner();
+                Inner inner = Schedulers.newThread().createInner();
                 s.add(inner);
                 inner.schedule(new Action0() {
 
@@ -521,7 +521,7 @@ public void testConcurrencyWithSleeping() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Inner inner = Schedulers.newThread().inner();
+                Inner inner = Schedulers.newThread().createInner();
                 s.add(inner);
                 inner.schedule(new Action0() {
 
@@ -562,7 +562,7 @@ public void testConcurrencyWithBrokenOnCompleteContract() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Inner inner = Schedulers.newThread().inner();
+                Inner inner = Schedulers.newThread().createInner();
                 s.add(inner);
                 inner.schedule(new Action0() {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 65d95c4a25..1e1977917e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -94,8 +94,8 @@ public SlowScheduler(Scheduler actual, long delay, TimeUnit unit) {
         }
 
         @Override
-        public Inner inner() {
-            return new SlowInner(actual.inner());
+        public Inner createInner() {
+            return new SlowInner(actual.createInner());
         }
 
         private class SlowInner extends Inner {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
index 59e26e4b46..3438665ea6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
@@ -145,7 +145,7 @@ public static class UIEventLoopScheduler extends Scheduler {
 
         public UIEventLoopScheduler() {
 
-            eventLoop = Schedulers.newThread().inner();
+            eventLoop = Schedulers.newThread().createInner();
             s = eventLoop;
 
             /*
@@ -169,7 +169,7 @@ public void call() {
         }
         
         @Override
-        public Inner inner() {
+        public Inner createInner() {
             return eventLoop;
         }
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 9f08b3f439..1eeaa31ac8 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -100,7 +100,7 @@ public void testUnsubscribeRecursiveScheduleFromOutside() throws InterruptedExce
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        final Inner inner = getScheduler().inner();
+        final Inner inner = getScheduler().createInner();
 
         inner.schedule(new Action0() {
 
@@ -145,7 +145,7 @@ public void call() {
     public void testUnsubscribeRecursiveScheduleFromInside() throws InterruptedException {
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        final Inner inner = getScheduler().inner();
+        final Inner inner = getScheduler().createInner();
         inner.schedule(new Action0() {
 
             @Override
@@ -179,7 +179,7 @@ public void testUnsubscribeRecursiveScheduleWithDelay() throws InterruptedExcept
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        final Inner inner = getScheduler().inner();
+        final Inner inner = getScheduler().createInner();
         inner.schedule(new Action0() {
 
             @Override
@@ -220,7 +220,7 @@ public void call() {
     @Test
     public void recursionFromOuterActionAndUnsubscribeInside() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        final Inner inner = getScheduler().inner();
+        final Inner inner = getScheduler().createInner();
         inner.schedule(new Action0() {
 
             int i = 0;
@@ -245,7 +245,7 @@ public void call() {
     @Test
     public void testRecursion() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        final Inner inner = getScheduler().inner();
+        final Inner inner = getScheduler().createInner();
         inner.schedule(new Action0() {
 
             private long i = 0;
@@ -276,7 +276,7 @@ public void testRecursionAndOuterUnsubscribe() throws InterruptedException {
         Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(final Subscriber<? super Integer> observer) {
-                final Inner inner = getScheduler().inner();
+                final Inner inner = getScheduler().createInner();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 53f5900ed4..04a3c569f9 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -61,7 +61,7 @@ public abstract class AbstractSchedulerTests {
     @Test
     public void testNestedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         final CountDownLatch latch = new CountDownLatch(1);
 
         final Action0 firstStepStart = mock(Action0.class);
@@ -153,7 +153,7 @@ public String call(String s) {
     @Test
     public final void testSequenceOfActions() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         
         final CountDownLatch latch = new CountDownLatch(2);
         final Action0 first = mock(Action0.class);
@@ -196,7 +196,7 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
     @Test
     public void testSequenceOfDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         
         final CountDownLatch latch = new CountDownLatch(1);
         final Action0 first = mock(Action0.class);
@@ -228,7 +228,7 @@ public void call() {
     @Test
     public void testMixOfDelayedAndNonDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         
         final CountDownLatch latch = new CountDownLatch(1);
         final Action0 first = mock(Action0.class);
@@ -265,7 +265,7 @@ public void call() {
     @Test
     public final void testRecursiveExecution() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         final AtomicInteger i = new AtomicInteger();
         final CountDownLatch latch = new CountDownLatch(1);
         inner.schedule(new Action0() {
@@ -287,7 +287,7 @@ public void call() {
     @Test
     public final void testRecursiveExecutionWithDelayTime() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         final AtomicInteger i = new AtomicInteger();
         final CountDownLatch latch = new CountDownLatch(1);
 
@@ -316,7 +316,7 @@ public final void testRecursiveSchedulerInObservable() {
         Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(final Subscriber<? super Integer> observer) {
-                final Scheduler.Inner inner = getScheduler().inner();
+                final Scheduler.Inner inner = getScheduler().createInner();
                 observer.add(inner);
                 inner.schedule(new Action0() {
                     int i = 0;
diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
index 2f2bd9214a..32dae60435 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
@@ -45,7 +45,7 @@ public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() {
         final CountDownLatch latch = new CountDownLatch(1);
         final HashMap<String, Integer> map = new HashMap<String, Integer>();
         
-        final Scheduler.Inner inner = Schedulers.computation().inner();
+        final Scheduler.Inner inner = Schedulers.computation().createInner();
         
         inner.schedule(new Action0() {
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
index 8bc5297aa1..c751c6a17e 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -43,7 +43,7 @@ public final void testPeriodicScheduling() {
         final Func1<Long, Void> calledOp = mock(Func1.class);
 
         final TestScheduler scheduler = new TestScheduler();
-        final Scheduler.Inner inner = scheduler.inner();
+        final Scheduler.Inner inner = scheduler.createInner();
         
         inner.schedulePeriodically(new Action0() {
             @Override
@@ -81,7 +81,7 @@ public void call() {
     @Test
     public final void testImmediateUnsubscribes() {
         TestScheduler s = new TestScheduler();
-        final Scheduler.Inner inner = s.inner();
+        final Scheduler.Inner inner = s.createInner();
         final AtomicInteger counter = new AtomicInteger(0);
         
         inner.schedule(new Action0() {
diff --git a/rxjava-core/src/test/java/rx/test/OperatorTester.java b/rxjava-core/src/test/java/rx/test/OperatorTester.java
index d5d556f851..3069e5e5ec 100644
--- a/rxjava-core/src/test/java/rx/test/OperatorTester.java
+++ b/rxjava-core/src/test/java/rx/test/OperatorTester.java
@@ -52,8 +52,8 @@ public ForwardingScheduler(Scheduler underlying) {
         }
 
         @Override
-        public Inner inner() {
-            return underlying.inner();
+        public Inner createInner() {
+            return underlying.createInner();
         }
 
     }

From 46d3c66a36dda366c86e86efefe56264e1b491f7 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 18 Apr 2014 09:21:09 -0700
Subject: [PATCH 230/422] degreeOfParallelism() -> parallelism()

https://github.com/Netflix/RxJava/issues/997#issuecomment-40819656
---
 rxjava-core/src/main/java/rx/Scheduler.java                  | 2 +-
 rxjava-core/src/main/java/rx/operators/OperatorParallel.java | 2 +-
 2 files 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 704c8c941a..4f72f389e4 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -128,7 +128,7 @@ public long now() {
      * 
      * @return the scheduler's available degree of parallelism
      */
-    public int degreeOfParallelism() {
+    public int parallelism() {
         return Runtime.getRuntime().availableProcessors();
     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
index 0e9893a54b..dcc92bf462 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorParallel.java
@@ -34,7 +34,7 @@ public final class OperatorParallel<T, R> implements Operator<R, T> {
     public OperatorParallel(Func1<Observable<T>, Observable<R>> f, Scheduler scheduler) {
         this.scheduler = scheduler;
         this.f = f;
-        this.degreeOfParallelism = scheduler.degreeOfParallelism();
+        this.degreeOfParallelism = scheduler.parallelism();
     }
 
     @Override

From c37fc2b4041c37765eecadf5ae9aea9483940c08 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Fri, 18 Apr 2014 19:13:42 -0700
Subject: [PATCH 231/422] 0.18.0-SNAPSHOT

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

diff --git a/gradle.properties b/gradle.properties
index cf84ac8f3e..cff13a233e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.17.7-SNAPSHOT
+version=0.18.0-SNAPSHOT

From 15a20e1996b70edd8c6e47862c252e17252d606f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 18 Apr 2014 20:53:57 -0700
Subject: [PATCH 232/422] Remove ExecutorScheduler - New ComputationScheduler

- see https://github.com/Netflix/RxJava/issues/711 and https://github.com/Netflix/RxJava/issues/713
---
 .../scala/schedulers/ExecutorScheduler.scala  |  41 ----
 .../operators/OperationDeferFutureTest.java   |   2 +-
 .../operators/OperationForEachFutureTest.java |   8 +-
 .../operators/OperationStartFutureTest.java   |   2 +-
 .../operators/OperationConditionalsTest.java  |   2 +-
 .../java/rx/operators/OperationBuffer.java    |   6 +-
 .../java/rx/operators/OperationWindow.java    |   6 +-
 .../rx/schedulers/ComputationScheduler.java   | 109 +++++++++++
 .../java/rx/schedulers/ExecutorScheduler.java | 185 ------------------
 .../GenericScheduledExecutorService.java      |   2 +-
 .../rx/schedulers/ImmediateScheduler.java     |   9 -
 .../rx/schedulers/NewThreadScheduler.java     |  37 ++--
 .../main/java/rx/schedulers/Schedulers.java   | 105 +---------
 .../rx/schedulers/TrampolineScheduler.java    |   9 -
 .../schedulers/SchedulerPerformanceTests.java |   9 +-
 .../schedulers/TestRecursionMemoryUsage.java  |  45 +----
 .../rx/operators/OperationWindowTest.java     |   2 +-
 ...ts.java => ComputationSchedulerTests.java} |  28 +--
 .../rx/schedulers/ImmediateSchedulerTest.java |   2 +-
 .../rx/schedulers/NewThreadSchedulerTest.java |  35 +++-
 .../schedulers/TrampolineSchedulerTest.java   |   4 +-
 21 files changed, 199 insertions(+), 449 deletions(-)
 delete mode 100644 language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala
 create mode 100644 rxjava-core/src/main/java/rx/schedulers/ComputationScheduler.java
 delete mode 100644 rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
 rename rxjava-core/src/test/java/rx/schedulers/{ExecutorSchedulerTests.java => ComputationSchedulerTests.java} (83%)

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
deleted file mode 100644
index 0ffe30b2a2..0000000000
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/ExecutorScheduler.scala
+++ /dev/null
@@ -1,41 +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, Executor}
-import rx.lang.scala.Scheduler
-
-object ExecutorScheduler {
-
-  /**
-  * Returns a [[rx.lang.scala.Scheduler]] that queues work on an `java.util.concurrent.Executor`.
-  *
-  * Note that this does not support scheduled actions with a delay.
-  */
-  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/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 f2d6091c96..8eddc63820 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
@@ -58,7 +58,7 @@ public Observable<Integer> call() throws Exception {
                 }
             };
             
-            Observable<Integer> result = Async.deferFuture(func, Schedulers.threadPoolForComputation());
+            Observable<Integer> result = Async.deferFuture(func, Schedulers.computation());
 
             final Observer<Integer> observer = mock(Observer.class);
 
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 8fd6e4c91e..75e6ff074a 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
@@ -54,7 +54,7 @@ public void testSimple() {
         
         try {
             Observable<Integer> source = Observable.from(1, 2, 3)
-                    .subscribeOn(Schedulers.threadPoolForComputation());
+                    .subscribeOn(Schedulers.computation());
             
             final AtomicInteger sum = new AtomicInteger();
             Action1<Integer> add = new Action1<Integer>() {
@@ -93,7 +93,7 @@ public void testSimpleThrowing() {
         
         try {
             Observable<Integer> source = Observable.<Integer>error(new CustomException())
-                    .subscribeOn(Schedulers.threadPoolForComputation());
+                    .subscribeOn(Schedulers.computation());
             
             final AtomicInteger sum = new AtomicInteger();
             Action1<Integer> add = new Action1<Integer>() {
@@ -128,7 +128,7 @@ public void call(Integer t1) {
     @Test
     public void testSimpleScheduled() {
         Observable<Integer> source = Observable.from(1, 2, 3)
-                .subscribeOn(Schedulers.threadPoolForComputation());
+                .subscribeOn(Schedulers.computation());
         
         final AtomicInteger sum = new AtomicInteger();
         Action1<Integer> add = new Action1<Integer>() {
@@ -158,7 +158,7 @@ public void call(Integer t1) {
     public void testSimpleScheduledThrowing() {
         
         Observable<Integer> source = Observable.<Integer>error(new CustomException())
-                .subscribeOn(Schedulers.threadPoolForComputation());
+                .subscribeOn(Schedulers.computation());
         
         final AtomicInteger sum = new AtomicInteger();
         Action1<Integer> add = new Action1<Integer>() {
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 babee1c7ac..42856ba2d7 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
@@ -104,7 +104,7 @@ public Integer call() throws Exception {
                 }
             };
 
-            Observable<Integer> result = Async.startFuture(func, Schedulers.threadPoolForComputation());
+            Observable<Integer> result = Async.startFuture(func, Schedulers.computation());
 
             final Observer<Integer> observer = mock(Observer.class);
 
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 7c49a28cf9..18530022cd 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
@@ -442,7 +442,7 @@ public void testWhileDoZeroTimes() {
 
     @Test
     public void testWhileDoManyTimes() {
-        Observable<Integer> source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.currentThread());
+        Observable<Integer> source1 = Observable.from(1, 2, 3).subscribeOn(Schedulers.trampoline());
 
         List<Integer> expected = new ArrayList<Integer>(numRecursion * 3);
         for (int i = 0; i < numRecursion; i++) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
index eaad7ca545..9ce6774d60 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
@@ -197,7 +197,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit) {
-        return buffer(source, timespan, unit, Schedulers.threadPoolForComputation());
+        return buffer(source, timespan, unit, Schedulers.computation());
     }
 
     /**
@@ -259,7 +259,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit, int count) {
-        return buffer(source, timespan, unit, count, Schedulers.threadPoolForComputation());
+        return buffer(source, timespan, unit, count, Schedulers.computation());
     }
 
     /**
@@ -325,7 +325,7 @@ public Subscription onSubscribe(final Observer<? super List<T>> observer) {
      *         the {@link Func1} object representing the specified buffer operation
      */
     public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
-        return buffer(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
+        return buffer(source, timespan, timeshift, unit, Schedulers.computation());
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
index 8280236a54..054be1f29b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
@@ -195,7 +195,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit) {
-        return window(source, timespan, unit, Schedulers.threadPoolForComputation());
+        return window(source, timespan, unit, Schedulers.computation());
     }
 
     /**
@@ -255,7 +255,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit, int count) {
-        return window(source, timespan, unit, count, Schedulers.threadPoolForComputation());
+        return window(source, timespan, unit, count, Schedulers.computation());
     }
 
     /**
@@ -318,7 +318,7 @@ public Subscription onSubscribe(final Observer<? super Observable<T>> observer)
      *         the {@link rx.functions.Func1} object representing the specified window operation
      */
     public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit) {
-        return window(source, timespan, timeshift, unit, Schedulers.threadPoolForComputation());
+        return window(source, timespan, timeshift, unit, Schedulers.computation());
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/schedulers/ComputationScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ComputationScheduler.java
new file mode 100644
index 0000000000..27214c6e0f
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/schedulers/ComputationScheduler.java
@@ -0,0 +1,109 @@
+package rx.schedulers;
+
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import rx.Scheduler;
+import rx.Subscription;
+import rx.functions.Action0;
+import rx.schedulers.NewThreadScheduler.OnActionComplete;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
+
+/* package */class ComputationScheduler extends Scheduler {
+
+    private static class ComputationSchedulerPool {
+        final int cores = Runtime.getRuntime().availableProcessors();
+        final ThreadFactory factory = new ThreadFactory() {
+            final AtomicInteger counter = new AtomicInteger();
+
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread t = new Thread(r, "RxComputationThreadPool-" + counter.incrementAndGet());
+                t.setDaemon(true);
+                return t;
+            }
+        };
+
+        final EventLoopScheduler[] eventLoops;
+
+        ComputationSchedulerPool() {
+            // initialize event loops
+            eventLoops = new EventLoopScheduler[cores];
+            for (int i = 0; i < cores; i++) {
+                eventLoops[i] = new EventLoopScheduler(factory);
+            }
+        }
+
+        private static ComputationSchedulerPool INSTANCE = new ComputationSchedulerPool();
+
+        long n = 0;
+
+        public EventLoopScheduler getEventLoop() {
+            // round-robin selection (improvements to come)
+            return eventLoops[(int) (n++ % cores)];
+        }
+
+    }
+
+    @Override
+    public Inner createInner() {
+        return new EventLoop();
+    }
+
+    private static class EventLoop extends Scheduler.Inner {
+        private final CompositeSubscription innerSubscription = new CompositeSubscription();
+        private final EventLoopScheduler pooledEventLoop;
+        private final OnActionComplete onComplete;
+
+        EventLoop() {
+            pooledEventLoop = ComputationSchedulerPool.INSTANCE.getEventLoop();
+            onComplete = new OnActionComplete() {
+
+                @Override
+                public void complete(Subscription s) {
+                    innerSubscription.remove(s);
+                }
+
+            };
+        }
+
+        @Override
+        public void unsubscribe() {
+            innerSubscription.unsubscribe();
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return innerSubscription.isUnsubscribed();
+        }
+
+        @Override
+        public Subscription schedule(Action0 action) {
+            if (innerSubscription.isUnsubscribed()) {
+                // don't schedule, we are unsubscribed
+                return Subscriptions.empty();
+            }
+            return pooledEventLoop.schedule(action, onComplete);
+        }
+
+        @Override
+        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
+            if (innerSubscription.isUnsubscribed()) {
+                // don't schedule, we are unsubscribed
+                return Subscriptions.empty();
+            }
+            
+            return pooledEventLoop.schedule(action, delayTime, unit, onComplete);
+        }
+
+    }
+
+    private static class EventLoopScheduler extends NewThreadScheduler.EventLoopScheduler {
+        EventLoopScheduler(ThreadFactory threadFactory) {
+            super(threadFactory);
+        }
+    }
+
+}
diff --git a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
deleted file mode 100644
index abf29a8684..0000000000
--- a/rxjava-core/src/main/java/rx/schedulers/ExecutorScheduler.java
+++ /dev/null
@@ -1,185 +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 java.util.concurrent.Executor;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
-import rx.Scheduler;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.subscriptions.MultipleAssignmentSubscription;
-import rx.subscriptions.Subscriptions;
-
-/**
- * A {@link Scheduler} implementation that uses an {@link Executor} or {@link ScheduledExecutorService} implementation.
- * <p>
- * Note that if an {@link Executor} implementation is used instead of {@link ScheduledExecutorService} then a
- * system-wide Timer will be used to handle delayed events.
- */
-public class ExecutorScheduler extends Scheduler {
-    private final Executor executor;
-
-    /**
-     * @deprecated Use Schedulers.executor();
-     */
-    @Deprecated
-    public ExecutorScheduler(Executor executor) {
-        this.executor = executor;
-    }
-
-    /**
-     * @deprecated Use Schedulers.executor();
-     */
-    @Deprecated
-    public ExecutorScheduler(ScheduledExecutorService executor) {
-        this.executor = executor;
-    }
-
-    @Override
-    public Inner createInner() {
-        return new InnerExecutorScheduler();
-    }
-
-    private class InnerExecutorScheduler extends Scheduler.Inner {
-
-        private final MultipleAssignmentSubscription innerSubscription = new MultipleAssignmentSubscription();
-
-        @Override
-        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
-            if (innerSubscription.isUnsubscribed()) {
-                // don't schedule, we are unsubscribed
-                return Subscriptions.empty();
-            }
-
-            if (executor instanceof ScheduledExecutorService) {
-                // we are a ScheduledExecutorService so can do proper scheduling
-                ScheduledFuture<?> f = ((ScheduledExecutorService) executor).schedule(new Runnable() {
-                    @Override
-                    public void run() {
-                        if (innerSubscription.isUnsubscribed()) {
-                            // don't execute if unsubscribed
-                            return;
-                        }
-                        // when the delay has passed we now do the work on the actual scheduler
-                        action.call();
-                    }
-                }, delayTime, unit);
-                // add the ScheduledFuture as a subscription so we can cancel the scheduled action if an unsubscribe happens
-                Subscription s = Subscriptions.from(f);
-                innerSubscription.set(s);
-                return s;
-            } 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(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() {
-                            if (innerSubscription.isUnsubscribed()) {
-                                // don't execute if unsubscribed
-                                return;
-                            }
-                            // now execute on the real Executor (by using the other overload that schedules for immediate execution)
-                            schedule(action);
-                        }
-                    }, delayTime, unit);
-                    // add the ScheduledFuture as a subscription so we can cancel the scheduled action if an unsubscribe happens
-                    Subscription s = Subscriptions.from(f);
-                    innerSubscription.set(s);
-                    return s;
-                }
-            }
-        }
-
-        @Override
-        public Subscription schedule(final Action0 action) {
-            if (innerSubscription.isUnsubscribed()) {
-                // don't schedule, we are unsubscribed
-                return Subscriptions.empty();
-            }
-
-            // work to be done on a thread
-            Runnable r = new Runnable() {
-                @Override
-                public void run() {
-                    if (innerSubscription.isUnsubscribed()) {
-                        // don't execute if unsubscribed
-                        return;
-                    }
-                    action.call();
-                }
-            };
-
-            // 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 s = Subscriptions.from(f);
-                innerSubscription.set(s);
-                return s;
-            } else {
-                // we are the lowest common denominator so can't unsubscribe once we execute
-                executor.execute(r);
-                return Subscriptions.empty();
-            }
-        }
-
-        @Override
-        public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
-            if (executor instanceof ScheduledExecutorService) {
-                ScheduledFuture<?> f = ((ScheduledExecutorService) executor).scheduleAtFixedRate(new Runnable() {
-                    @Override
-                    public void run() {
-                        if (isUnsubscribed()) {
-                            // don't execute if unsubscribed
-                            return;
-                        }
-                        action.call();
-                    }
-                }, initialDelay, period, unit);
-
-                Subscription s = Subscriptions.from(f);
-                innerSubscription.set(s);
-                return s;
-            } else {
-                return super.schedulePeriodically(action, initialDelay, period, unit);
-            }
-        }
-
-        @Override
-        public void unsubscribe() {
-            innerSubscription.unsubscribe();
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return innerSubscription.isUnsubscribed();
-        }
-
-    }
-
-}
diff --git a/rxjava-core/src/main/java/rx/schedulers/GenericScheduledExecutorService.java b/rxjava-core/src/main/java/rx/schedulers/GenericScheduledExecutorService.java
index f9b3bbe402..5b19b40ba5 100644
--- a/rxjava-core/src/main/java/rx/schedulers/GenericScheduledExecutorService.java
+++ b/rxjava-core/src/main/java/rx/schedulers/GenericScheduledExecutorService.java
@@ -40,7 +40,7 @@
 
     private GenericScheduledExecutorService() {
         int count = Runtime.getRuntime().availableProcessors();
-        if (count > 8) {
+        if (count > 4) {
             count = count / 2;
         }
         // we don't need more than 8 to handle just scheduling and doing no work
diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
index bff77eb0b8..e74296fe81 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -29,15 +29,6 @@
 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;
     }
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 0aa112df4d..cebbdba64a 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -46,15 +46,6 @@ public Thread newThread(Runnable r) {
         }
     };
 
-    /**
-     * @deprecated Use Schedulers.newThread();
-     * @return
-     */
-    @Deprecated
-    public static NewThreadScheduler getInstance() {
-        return INSTANCE;
-    }
-
     /* package */static NewThreadScheduler instance() {
         return INSTANCE;
     }
@@ -65,19 +56,23 @@ private NewThreadScheduler() {
 
     @Override
     public Inner createInner() {
-        return new EventLoopScheduler();
+        return new EventLoopScheduler(THREAD_FACTORY);
     }
 
-    private class EventLoopScheduler extends Scheduler.Inner implements Subscription {
+    /* package */static class EventLoopScheduler extends Scheduler.Inner implements Subscription {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
         private final ExecutorService executor;
 
-        private EventLoopScheduler() {
-            executor = Executors.newSingleThreadExecutor(THREAD_FACTORY);
+        /* package */EventLoopScheduler(ThreadFactory threadFactory) {
+            executor = Executors.newSingleThreadExecutor(threadFactory);
         }
 
         @Override
         public Subscription schedule(final Action0 action) {
+            return schedule(action, null);
+        }
+
+        /* package */Subscription schedule(final Action0 action, final OnActionComplete onComplete) {
             if (innerSubscription.isUnsubscribed()) {
                 // don't schedule, we are unsubscribed
                 return Subscriptions.empty();
@@ -99,6 +94,9 @@ public void run() {
                         if (s != null) {
                             innerSubscription.remove(s);
                         }
+                        if (onComplete != null) {
+                            onComplete.complete(s);
+                        }
                     }
                 }
             }));
@@ -110,6 +108,10 @@ public void run() {
 
         @Override
         public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
+            return schedule(action, delayTime, unit, null);
+        }
+
+        /* package */Subscription schedule(final Action0 action, long delayTime, TimeUnit unit, final OnActionComplete onComplete) {
             final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
             // 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
@@ -129,6 +131,9 @@ public void run() {
                         if (s != null) {
                             innerSubscription.remove(s);
                         }
+                        if (onComplete != null) {
+                            onComplete.complete(s);
+                        }
                     }
                 }
             }, delayTime, unit);
@@ -152,4 +157,10 @@ public boolean isUnsubscribed() {
 
     }
 
+    /* package */static interface OnActionComplete {
+
+        public void complete(Subscription s);
+
+    }
+
 }
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 7aa8cc0e55..74f033c1cf 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -16,11 +16,6 @@
 package rx.schedulers;
 
 import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Scheduler;
 import rx.plugins.RxJavaPlugins;
@@ -41,14 +36,14 @@ private Schedulers() {
         if (c != null) {
             computationScheduler = c;
         } else {
-            computationScheduler = executor(createComputationExecutor());
+            computationScheduler = new ComputationScheduler();
         }
 
         Scheduler io = RxJavaPlugins.getInstance().getDefaultSchedulers().getIOScheduler();
         if (io != null) {
             ioScheduler = io;
         } else {
-            ioScheduler = executor(createIOExecutor());
+            ioScheduler = NewThreadScheduler.instance(); // defaults to new thread
         }
 
         Scheduler nt = RxJavaPlugins.getInstance().getDefaultSchedulers().getNewThreadScheduler();
@@ -57,7 +52,6 @@ private Schedulers() {
         } else {
             newThreadScheduler = NewThreadScheduler.instance();
         }
-
     }
 
     /**
@@ -69,17 +63,6 @@ public static Scheduler immediate() {
         return ImmediateScheduler.instance();
     }
 
-    /**
-     * {@link Scheduler} that queues work on the current thread to be executed after the current work completes.
-     * 
-     * @return {@link TrampolineScheduler} instance
-     * @deprecated use {@link #trampoline()} instead
-     */
-    @Deprecated
-    public static Scheduler currentThread() {
-        return TrampolineScheduler.instance();
-    }
-
     /**
      * {@link Scheduler} that queues work on the current thread to be executed after the current work completes.
      * 
@@ -98,44 +81,6 @@ public static Scheduler newThread() {
         return INSTANCE.newThreadScheduler;
     }
 
-    /**
-     * {@link Scheduler} that queues work on an {@link Executor}.
-     * <p>
-     * Note that this does not support scheduled actions with a delay.
-     * 
-     * @return {@link ExecutorScheduler} instance
-     */
-    public static Scheduler executor(Executor executor) {
-        return new ExecutorScheduler(executor);
-    }
-
-    /**
-     * {@link Scheduler} that queues work on an {@link ScheduledExecutorService}.
-     * 
-     * @return {@link ExecutorScheduler} instance
-     */
-    public static Scheduler executor(ScheduledExecutorService executor) {
-        return new ExecutorScheduler(executor);
-    }
-
-    /**
-     * {@link Scheduler} intended for computational work.
-     * <p>
-     * The implementation is backed by a {@link ScheduledExecutorService} thread-pool sized to the number of CPU
-     * cores.
-     * <p>
-     * This can be used for event-loops, processing callbacks and other computational work.
-     * <p>
-     * 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 computation();
-    }
-
     /**
      * {@link Scheduler} intended for computational work.
      * <p>
@@ -149,23 +94,6 @@ public static Scheduler computation() {
         return INSTANCE.computationScheduler;
     }
 
-    /**
-     * {@link Scheduler} intended for IO-bound work.
-     * <p>
-     * The implementation is backed by an {@link Executor} thread-pool that will grow as needed.
-     * <p>
-     * This can be used for asynchronously performing blocking IO.
-     * <p>
-     * 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 io();
-    }
-
     /**
      * {@link Scheduler} intended for IO-bound work.
      * <p>
@@ -181,35 +109,6 @@ public static Scheduler io() {
         return INSTANCE.ioScheduler;
     }
 
-    private static ScheduledExecutorService createComputationExecutor() {
-        int cores = Runtime.getRuntime().availableProcessors();
-        return Executors.newScheduledThreadPool(cores, new ThreadFactory() {
-            final AtomicInteger counter = new AtomicInteger();
-
-            @Override
-            public Thread newThread(Runnable r) {
-                Thread t = new Thread(r, "RxComputationThreadPool-" + counter.incrementAndGet());
-                t.setDaemon(true);
-                return t;
-            }
-        });
-    }
-
-    private static Executor createIOExecutor() {
-        Executor result = Executors.newCachedThreadPool(new ThreadFactory() {
-            final AtomicLong counter = new AtomicLong();
-
-            @Override
-            public Thread newThread(Runnable r) {
-                Thread t = new Thread(r, "RxIOThreadPool-" + counter.incrementAndGet());
-                t.setDaemon(true);
-                return t;
-            }
-        });
-
-        return result;
-    }
-
     public static TestScheduler test() {
         return new TestScheduler();
     }
diff --git a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
index c915d7a481..af4cea9801 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -31,15 +31,6 @@
 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;
     }
diff --git a/rxjava-core/src/perf/java/rx/archive/schedulers/SchedulerPerformanceTests.java b/rxjava-core/src/perf/java/rx/archive/schedulers/SchedulerPerformanceTests.java
index 392dc50283..4df996d998 100644
--- a/rxjava-core/src/perf/java/rx/archive/schedulers/SchedulerPerformanceTests.java
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/SchedulerPerformanceTests.java
@@ -36,7 +36,7 @@ public static void main(String args[]) {
 
                 @Override
                 public void call() {
-                    spt.singleResponse(Schedulers.immediate());
+                    spt.singleResponse(Schedulers.computation());
                     //                    spt.singleResponse(Schedulers.currentThread());
                     //                    spt.singleResponse(Schedulers.computation());
 
@@ -109,8 +109,11 @@ public long baseline() {
      * 
      * --- Schedulers.computation() ---
      * 
-     * Run: 0 - 224,004 ops/sec
-     * Run: 1 - 227,101 ops/sec
+     * Run: 10 - 12,616,099 ops/sec
+     * Run: 11 - 12,661,625 ops/sec
+     * Run: 12 - 12,775,536 ops/sec
+     * Run: 13 - 12,711,358 ops/sec
+     * Run: 14 - 12,815,452 ops/sec
      * 
      */
     public long singleResponse(Scheduler scheduler) {
diff --git a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
index 4e1e51f432..6335dc2109 100644
--- a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
@@ -30,52 +30,13 @@
 public class TestRecursionMemoryUsage {
 
     public static void main(String args[]) {
-        usingFunc2(Schedulers.newThread());
-        usingAction0(Schedulers.newThread());
-
-        usingFunc2(Schedulers.immediate());
-        usingAction0(Schedulers.immediate());
-
-        usingFunc2(Schedulers.computation());
-        usingAction0(Schedulers.computation());
+        testScheduler(Schedulers.newThread());
+        testScheduler(Schedulers.computation());
 
         System.exit(0);
     }
 
-    protected static void usingFunc2(final Scheduler scheduler) {
-        System.out.println("************ usingFunc2: " + scheduler);
-        Observable.create(new OnSubscribe<Long>() {
-
-            @Override
-            public void call(final Subscriber<? super Long> o) {
-                final Inner inner = scheduler.createInner();
-                o.add(inner);
-                inner.schedule(new Action0() {
-                    long i = 0;
-
-                    @Override
-                    public void call() {
-                        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;
-                        }
-
-                        inner.schedule(this);
-                    }
-                });
-            }
-        }).toBlockingObservable().last();
-    }
-
-    protected static void usingAction0(final Scheduler scheduler) {
+    protected static void testScheduler(final Scheduler scheduler) {
         System.out.println("************ usingAction0: " + scheduler);
         Observable.create(new OnSubscribe<Long>() {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index 988f5bc0c0..480b02fdf7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -99,7 +99,7 @@ public void testSkipAndCountGaplessWindows() {
 
     @Test
     public void testOverlappingWindows() {
-        Observable<String> subject = Observable.from(new String[] { "zero", "one", "two", "three", "four", "five" }, Schedulers.currentThread());
+        Observable<String> subject = Observable.from(new String[] { "zero", "one", "two", "three", "four", "five" }, Schedulers.trampoline());
         Observable<Observable<String>> windowed = Observable.create(window(subject, 3, 1));
 
         List<List<String>> windows = toLists(windowed);
diff --git a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
similarity index 83%
rename from rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
rename to rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index 32dae60435..ef8644950b 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ExecutorSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -30,7 +30,7 @@
 import rx.functions.Action1;
 import rx.functions.Func1;
 
-public class ExecutorSchedulerTests extends AbstractSchedulerConcurrencyTests {
+public class ComputationSchedulerTests extends AbstractSchedulerConcurrencyTests {
 
     @Override
     protected Scheduler getScheduler() {
@@ -44,9 +44,9 @@ public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() {
         final int NUM = 1000000;
         final CountDownLatch latch = new CountDownLatch(1);
         final HashMap<String, Integer> map = new HashMap<String, Integer>();
-        
+
         final Scheduler.Inner inner = Schedulers.computation().createInner();
-        
+
         inner.schedule(new Action0() {
 
             private HashMap<String, Integer> statefulMap = map;
@@ -113,28 +113,6 @@ public void call(String t) {
         });
     }
 
-    @Test
-    public final void testIOThreadPool1() {
-
-        Observable<Integer> o1 = Observable.<Integer> from(1, 2, 3, 4, 5);
-        Observable<Integer> o2 = Observable.<Integer> from(6, 7, 8, 9, 10);
-        Observable<String> o = Observable.<Integer> merge(o1, o2).map(new Func1<Integer, String>() {
-
-            @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<String>() {
-
-            @Override
-            public void call(String t) {
-                System.out.println("t: " + t);
-            }
-        });
-    }
 
     @Test
     public final void testMergeWithExecutorScheduler() {
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index 622f190798..36cae71fee 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -28,7 +28,7 @@ public class ImmediateSchedulerTest extends AbstractSchedulerTests {
 
     @Override
     protected Scheduler getScheduler() {
-        return ImmediateScheduler.getInstance();
+        return Schedulers.immediate();
     }
 
     @Override
diff --git a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
index a05e60925d..2bc2f2088d 100644
--- a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
@@ -16,13 +16,46 @@
 
 package rx.schedulers;
 
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import rx.Observable;
 import rx.Scheduler;
+import rx.functions.Action1;
+import rx.functions.Func1;
 
 public class NewThreadSchedulerTest extends AbstractSchedulerConcurrencyTests {
 
     @Override
     protected Scheduler getScheduler() {
-        return NewThreadScheduler.getInstance();
+        return Schedulers.newThread();
+    }
+
+    /**
+     * IO scheduler defaults to using NewThreadScheduler
+     */
+    @Test
+    public final void testIOScheduler() {
+
+        Observable<Integer> o1 = Observable.<Integer> from(1, 2, 3, 4, 5);
+        Observable<Integer> o2 = Observable.<Integer> from(6, 7, 8, 9, 10);
+        Observable<String> o = Observable.<Integer> merge(o1, o2).map(new Func1<Integer, String>() {
+
+            @Override
+            public String call(Integer t) {
+                assertTrue(Thread.currentThread().getName().startsWith("RxNewThreadScheduler"));
+                return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
+            }
+        });
+
+        o.subscribeOn(Schedulers.io()).toBlockingObservable().forEach(new Action1<String>() {
+
+            @Override
+            public void call(String t) {
+                System.out.println("t: " + t);
+            }
+        });
     }
 
 }
diff --git a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
index e936e8caef..0add9db59d 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
@@ -28,7 +28,7 @@ public class TrampolineSchedulerTest extends AbstractSchedulerTests {
 
     @Override
     protected Scheduler getScheduler() {
-        return TrampolineScheduler.getInstance();
+        return Schedulers.trampoline();
     }
 
     @Test
@@ -38,7 +38,7 @@ public final void testMergeWithCurrentThreadScheduler1() {
 
         Observable<Integer> o1 = Observable.<Integer> from(1, 2, 3, 4, 5);
         Observable<Integer> o2 = Observable.<Integer> from(6, 7, 8, 9, 10);
-        Observable<String> o = Observable.<Integer> merge(o1, o2).subscribeOn(Schedulers.currentThread()).map(new Func1<Integer, String>() {
+        Observable<String> o = Observable.<Integer> merge(o1, o2).subscribeOn(Schedulers.trampoline()).map(new Func1<Integer, String>() {
 
             @Override
             public String call(Integer t) {

From 6896110c55a4f5b24c4cd7399681c1c1e1327169 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Fri, 18 Apr 2014 21:35:20 -0700
Subject: [PATCH 233/422] Move rx.joins to rxjava-joins module

Migrating rx.joins into a separate contrib module as part of roadmap to 1.0: https://github.com/Netflix/RxJava/issues/1001#issuecomment-40390984
This is being done until the rx.joins API has further time to mature as it is likely to change and we can't make breaking changes any further once we hit 1.0.
---
 rxjava-contrib/rxjava-joins/build.gradle      |  21 ++
 .../src/main/java/rx/joins/ActivePlan0.java   |   0
 .../src/main/java/rx/joins/ActivePlan1.java   |   0
 .../src/main/java/rx/joins/ActivePlan2.java   |   0
 .../src/main/java/rx/joins/ActivePlan3.java   |   0
 .../src/main/java/rx/joins/JoinObserver.java  |   0
 .../src/main/java/rx/joins/JoinObserver1.java |   0
 .../src/main/java/rx/joins/Pattern.java       |   0
 .../src/main/java/rx/joins/Pattern1.java      |   0
 .../src/main/java/rx/joins/Pattern2.java      |   0
 .../src/main/java/rx/joins/Pattern3.java      |   0
 .../src/main/java/rx/joins/Plan0.java         |   0
 .../src/main/java/rx/joins/Plan1.java         |   0
 .../src/main/java/rx/joins/Plan2.java         |   0
 .../src/main/java/rx/joins/Plan3.java         |   0
 .../operators/OperationJoinPatterns.java      |   2 +-
 .../java/rx/observables/JoinObservable.java   | 312 ++++++++++++++++++
 .../joins}/operators/OperationJoinsTest.java  |  61 ++--
 rxjava-core/src/main/java/rx/Observable.java  | 296 +----------------
 settings.gradle                               |   1 +
 20 files changed, 368 insertions(+), 325 deletions(-)
 create mode 100644 rxjava-contrib/rxjava-joins/build.gradle
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/ActivePlan0.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/ActivePlan1.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/ActivePlan2.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/ActivePlan3.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/JoinObserver.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/JoinObserver1.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Pattern.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Pattern1.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Pattern2.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Pattern3.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Plan0.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Plan1.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Plan2.java (100%)
 rename {rxjava-core => rxjava-contrib/rxjava-joins}/src/main/java/rx/joins/Plan3.java (100%)
 rename {rxjava-core/src/main/java/rx => rxjava-contrib/rxjava-joins/src/main/java/rx/joins}/operators/OperationJoinPatterns.java (99%)
 create mode 100644 rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java
 rename {rxjava-core/src/test/java/rx => rxjava-contrib/rxjava-joins/src/test/java/rx/joins}/operators/OperationJoinsTest.java (80%)

diff --git a/rxjava-contrib/rxjava-joins/build.gradle b/rxjava-contrib/rxjava-joins/build.gradle
new file mode 100644
index 0000000000..d27e105d0a
--- /dev/null
+++ b/rxjava-contrib/rxjava-joins/build.gradle
@@ -0,0 +1,21 @@
+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-joins'
+        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-core/src/main/java/rx/joins/ActivePlan0.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan0.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/ActivePlan0.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan0.java
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan1.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan1.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/ActivePlan1.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan1.java
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan2.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan2.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/ActivePlan2.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan2.java
diff --git a/rxjava-core/src/main/java/rx/joins/ActivePlan3.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan3.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/ActivePlan3.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/ActivePlan3.java
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/JoinObserver.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/JoinObserver.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/JoinObserver.java
diff --git a/rxjava-core/src/main/java/rx/joins/JoinObserver1.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/JoinObserver1.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/JoinObserver1.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/JoinObserver1.java
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Pattern.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern.java
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern1.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern1.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Pattern1.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern1.java
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern2.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern2.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Pattern2.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern2.java
diff --git a/rxjava-core/src/main/java/rx/joins/Pattern3.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern3.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Pattern3.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern3.java
diff --git a/rxjava-core/src/main/java/rx/joins/Plan0.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan0.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Plan0.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan0.java
diff --git a/rxjava-core/src/main/java/rx/joins/Plan1.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan1.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Plan1.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan1.java
diff --git a/rxjava-core/src/main/java/rx/joins/Plan2.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan2.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Plan2.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan2.java
diff --git a/rxjava-core/src/main/java/rx/joins/Plan3.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan3.java
similarity index 100%
rename from rxjava-core/src/main/java/rx/joins/Plan3.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Plan3.java
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperationJoinPatterns.java
similarity index 99%
rename from rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperationJoinPatterns.java
index 2ee716af46..81ea84aee1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoinPatterns.java
+++ b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperationJoinPatterns.java
@@ -13,7 +13,7 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package rx.operators;
+package rx.joins.operators;
 
 import java.util.ArrayList;
 import java.util.Arrays;
diff --git a/rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java
new file mode 100644
index 0000000000..d79b1f2204
--- /dev/null
+++ b/rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java
@@ -0,0 +1,312 @@
+package rx.observables;
+
+import rx.Observable;
+import rx.functions.Func1;
+import rx.joins.Pattern2;
+import rx.joins.Plan0;
+import rx.joins.operators.OperationJoinPatterns;
+
+public class JoinObservable<T> {
+
+    private final Observable<T> o;
+
+    private JoinObservable(Observable<T> o) {
+        this.o = o;
+    }
+
+    public static <T> JoinObservable<T> from(Observable<T> o) {
+        return new JoinObservable<T>(o);
+    }
+
+    /**
+     * Returns a Pattern that matches when both Observables emit an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param right
+     *            an Observable to match with the source Observable
+     * @return a Pattern object that matches when both Observables emit an item
+     * @throws NullPointerException
+     *             if {@code right} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: and()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229153.aspx">MSDN: Observable.And</a>
+     */
+    public final <T2> Pattern2<T, T2> and(Observable<T2> right) {
+        return OperationJoinPatterns.and(o, right);
+    }
+
+    /**
+     * Joins together the results from several patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param plans
+     *            a series of plans created by use of the {@link #then} Observer on patterns
+     * @return an Observable that emits the results from matching several patterns
+     * @throws NullPointerException
+     *             if {@code plans} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229558.aspx">MSDN: Observable.When</a>
+     */
+    public final static <R> JoinObservable<R> when(Iterable<? extends Plan0<R>> plans) {
+        if (plans == null) {
+            throw new NullPointerException("plans");
+        }
+        return from(Observable.create(OperationJoinPatterns.when(plans)));
+    }
+
+    /**
+     * Joins together the results from several patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param plans
+     *            a series of plans created by use of the {@link #then} Observer on patterns
+     * @return an Observable that emits the results from matching several patterns
+     * @throws NullPointerException
+     *             if {@code plans} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    public final static <R> JoinObservable<R> when(Plan0<R>... plans) {
+        return from(Observable.create(OperationJoinPatterns.when(plans)));
+    }
+
+    /**
+     * Joins the results from a pattern via its plan.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            the plan to join, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching a pattern
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1) {
+        return from(Observable.create(OperationJoinPatterns.when(p1)));
+    }
+
+    /**
+     * Joins together the results from two patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching two patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2)));
+    }
+
+    /**
+     * Joins together the results from three patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p3
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching three patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3)));
+    }
+
+    /**
+     * Joins together the results from four patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p3
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p4
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching four patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4)));
+    }
+
+    /**
+     * Joins together the results from five patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p3
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p4
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p5
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching five patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5)));
+    }
+
+    /**
+     * Joins together the results from six patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p3
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p4
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p5
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p6
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching six patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6)));
+    }
+
+    /**
+     * Joins together the results from seven patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p3
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p4
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p5
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p6
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p7
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching seven patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7)));
+    }
+
+    /**
+     * Joins together the results from eight patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p3
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p4
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p5
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p6
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p7
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p8
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching eight patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7, Plan0<R> p8) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8)));
+    }
+
+    /**
+     * Joins together the results from nine patterns via their plans.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param p1
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p2
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p3
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p4
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p5
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p6
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p7
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p8
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @param p9
+     *            a plan, created by use of the {@link #then} Observer on a pattern
+     * @return an Observable that emits the results from matching nine patterns
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7, Plan0<R> p8, Plan0<R> p9) {
+        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8, p9)));
+    }
+
+    /**
+     * Matches when the Observable has an available item and projects the item by invoking the selector
+     * function.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
+     * 
+     * @param selector
+     *            selector that will be invoked for items emitted by the source Observable
+     * @return a {@link Plan0} that produces the projected results, to be fed (with other Plans) to the {@link #when} Observer
+     * @throws NullPointerException
+     *             if {@code selector} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: then()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211662.aspx">MSDN: Observable.Then</a>
+     */
+    public final <R> Plan0<R> then(Func1<T, R> selector) {
+        return OperationJoinPatterns.then(o, selector);
+    }
+    
+    public Observable<T> toObservable() {
+        return o;
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java b/rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperationJoinsTest.java
similarity index 80%
rename from rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
rename to rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperationJoinsTest.java
index beeff72fe6..3b5fac3050 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinsTest.java
+++ b/rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperationJoinsTest.java
@@ -13,7 +13,7 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package rx.operators;
+package rx.joins.operators;
 
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.inOrder;
@@ -36,6 +36,7 @@
 import rx.functions.Func3;
 import rx.functions.Functions;
 import rx.joins.Plan0;
+import rx.observables.JoinObservable;
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 
@@ -95,20 +96,20 @@ public void before() {
     @Test(expected = NullPointerException.class)
     public void and2ArgumentNull() {
         Observable<Integer> some = Observable.just(1);
-        some.and(null);
+        JoinObservable.from(some).and(null);
     }
 
     @Test(expected = NullPointerException.class)
     public void and3argumentNull() {
         Observable<Integer> some = Observable.just(1);
-        some.and(some).and(null);
+        JoinObservable.from(some).and(some).and(null);
     }
 
     @Test
     public void and2() {
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.and(some).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).and(some).then(add2)).toObservable();
 
         m.subscribe(observer);
 
@@ -123,7 +124,7 @@ public void and2Error1() {
 
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(error.and(some).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(error).and(some).then(add2)).toObservable();
 
         m.subscribe(observer);
 
@@ -138,7 +139,7 @@ public void and2Error2() {
 
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.and(error).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).and(error).then(add2)).toObservable();
 
         m.subscribe(observer);
 
@@ -151,7 +152,7 @@ public void and2Error2() {
     public void and3() {
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.and(some).and(some).then(add3));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).and(some).and(some).then(add3)).toObservable();
 
         m.subscribe(observer);
 
@@ -166,7 +167,7 @@ public void and3Error1() {
 
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(error.and(some).and(some).then(add3));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(error).and(some).and(some).then(add3)).toObservable();
 
         m.subscribe(observer);
 
@@ -181,7 +182,7 @@ public void and3Error2() {
 
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.and(error).and(some).then(add3));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).and(error).and(some).then(add3)).toObservable();
 
         m.subscribe(observer);
 
@@ -196,7 +197,7 @@ public void and3Error3() {
 
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.and(some).and(error).then(add3));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).and(some).and(error).then(add3)).toObservable();
 
         m.subscribe(observer);
 
@@ -209,28 +210,28 @@ public void and3Error3() {
     public void thenArgumentNull() {
         Observable<Integer> some = Observable.just(1);
 
-        some.then(null);
+        JoinObservable.from(some).then(null);
     }
 
     @Test(expected = NullPointerException.class)
     public void then2ArgumentNull() {
         Observable<Integer> some = Observable.just(1);
 
-        some.and(some).then(null);
+        JoinObservable.from(some).and(some).then(null);
     }
 
     @Test(expected = NullPointerException.class)
     public void then3ArgumentNull() {
         Observable<Integer> some = Observable.just(1);
 
-        some.and(some).and(some).then(null);
+        JoinObservable.from(some).and(some).and(some).then(null);
     }
 
     @Test
     public void then1() {
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.then(Functions.<Integer> identity()));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).then(Functions.<Integer> identity())).toObservable();
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));
@@ -242,7 +243,7 @@ public void then1() {
     public void then1Error() {
         Observable<Integer> some = Observable.error(new RuntimeException("Forced failure"));
 
-        Observable<Integer> m = Observable.when(some.then(Functions.<Integer> identity()));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).then(Functions.<Integer> identity())).toObservable();
         m.subscribe(observer);
 
         verify(observer, times(1)).onError(any(Throwable.class));
@@ -254,7 +255,7 @@ public void then1Error() {
     public void then1Throws() {
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.then(func1Throw));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).then(func1Throw)).toObservable();
         m.subscribe(observer);
 
         verify(observer, times(1)).onError(any(Throwable.class));
@@ -266,7 +267,7 @@ public void then1Throws() {
     public void then2Throws() {
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.and(some).then(func2Throw));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).and(some).then(func2Throw)).toObservable();
         m.subscribe(observer);
 
         verify(observer, times(1)).onError(any(Throwable.class));
@@ -278,7 +279,7 @@ public void then2Throws() {
     public void then3Throws() {
         Observable<Integer> some = Observable.just(1);
 
-        Observable<Integer> m = Observable.when(some.and(some).and(some).then(func3Throw));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(some).and(some).and(some).then(func3Throw)).toObservable();
         m.subscribe(observer);
 
         verify(observer, times(1)).onError(any(Throwable.class));
@@ -288,12 +289,12 @@ public void then3Throws() {
 
     @Test(expected = NullPointerException.class)
     public void whenArgumentNull1() {
-        Observable.when((Plan0<Object>[]) null);
+        JoinObservable.when((Plan0<Object>[]) null);
     }
 
     @Test(expected = NullPointerException.class)
     public void whenArgumentNull2() {
-        Observable.when((Iterable<Plan0<Object>>) null);
+        JoinObservable.when((Iterable<Plan0<Object>>) null);
     }
 
     @Test
@@ -301,7 +302,7 @@ public void whenMultipleSymmetric() {
         Observable<Integer> source1 = Observable.from(1, 2, 3);
         Observable<Integer> source2 = Observable.from(4, 5, 6);
 
-        Observable<Integer> m = Observable.when(source1.and(source2).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(source1).and(source2).then(add2)).toObservable();
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));
@@ -316,7 +317,7 @@ public void whenMultipleAsymSymmetric() {
         Observable<Integer> source1 = Observable.from(1, 2, 3);
         Observable<Integer> source2 = Observable.from(4, 5);
 
-        Observable<Integer> m = Observable.when(source1.and(source2).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(source1).and(source2).then(add2)).toObservable();
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));
@@ -330,7 +331,7 @@ public void whenEmptyEmpty() {
         Observable<Integer> source1 = Observable.empty();
         Observable<Integer> source2 = Observable.empty();
 
-        Observable<Integer> m = Observable.when(source1.and(source2).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(source1).and(source2).then(add2)).toObservable();
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));
@@ -343,7 +344,7 @@ public void whenNeverNever() {
         Observable<Integer> source1 = Observable.never();
         Observable<Integer> source2 = Observable.never();
 
-        Observable<Integer> m = Observable.when(source1.and(source2).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(source1).and(source2).then(add2)).toObservable();
         m.subscribe(observer);
 
         verify(observer, never()).onError(any(Throwable.class));
@@ -356,7 +357,7 @@ public void whenThrowNonEmpty() {
         Observable<Integer> source1 = Observable.empty();
         Observable<Integer> source2 = Observable.error(new RuntimeException("Forced failure"));
 
-        Observable<Integer> m = Observable.when(source1.and(source2).then(add2));
+        Observable<Integer> m = JoinObservable.when(JoinObservable.from(source1).and(source2).then(add2)).toObservable();
         m.subscribe(observer);
 
         verify(observer, times(1)).onError(any(Throwable.class));
@@ -370,11 +371,11 @@ public void whenComplicated() {
         PublishSubject<Integer> ys = PublishSubject.create();
         PublishSubject<Integer> zs = PublishSubject.create();
 
-        Observable<Integer> m = Observable.when(
-                xs.and(ys).then(add2), // 1+4=5, 2+5=7, 3+6=9
-                xs.and(zs).then(mul2), // 1*7=7, 2*8=16, 3*9=27
-                ys.and(zs).then(sub2)  // 4-7=-3, 5-8=-3, 6-9=-3
-                );
+        Observable<Integer> m = JoinObservable.when(
+                JoinObservable.from(xs).and(ys).then(add2), // 1+4=5, 2+5=7, 3+6=9
+                JoinObservable.from(xs).and(zs).then(mul2), // 1*7=7, 2*8=16, 3*9=27
+                JoinObservable.from(ys).and(zs).then(sub2)  // 4-7=-3, 5-8=-3, 6-9=-3
+                ).toObservable();
 
         TestSubscriber<Integer> to = new TestSubscriber<Integer>(observer);
         m.subscribe(to);
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 75b45069f0..4352975585 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -20,7 +20,6 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
@@ -43,8 +42,6 @@
 import rx.functions.FuncN;
 import rx.functions.Function;
 import rx.functions.Functions;
-import rx.joins.Pattern2;
-import rx.joins.Plan0;
 import rx.observables.BlockingObservable;
 import rx.observables.ConnectableObservable;
 import rx.observables.GroupedObservable;
@@ -65,15 +62,12 @@
 import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
-import rx.operators.OperatorElementAt;
 import rx.operators.OperationFinally;
 import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupByUntil;
 import rx.operators.OperationGroupJoin;
 import rx.operators.OperationInterval;
 import rx.operators.OperationJoin;
-import rx.operators.OperationJoinPatterns;
-import rx.operators.OperatorMaterialize;
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMinMax;
@@ -107,9 +101,11 @@
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorDoOnEach;
+import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
 import rx.operators.OperatorGroupBy;
 import rx.operators.OperatorMap;
+import rx.operators.OperatorMaterialize;
 import rx.operators.OperatorMerge;
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorOnErrorFlatMap;
@@ -2826,259 +2822,6 @@ public final static <T, RESOURCE extends Subscription> Observable<T> using(Func0
         return create(OperationUsing.using(resourceFactory, observableFactory));
     }
 
-    /**
-     * Joins together the results from several patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param plans
-     *            a series of plans created by use of the {@link #then} Observer on patterns
-     * @return an Observable that emits the results from matching several patterns
-     * @throws NullPointerException
-     *             if {@code plans} is null
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229558.aspx">MSDN: Observable.When</a>
-     */
-    public final static <R> Observable<R> when(Iterable<? extends Plan0<R>> plans) {
-        if (plans == null) {
-            throw new NullPointerException("plans");
-        }
-        return create(OperationJoinPatterns.when(plans));
-    }
-
-    /**
-     * Joins together the results from several patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param plans
-     *            a series of plans created by use of the {@link #then} Observer on patterns
-     * @return an Observable that emits the results from matching several patterns
-     * @throws NullPointerException
-     *             if {@code plans} is null
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    public final static <R> Observable<R> when(Plan0<R>... plans) {
-        return create(OperationJoinPatterns.when(plans));
-    }
-
-    /**
-     * Joins the results from a pattern via its plan.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            the plan to join, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching a pattern
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1) {
-        return create(OperationJoinPatterns.when(p1));
-    }
-
-    /**
-     * Joins together the results from two patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching two patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2) {
-        return create(OperationJoinPatterns.when(p1, p2));
-    }
-
-    /**
-     * Joins together the results from three patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p3
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching three patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3) {
-        return create(OperationJoinPatterns.when(p1, p2, p3));
-    }
-
-    /**
-     * Joins together the results from four patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p3
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p4
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching four patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4));
-    }
-
-    /**
-     * Joins together the results from five patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p3
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p4
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p5
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching five patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5));
-    }
-
-    /**
-     * Joins together the results from six patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p3
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p4
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p5
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p6
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching six patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6));
-    }
-
-    /**
-     * Joins together the results from seven patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p3
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p4
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p5
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p6
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p7
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching seven patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7));
-    }
-
-    /**
-     * Joins together the results from eight patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p3
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p4
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p5
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p6
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p7
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p8
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching eight patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7, Plan0<R> p8) {
-        return create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8));
-    }
-
-    /**
-     * Joins together the results from nine patterns via their plans.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param p1
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p2
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p3
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p4
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p5
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p6
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p7
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p8
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @param p9
-     *            a plan, created by use of the {@link #then} Observer on a pattern
-     * @return an Observable that emits the results from matching nine patterns
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: when()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <R> Observable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7, Plan0<R> p8, Plan0<R> 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 of
      * items emitted, in sequence, by an Iterable of other Observables.
@@ -3470,23 +3213,6 @@ public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
         return create(OperationAll.all(this, predicate));
     }
 
-    /**
-     * Returns a Pattern that matches when both Observables emit an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param right
-     *            an Observable to match with the source Observable
-     * @return a Pattern object that matches when both Observables emit an item
-     * @throws NullPointerException
-     *             if {@code right} is null
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: and()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229153.aspx">MSDN: Observable.And</a>
-     */
-    public final <T2> Pattern2<T, T2> and(Observable<T2> right) {
-        return OperationJoinPatterns.and(this, 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
@@ -7582,24 +7308,6 @@ public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Int
         return create(OperationTakeWhile.takeWhileWithIndex(this, predicate));
     }
 
-    /**
-     * Matches when the Observable has an available item and projects the item by invoking the selector
-     * function.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/and_then_when.png">
-     * 
-     * @param selector
-     *            selector that will be invoked for items emitted by the source Observable
-     * @return a {@link Plan0} that produces the projected results, to be fed (with other Plans) to the {@link #when} Observer
-     * @throws NullPointerException
-     *             if {@code selector} is null
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-and-then-and-when">RxJava Wiki: then()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211662.aspx">MSDN: Observable.Then</a>
-     */
-    public final <R> Plan0<R> then(Func1<T, R> selector) {
-        return OperationJoinPatterns.then(this, selector);
-    }
-
     /**
      * Returns an Observable that emits only the first item emitted by the source Observable during sequential
      * time windows of a specified duration.
diff --git a/settings.gradle b/settings.gradle
index 0ee27bf3eb..913516f575 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -9,6 +9,7 @@ include 'rxjava-core', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-android-samples-build-wrapper', \
 'rxjava-contrib:rxjava-apache-http', \
+'rxjava-contrib:rxjava-joins', \
 'rxjava-contrib:rxjava-string', \
 'rxjava-contrib:rxjava-math', \
 'rxjava-contrib:rxjava-debug', \

From fe9d383bcb989045316d4c2add4a5196cf3c55d4 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Fri, 18 Apr 2014 23:15:59 +0800
Subject: [PATCH 234/422] Reimplement "SkipLast" operator

---
 rxjava-core/src/main/java/rx/Observable.java  |   2 +-
 .../java/rx/operators/OperationSkipLast.java  | 134 ++++++------------
 .../rx/operators/OperationSkipLastTest.java   |  29 ++--
 3 files changed, 53 insertions(+), 112 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4352975585..117eca7fa9 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6043,7 +6043,7 @@ public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
      */
     public final Observable<T> skipLast(int count) {
-        return create(OperationSkipLast.skipLast(this, count));
+        return lift(new OperationSkipLast<T>(count));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
index d4bdaad988..93f99b9b2f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
@@ -1,12 +1,12 @@
 /**
  * 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.
@@ -21,10 +21,10 @@
 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.Observable.Operator;
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscriber;
@@ -34,106 +34,60 @@
 /**
  * Bypasses a specified number of elements at the end of an observable sequence.
  */
-public class OperationSkipLast {
+public class OperationSkipLast<T> implements Operator<T, T> {
 
-    /**
-     * Bypasses a specified number of elements at the end of an observable
-     * sequence.
-     * <p>
-     * This operator accumulates a queue with a length enough to store the first
-     * count elements. As more elements are received, elements are taken from
-     * the front of the queue and produced on the result sequence. This causes
-     * elements to be delayed.
-     * 
-     * @param source
-     *            the source sequence.
-     * @param count
-     *            number of elements to bypass at the end of the source
-     *            sequence.
-     * @return An observable sequence containing the source sequence elements
-     *         except for the bypassed ones at the end.
-     * 
-     * @throws IndexOutOfBoundsException
-     *             count is less than zero.
-     */
-    public static <T> OnSubscribeFunc<T> skipLast(
-            Observable<? extends T> source, int count) {
-        return new SkipLast<T>(source, count);
-    }
+    private final int count;
 
-    private static class SkipLast<T> implements OnSubscribeFunc<T> {
-        private final int count;
-        private final Observable<? extends T> source;
-
-        private SkipLast(Observable<? extends T> source, int count) {
-            this.count = count;
-            this.source = source;
+    public OperationSkipLast(int count) {
+        if (count < 0) {
+            throw new IndexOutOfBoundsException("count could not be negative");
         }
+        this.count = count;
+    }
 
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            if (count < 0) {
-                throw new IndexOutOfBoundsException(
-                        "count could not be negative");
-            }
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(source.unsafeSubscribe(new Subscriber<T>() {
-
-                private final ReentrantLock lock = new ReentrantLock();
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
+            /**
+             * Store the last count elements until now.
+             */
+            private final Deque<T> deque = new LinkedList<T>();
 
-                /**
-                 * Store the last count elements until now.
-                 */
-                private final Deque<T> deque = new LinkedList<T>();
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
 
-                @Override
-                public void onCompleted() {
-                    observer.onCompleted();
-                }
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
 
-                @Override
-                public void onError(Throwable e) {
-                    observer.onError(e);
+            @Override
+            public void onNext(T value) {
+                if (count == 0) {
+                    // If count == 0, we do not need to put value into deque
+                    // and remove it at once. We can emit the value
+                    // directly.
+                    subscriber.onNext(value);
+                    return;
                 }
-
-                @Override
-                public void onNext(T value) {
-                    if (count == 0) {
-                        // If count == 0, we do not need to put value into deque
-                        // and remove it at once. We can emit the value
-                        // directly.
-                        try {
-                            observer.onNext(value);
-                        } catch (Throwable ex) {
-                            observer.onError(ex);
-                            subscription.unsubscribe();
-                        }
-                        return;
-                    }
-                    lock.lock();
-                    try {
-                        deque.offerLast(value);
-                        if (deque.size() > count) {
-                            // Now deque has count + 1 elements, so the first
-                            // element in the deque definitely does not belong
-                            // to the last count elements of the source
-                            // sequence. We can emit it now.
-                            observer.onNext(deque.removeFirst());
-                        }
-                    } catch (Throwable ex) {
-                        observer.onError(ex);
-                        subscription.unsubscribe();
-                    } finally {
-                        lock.unlock();
-                    }
+                deque.offerLast(value);
+                if (deque.size() > count) {
+                    // Now deque has count + 1 elements, so the first
+                    // element in the deque definitely does not belong
+                    // to the last count elements of the source
+                    // sequence. We can emit it now.
+                    subscriber.onNext(deque.removeFirst());
                 }
+            }
 
-            }));
-        }
+        };
     }
 
     /**
      * Skip delivering values in the time window before the values.
-     * 
+     *
      * @param <T>
      *            the result value type
      */
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
index 95441419aa..5a1b7bf3d5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
@@ -21,8 +21,8 @@
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationSkipLast.skipLast;
 
+import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
@@ -38,8 +38,7 @@ public class OperationSkipLastTest {
 
     @Test
     public void testSkipLastEmpty() {
-        Observable<String> w = Observable.empty();
-        Observable<String> observable = Observable.create(skipLast(w, 2));
+        Observable<String> observable = Observable.<String>empty().skipLast(2);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -51,8 +50,7 @@ public void testSkipLastEmpty() {
 
     @Test
     public void testSkipLast1() {
-        Observable<String> w = Observable.from("one", "two", "three");
-        Observable<String> observable = Observable.create(skipLast(w, 2));
+        Observable<String> observable = Observable.from(Arrays.asList("one", "two", "three")).skipLast(2);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -67,8 +65,7 @@ public void testSkipLast1() {
 
     @Test
     public void testSkipLast2() {
-        Observable<String> w = Observable.from("one", "two");
-        Observable<String> observable = Observable.create(skipLast(w, 2));
+        Observable<String> observable = Observable.from(Arrays.asList("one", "two")).skipLast(2);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -81,7 +78,7 @@ public void testSkipLast2() {
     @Test
     public void testSkipLastWithZeroCount() {
         Observable<String> w = Observable.from("one", "two");
-        Observable<String> observable = Observable.create(skipLast(w, 0));
+        Observable<String> observable = w.skipLast(0);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -94,8 +91,7 @@ public void testSkipLastWithZeroCount() {
 
     @Test
     public void testSkipLastWithNull() {
-        Observable<String> w = Observable.from("one", null, "two");
-        Observable<String> observable = Observable.create(skipLast(w, 1));
+        Observable<String> observable = Observable.from(Arrays.asList("one", null, "two")).skipLast(1);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -107,18 +103,9 @@ public void testSkipLastWithNull() {
         verify(observer, times(1)).onCompleted();
     }
 
-    @Test
+    @Test(expected = IndexOutOfBoundsException.class)
     public void testSkipLastWithNegativeCount() {
-        Observable<String> w = Observable.from("one");
-        Observable<String> observable = Observable.create(skipLast(w, -1));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, never()).onNext(any(String.class));
-        verify(observer, times(1)).onError(
-                any(IndexOutOfBoundsException.class));
-        verify(observer, never()).onCompleted();
+        Observable.from("one").skipLast(-1);
     }
 
     @Test

From 632ca76ebee64546249ee1d7ab23b40047df5dd8 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Fri, 18 Apr 2014 23:22:34 +0800
Subject: [PATCH 235/422] Rename OperationSkipLast to OperatorSkipLast

---
 rxjava-core/src/main/java/rx/Observable.java                | 6 +++---
 .../{OperationSkipLast.java => OperatorSkipLast.java}       | 4 ++--
 ...OperationSkipLastTest.java => OperatorSkipLastTest.java} | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationSkipLast.java => OperatorSkipLast.java} (98%)
 rename rxjava-core/src/test/java/rx/operators/{OperationSkipLastTest.java => OperatorSkipLastTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 117eca7fa9..825e2a7207 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -81,7 +81,6 @@
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSingle;
 import rx.operators.OperationSkip;
-import rx.operators.OperationSkipLast;
 import rx.operators.OperationSkipUntil;
 import rx.operators.OperationSum;
 import rx.operators.OperationSwitch;
@@ -117,6 +116,7 @@
 import rx.operators.OperatorScan;
 import rx.operators.OperatorSerialize;
 import rx.operators.OperatorSkip;
+import rx.operators.OperatorSkipLast;
 import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorSynchronize;
@@ -6043,7 +6043,7 @@ public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
      */
     public final Observable<T> skipLast(int count) {
-        return lift(new OperationSkipLast<T>(count));
+        return lift(new OperatorSkipLast<T>(count));
     }
 
     /**
@@ -6083,7 +6083,7 @@ public final Observable<T> skipLast(long time, TimeUnit unit) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
      */
     public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationSkipLast.SkipLastTimed<T>(this, time, unit, scheduler));
+        return create(new OperatorSkipLast.SkipLastTimed<T>(this, time, unit, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
similarity index 98%
rename from rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
rename to rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
index 93f99b9b2f..ba9455692c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
@@ -34,11 +34,11 @@
 /**
  * Bypasses a specified number of elements at the end of an observable sequence.
  */
-public class OperationSkipLast<T> implements Operator<T, T> {
+public class OperatorSkipLast<T> implements Operator<T, T> {
 
     private final int count;
 
-    public OperationSkipLast(int count) {
+    public OperatorSkipLast(int count) {
         if (count < 0) {
             throw new IndexOutOfBoundsException("count could not be negative");
         }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSkipLastTest.java
index 5a1b7bf3d5..d07227ad86 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTest.java
@@ -34,7 +34,7 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class OperationSkipLastTest {
+public class OperatorSkipLastTest {
 
     @Test
     public void testSkipLastEmpty() {

From 0fc6e2ccf82531dd93fd902437c37ffa3006676d Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sat, 19 Apr 2014 22:39:48 +0800
Subject: [PATCH 236/422] Reimplement the "SkipLast" operator with time

---
 rxjava-core/src/main/java/rx/Observable.java  |   3 +-
 .../java/rx/operators/OperatorSkipLast.java   |  81 ----------
 .../rx/operators/OperatorSkipLastTimed.java   |  82 ++++++++++
 .../rx/operators/OperatorSkipLastTest.java    |  94 -----------
 .../operators/OperatorSkipLastTimedTest.java  | 151 ++++++++++++++++++
 5 files changed, 235 insertions(+), 176 deletions(-)
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 825e2a7207..138dcf12db 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -117,6 +117,7 @@
 import rx.operators.OperatorSerialize;
 import rx.operators.OperatorSkip;
 import rx.operators.OperatorSkipLast;
+import rx.operators.OperatorSkipLastTimed;
 import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorSynchronize;
@@ -6083,7 +6084,7 @@ public final Observable<T> skipLast(long time, TimeUnit unit) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
      */
     public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperatorSkipLast.SkipLastTimed<T>(this, time, unit, scheduler));
+        return lift(new OperatorSkipLastTimed<T>(time, unit, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
index ba9455692c..af16bb243c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
@@ -15,21 +15,11 @@
  */
 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 rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observable.Operator;
-import rx.Observer;
-import rx.Scheduler;
 import rx.Subscriber;
-import rx.Subscription;
-import rx.schedulers.Timestamped;
 
 /**
  * Bypasses a specified number of elements at the end of an observable sequence.
@@ -85,75 +75,4 @@ public void onNext(T value) {
         };
     }
 
-    /**
-     * Skip delivering values in the time window before the values.
-     *
-     * @param <T>
-     *            the result value type
-     */
-    public static final class SkipLastTimed<T> implements OnSubscribeFunc<T> {
-        final Observable<? extends T> source;
-        final long timeInMillis;
-        final Scheduler scheduler;
-
-        public SkipLastTimed(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
-            this.source = source;
-            this.timeInMillis = unit.toMillis(time);
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
-            return source.unsafeSubscribe(new SourceObserver<T>(t1, timeInMillis, scheduler));
-        }
-
-        /** Observes the source. */
-        private static final class SourceObserver<T> extends Subscriber<T> {
-            final Observer<? super T> observer;
-            final long timeInMillis;
-            final Scheduler scheduler;
-            List<Timestamped<T>> buffer = new ArrayList<Timestamped<T>>();
-
-            public SourceObserver(Observer<? super T> observer,
-                    long timeInMillis, Scheduler scheduler) {
-                this.observer = observer;
-                this.timeInMillis = timeInMillis;
-                this.scheduler = scheduler;
-            }
-
-            @Override
-            public void onNext(T args) {
-                buffer.add(new Timestamped<T>(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<T> 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/OperatorSkipLastTimed.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
new file mode 100644
index 0000000000..1123dc93e8
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.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.Operator;
+import rx.Scheduler;
+import rx.Subscriber;
+import rx.schedulers.Timestamped;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Skip delivering values in the time window before the values.
+ */
+public class OperatorSkipLastTimed<T> implements Operator<T, T> {
+
+    private final long timeInMillis;
+    private final Scheduler scheduler;
+
+    public OperatorSkipLastTimed(long time, TimeUnit unit, Scheduler scheduler) {
+        this.timeInMillis = unit.toMillis(time);
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            private List<Timestamped<T>> buffer = new ArrayList<Timestamped<T>>();
+
+            @Override
+            public void onNext(T value) {
+                buffer.add(new Timestamped<T>(scheduler.now(), value));
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                buffer = Collections.emptyList();
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                long limit = scheduler.now() - timeInMillis;
+                try {
+                    for (Timestamped<T> v : buffer) {
+                        if (v.getTimestampMillis() < limit) {
+                            try {
+                                subscriber.onNext(v.getValue());
+                            } catch (Throwable t) {
+                                subscriber.onError(t);
+                                return;
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                    subscriber.onCompleted();
+                } finally {
+                    buffer = Collections.emptyList();
+                }
+            }
+
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTest.java
index d07227ad86..ef18d5984a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTest.java
@@ -23,16 +23,12 @@
 import static org.mockito.Mockito.verify;
 
 import java.util.Arrays;
-import java.util.concurrent.TimeUnit;
 
 import org.junit.Test;
 import org.mockito.InOrder;
 
 import rx.Observable;
 import rx.Observer;
-import rx.operators.OperationSkipTest.CustomException;
-import rx.schedulers.TestScheduler;
-import rx.subjects.PublishSubject;
 
 public class OperatorSkipLastTest {
 
@@ -108,94 +104,4 @@ public void testSkipLastWithNegativeCount() {
         Observable.from("one").skipLast(-1);
     }
 
-    @Test
-    public void testSkipLastTimed() {
-        TestScheduler scheduler = new TestScheduler();
-
-        PublishSubject<Integer> source = PublishSubject.create();
-
-        Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
-
-        Observer<Object> 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<Integer> source = PublishSubject.create();
-
-        Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
-
-        Observer<Object> 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<Integer> source = PublishSubject.create();
-
-        Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
-
-        Observer<Object> 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/OperatorSkipLastTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
new file mode 100644
index 0000000000..ea58175832
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
@@ -0,0 +1,151 @@
+/**
+ * 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 org.junit.Test;
+import org.mockito.InOrder;
+import rx.Observable;
+import rx.Observer;
+import rx.operators.OperationSkipTest.CustomException;
+import rx.schedulers.TestScheduler;
+import rx.subjects.PublishSubject;
+
+import java.util.concurrent.TimeUnit;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+
+public class OperatorSkipLastTimedTest {
+
+    @Test
+    public void testSkipLastTimed() {
+        TestScheduler scheduler = new TestScheduler();
+
+        PublishSubject<Integer> source = PublishSubject.create();
+
+        Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
+
+        Observer<Object> 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<Integer> source = PublishSubject.create();
+
+        Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
+
+        Observer<Object> o = mock(Observer.class);
+
+        result.subscribe(o);
+
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        source.onError(new 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<Integer> source = PublishSubject.create();
+
+        Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
+
+        Observer<Object> 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));
+    }
+
+    @Test
+    public void testSkipLastTimedWhenAllElementsAreValid() {
+        TestScheduler scheduler = new TestScheduler();
+
+        PublishSubject<Integer> source = PublishSubject.create();
+
+        Observable<Integer> result = source.skipLast(1, TimeUnit.MILLISECONDS, scheduler);
+
+        Observer<Object> 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).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onNext(3);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
+}

From a2604a81c280da491abc6203b847bdedb156b8f3 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 20 Apr 2014 00:31:36 +0800
Subject: [PATCH 237/422] Replace LinkedList with ArrayDeque

---
 .../java/rx/operators/OperatorSkipLast.java     | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
index af16bb243c..d8d297cd75 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipLast.java
@@ -15,8 +15,8 @@
  */
 package rx.operators;
 
+import java.util.ArrayDeque;
 import java.util.Deque;
-import java.util.LinkedList;
 
 import rx.Observable.Operator;
 import rx.Subscriber;
@@ -38,10 +38,13 @@ public OperatorSkipLast(int count) {
     @Override
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         return new Subscriber<T>(subscriber) {
+
+            private final NotificationLite<T> on = NotificationLite.instance();
+
             /**
              * Store the last count elements until now.
              */
-            private final Deque<T> deque = new LinkedList<T>();
+            private final Deque<Object> deque = new ArrayDeque<Object>();
 
             @Override
             public void onCompleted() {
@@ -62,14 +65,10 @@ public void onNext(T value) {
                     subscriber.onNext(value);
                     return;
                 }
-                deque.offerLast(value);
-                if (deque.size() > count) {
-                    // Now deque has count + 1 elements, so the first
-                    // element in the deque definitely does not belong
-                    // to the last count elements of the source
-                    // sequence. We can emit it now.
-                    subscriber.onNext(deque.removeFirst());
+                if (deque.size() == count) {
+                    subscriber.onNext(on.getValue(deque.removeFirst()));
                 }
+                deque.offerLast(on.next(value));
             }
 
         };

From 3759b0eda798d1d1c7a577ec3bc74582f2194c4a Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Sat, 19 Apr 2014 21:00:28 -0700
Subject: [PATCH 238/422] ComputationScheduler -> EventLoopsScheduler

- This implementation is used by Schedulers.computation() but is actually a pool of event loops, so renaming.
---
 .../{ComputationScheduler.java => EventLoopsScheduler.java}     | 2 +-
 rxjava-core/src/main/java/rx/schedulers/Schedulers.java         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename rxjava-core/src/main/java/rx/schedulers/{ComputationScheduler.java => EventLoopsScheduler.java} (98%)

diff --git a/rxjava-core/src/main/java/rx/schedulers/ComputationScheduler.java b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
similarity index 98%
rename from rxjava-core/src/main/java/rx/schedulers/ComputationScheduler.java
rename to rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
index 27214c6e0f..a5e3899368 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ComputationScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
@@ -11,7 +11,7 @@
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 
-/* package */class ComputationScheduler extends Scheduler {
+/* package */class EventLoopsScheduler extends Scheduler {
 
     private static class ComputationSchedulerPool {
         final int cores = Runtime.getRuntime().availableProcessors();
diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 74f033c1cf..2f6a886c61 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -36,7 +36,7 @@ private Schedulers() {
         if (c != null) {
             computationScheduler = c;
         } else {
-            computationScheduler = new ComputationScheduler();
+            computationScheduler = new EventLoopsScheduler();
         }
 
         Scheduler io = RxJavaPlugins.getInstance().getDefaultSchedulers().getIOScheduler();

From 9826fc9e5124b81b99e45f30726196023afce0e5 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Sat, 19 Apr 2014 21:07:03 -0700
Subject: [PATCH 239/422] Restoring parallel() to using
 Schedulers.computation()

See https://github.com/Netflix/RxJava/issues/713 for background on this.
---
 rxjava-core/src/main/java/rx/Observable.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 01d6e070e8..fa31251247 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5079,9 +5079,7 @@ public final Observable<T> onExceptionResumeNext(final Observable<? extends T> r
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-parallel">RxJava Wiki: parallel()</a>
      */
     public final <R> Observable<R> parallel(Func1<Observable<T>, Observable<R>> f) {
-        // 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<T, R>(f, Schedulers.newThread()));
+        return lift(new OperatorParallel<T, R>(f, Schedulers.computation()));
     }
 
     /**

From cd4c1acef8142e381a5ef7799834dbe0d468f374 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Sat, 19 Apr 2014 21:35:39 -0700
Subject: [PATCH 240/422] Remove deprecated rx.util.functions.*

- organized imports and fixed few places that were still accidentally using the old package
---
 language-adaptors/rxjava-clojure/README.md    |   8 +-
 .../main/clojure/rx/lang/clojure/chunk.clj    |   2 +-
 .../src/main/clojure/rx/lang/clojure/core.clj |   4 +-
 .../java/rx/quasar/BlockingObservable.java    |  20 +-
 .../java/rx/quasar/ChannelObservable.java     |  13 +-
 .../java/rx/quasar/NewFiberScheduler.java     |  13 +-
 .../rx/quasar/OnSubscribeFromChannel.java     |   4 +-
 .../rx/quasar/RxSuspendableClassifier.java    |   7 +-
 .../rx/quasar/BlockingObservableTest.java     |  14 +-
 .../java/rx/quasar/ChannelObservableTest.java |  30 +-
 .../java/rx/quasar/NewFiberSchedulerTest.java |   3 -
 .../rx/observables/BlockingObservable.java    |   1 +
 .../rx/operators/OperatorSkipLastTimed.java   |  10 +-
 .../rx/operators/OperatorTimeoutBase.java     |   1 -
 .../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 --
 .../composition/RangeMapTakeOnNextPerf.java   |   4 +-
 .../java/rx/subjects/ReplaySubjectPerf.java   |   7 +-
 .../operators/OperatorSkipLastTimedTest.java  |  14 +-
 .../operators/OperatorUnsubscribeOnTest.java  |   1 -
 .../java/rx/schedulers/TestSchedulerTest.java |   1 -
 .../java/rx/subjects/BehaviorSubjectTest.java |   2 +-
 .../java/rx/subjects/PublishSubjectTest.java  |   2 +-
 48 files changed, 84 insertions(+), 1505 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action0.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action1.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action2.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action3.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action4.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action5.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action6.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action7.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action8.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Action9.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/ActionN.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Actions.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func0.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func1.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func2.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func3.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func4.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func5.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func6.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func7.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func8.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Func9.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/FuncN.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Function.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Functions.java
 delete mode 100644 rxjava-core/src/main/java/rx/util/functions/Not.java

diff --git a/language-adaptors/rxjava-clojure/README.md b/language-adaptors/rxjava-clojure/README.md
index 4c5bdafe46..e3729bdc94 100644
--- a/language-adaptors/rxjava-clojure/README.md
+++ b/language-adaptors/rxjava-clojure/README.md
@@ -106,14 +106,14 @@ or, at the REPL:
 ```
 
 ### Using rx/fn
-Once the namespace is required, you can use the `rx/fn` macro anywhere RxJava wants a `rx.util.functions.Func` object. The syntax is exactly the same as `clojure.core/fn`:
+Once the namespace is required, you can use the `rx/fn` macro anywhere RxJava wants a `rx.functions.Func` object. The syntax is exactly the same as `clojure.core/fn`:
 
 ```clojure
 (-> my-observable
     (.map (rx/fn [v] (* 2 v))))
 ```
 
-If you already have a plain old Clojure function you'd like to use, you can pass it to the `rx/fn*` function to get a new object that implements `rx.util.functions.Func`:
+If you already have a plain old Clojure function you'd like to use, you can pass it to the `rx/fn*` function to get a new object that implements `rx.functions.Func`:
 
 ```clojure
 (-> my-numbers
@@ -121,7 +121,7 @@ If you already have a plain old Clojure function you'd like to use, you can pass
 ```
 
 ### Using rx/action
-The `rx/action` macro is identical to `rx/fn` except that the object returned implements `rx.util.functions.Action` interfaces. It's used in `subscribe` and other side-effect-y contexts:
+The `rx/action` macro is identical to `rx/fn` except that the object returned implements `rx.functions.Action` interfaces. It's used in `subscribe` and other side-effect-y contexts:
 
 ```clojure
 (-> my-observable
@@ -133,7 +133,7 @@ The `rx/action` macro is identical to `rx/fn` except that the object returned im
 ```
 
 ### 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:
+As of 0.17, `rx.Observable/create` takes an implementation of `rx.Observable$OnSubscribe` which is basically an alias for `rx.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
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
index d53c8ce322..ec07e51055 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/chunk.clj
@@ -73,7 +73,7 @@
                           (instance? rx.Observable action)
                             (rx/on-next observer
                                         (.finallyDo ^rx.Observable action
-                                                    (reify rx.util.functions.Action0
+                                                    (reify rx.functions.Action0
                                                               (call [this]
                                                                 (swap! state-atom update-in [:in-flight] disj action)
                                                                 (advance! state-atom)))))))
diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index d2768d1b37..b89141dd26 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -22,7 +22,7 @@
             BlockingObservable
             GroupedObservable]
            [rx.subscriptions Subscriptions]
-           [rx.util.functions Action0 Action1 Func0 Func1 Func2]))
+           [rx.functions Action0 Action1 Func0 Func1 Func2]))
 
 (set! *warn-on-reflection* true)
 
@@ -832,7 +832,7 @@
 
   See:
     rx.Observable/onErrorResumeNext
-    http://netflix.github.io/RxJava/javadoc/rx/Observable.html#onErrorResumeNext(rx.util.functions.Func1)
+    http://netflix.github.io/RxJava/javadoc/rx/Observable.html#onErrorResumeNext(rx.functions.Func1)
   "
   [p f ^Observable o]
   (let [p (if (class? p)
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
index 7bffe4747f..da84ec58c8 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/BlockingObservable.java
@@ -15,16 +15,6 @@
  */
 package rx.quasar;
 
-import co.paralleluniverse.fibers.SuspendExecution;
-import co.paralleluniverse.fibers.Suspendable;
-import co.paralleluniverse.strands.AbstractFuture;
-import co.paralleluniverse.strands.ConditionSynchronizer;
-import co.paralleluniverse.strands.SimpleConditionSynchronizer;
-import co.paralleluniverse.strands.Strand;
-import co.paralleluniverse.strands.channels.Channels;
-import co.paralleluniverse.strands.channels.DelegatingReceivePort;
-import co.paralleluniverse.strands.channels.ProducerException;
-import co.paralleluniverse.strands.channels.ReceivePort;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -38,6 +28,16 @@
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.observers.SafeSubscriber;
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.fibers.Suspendable;
+import co.paralleluniverse.strands.AbstractFuture;
+import co.paralleluniverse.strands.ConditionSynchronizer;
+import co.paralleluniverse.strands.SimpleConditionSynchronizer;
+import co.paralleluniverse.strands.Strand;
+import co.paralleluniverse.strands.channels.Channels;
+import co.paralleluniverse.strands.channels.DelegatingReceivePort;
+import co.paralleluniverse.strands.channels.ProducerException;
+import co.paralleluniverse.strands.channels.ReceivePort;
 
 /**
  * An extension of {@link Observable} that provides blocking operators, compatible with both threads and fibers.
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index a4cd824f9d..86785acdc0 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -14,6 +14,13 @@
  * limitations under the License.
  */package rx.quasar;
 
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Scheduler;
 import co.paralleluniverse.fibers.FiberAsync;
 import co.paralleluniverse.fibers.SuspendExecution;
 import co.paralleluniverse.fibers.Suspendable;
@@ -22,12 +29,6 @@
 import co.paralleluniverse.strands.channels.Channels;
 import co.paralleluniverse.strands.channels.ReceivePort;
 import co.paralleluniverse.strands.channels.SendPort;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import rx.Observable;
-import rx.Observer;
-import rx.Scheduler;
 
 /**
  * This class contains static methods that connect {@link Observable}s and {@link Channel}s.
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
index ee473f296b..8726f97feb 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
@@ -15,20 +15,19 @@
  */
 package rx.quasar;
 
-import co.paralleluniverse.fibers.DefaultFiberScheduler;
-import co.paralleluniverse.fibers.Fiber;
-import co.paralleluniverse.fibers.FiberScheduler;
-import co.paralleluniverse.fibers.SuspendExecution;
-import co.paralleluniverse.strands.SuspendableRunnable;
-
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Scheduler;
 import rx.Subscription;
+import rx.functions.Action0;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
-import rx.functions.Action0;
+import co.paralleluniverse.fibers.DefaultFiberScheduler;
+import co.paralleluniverse.fibers.Fiber;
+import co.paralleluniverse.fibers.FiberScheduler;
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.strands.SuspendableRunnable;
 
 /**
  * Schedules work on a new fiber.
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
index 9644828947..c7a12f223a 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/OnSubscribeFromChannel.java
@@ -15,10 +15,10 @@
  */
 package rx.quasar;
 
-import co.paralleluniverse.fibers.Suspendable;
-import co.paralleluniverse.strands.channels.ReceivePort;
 import rx.Observable.OnSubscribe;
 import rx.Subscriber;
+import co.paralleluniverse.fibers.Suspendable;
+import co.paralleluniverse.strands.channels.ReceivePort;
 
 /**
  * Converts a {@link ReceivePort} into an Observable that emits each message received on the channel.
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
index 4905ea4bfa..f32e8e5108 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/RxSuspendableClassifier.java
@@ -15,13 +15,14 @@
  */
 package rx.quasar;
 
-import co.paralleluniverse.fibers.instrument.MethodDatabase;
-import co.paralleluniverse.fibers.instrument.SimpleSuspendableClassifier;
-import co.paralleluniverse.fibers.instrument.SuspendableClassifier;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
+import co.paralleluniverse.fibers.instrument.MethodDatabase;
+import co.paralleluniverse.fibers.instrument.SimpleSuspendableClassifier;
+import co.paralleluniverse.fibers.instrument.SuspendableClassifier;
+
 public class RxSuspendableClassifier implements SuspendableClassifier {
     private static final Set<String> CORE_PACKAGES = new HashSet<String>(Arrays.asList(new String[]{
         "rx", "rx.joins", "rx.observables", "rx.observers", "rx.operators", "rx.plugins", "rx.schedulers",
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
index 5c0afc9c31..3a640ac00d 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
@@ -15,12 +15,8 @@
  */
 package rx.quasar;
 
-import co.paralleluniverse.strands.channels.ProducerException;
-import co.paralleluniverse.strands.channels.ReceivePort;
-import static org.junit.Assert.*;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import org.junit.Assert;
 import org.junit.Before;
@@ -32,10 +28,12 @@
 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;
+import co.paralleluniverse.strands.channels.ProducerException;
+import co.paralleluniverse.strands.channels.ReceivePort;
 
 public class BlockingObservableTest {
 
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
index 63ef447af3..b048ae57a9 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
@@ -15,27 +15,35 @@
  */
 package rx.quasar;
 
-import co.paralleluniverse.fibers.Fiber;
-import co.paralleluniverse.fibers.SuspendExecution;
-import co.paralleluniverse.fibers.Suspendable;
-import co.paralleluniverse.strands.Strand;
-import co.paralleluniverse.strands.SuspendableCallable;
-import co.paralleluniverse.strands.channels.Channel;
-import co.paralleluniverse.strands.channels.Channels;
-import co.paralleluniverse.strands.channels.ProducerException;
-import co.paralleluniverse.strands.channels.ReceivePort;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
+
 import org.junit.Test;
+
 import rx.Observable;
 import rx.Observer;
 import rx.subjects.PublishSubject;
+import co.paralleluniverse.fibers.Fiber;
+import co.paralleluniverse.fibers.SuspendExecution;
+import co.paralleluniverse.fibers.Suspendable;
+import co.paralleluniverse.strands.Strand;
+import co.paralleluniverse.strands.SuspendableCallable;
+import co.paralleluniverse.strands.channels.Channel;
+import co.paralleluniverse.strands.channels.Channels;
+import co.paralleluniverse.strands.channels.ProducerException;
+import co.paralleluniverse.strands.channels.ReceivePort;
 
 public class ChannelObservableTest {
     @Test
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java
index 93ef9d73b9..e252ad96bb 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/NewFiberSchedulerTest.java
@@ -15,9 +15,6 @@
  */
 package rx.quasar;
 
-import org.junit.Rule;
-import org.junit.rules.TestRule;
-import org.junit.rules.Timeout;
 import rx.Scheduler;
 import rx.schedulers.AbstractSchedulerConcurrencyTests;
 
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index 58c15124d3..bab6d67f90 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -16,6 +16,7 @@
 package rx.observables;
 
 import java.util.Iterator;
+import java.util.NoSuchElementException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicReference;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
index 1123dc93e8..f5d92583c1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
@@ -15,16 +15,16 @@
  */
 package rx.operators;
 
-import rx.Observable.Operator;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.schedulers.Timestamped;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
+import rx.Observable.Operator;
+import rx.Scheduler;
+import rx.Subscriber;
+import rx.schedulers.Timestamped;
+
 /**
  * Skip delivering values in the time window before the values.
  */
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index 5b58bd882a..b78217b09f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -24,7 +24,6 @@
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Func2;
 import rx.functions.Func3;
 import rx.functions.Func4;
 import rx.observers.SerializedSubscriber;
diff --git a/rxjava-core/src/main/java/rx/util/functions/Action.java b/rxjava-core/src/main/java/rx/util/functions/Action.java
deleted file mode 100644
index cddf3c196c..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action.java
+++ /dev/null
@@ -1,24 +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.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
deleted file mode 100644
index 0611d35984..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action0.java
+++ /dev/null
@@ -1,23 +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.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
deleted file mode 100644
index 1ec94d630d..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action1.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action1<T1> extends rx.functions.Action1<T1>, 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
deleted file mode 100644
index bde1b863ec..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action2.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action2<T1, T2> extends rx.functions.Action2<T1, T2>, 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
deleted file mode 100644
index 91ce6ed3a4..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action3.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action3<T1, T2, T3> extends rx.functions.Action3<T1, T2, T3>, 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
deleted file mode 100644
index d9c1030ee5..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action4.java
+++ /dev/null
@@ -1,24 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action4<T1, T2, T3, T4> extends rx.functions.Action4<T1, T2, T3, T4>, 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
deleted file mode 100644
index 53d5884fc3..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action5.java
+++ /dev/null
@@ -1,24 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action5<T1, T2, T3, T4, T5> extends rx.functions.Action5<T1, T2, T3, T4, T5>, 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
deleted file mode 100644
index 08d95fb504..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action6.java
+++ /dev/null
@@ -1,24 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action6<T1, T2, T3, T4, T5, T6> extends rx.functions.Action6<T1, T2, T3, T4, T5, T6>, 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
deleted file mode 100644
index 095bc5945b..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action7.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action7<T1, T2, T3, T4, T5, T6, T7> extends rx.functions.Action7<T1, T2, T3, T4, T5, T6, T7>, 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
deleted file mode 100644
index 8512994fb2..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action8.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action8<T1, T2, T3, T4, T5, T6, T7, T8> extends rx.functions.Action8<T1, T2, T3, T4, T5, T6, T7, T8>, 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
deleted file mode 100644
index eebf66a6fb..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Action9.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Action9<T1, T2, T3, T4, T5, T6, T7, T8, T9> extends rx.functions.Action9<T1, T2, T3, T4, T5, T6, T7, T8, T9>, 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
deleted file mode 100644
index e0a586aec1..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/ActionN.java
+++ /dev/null
@@ -1,23 +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.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
deleted file mode 100644
index 4cf9342097..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Actions.java
+++ /dev/null
@@ -1,465 +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.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.
-     * <p>Java 8: observer::onNext</p>
-     * 
-     * @param observer
-     *            the observer to use
-     * @return an action which calls the observer's onNext method.
-     */
-    public static <T> Action1<T> onNextFrom(final Observer<T> observer) {
-        return new Action1<T>() {
-            @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.
-     * <p>Java 8: observer::onError</p>
-     * 
-     * @param observer
-     *            the observer to use
-     * @return an action which calls the observer's onError method.
-     */
-    public static <T> Action1<Throwable> onErrorFrom(final Observer<T> observer) {
-        return new Action1<Throwable>() {
-            @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.
-     * <p>Java 8: observer::onCompleted</p>
-     * 
-     * @param observer
-     *            the observer to use
-     * @return an action which calls the observer's onCompleted method.
-     */
-    public static <T> Action0 onCompletedFrom(final Observer<T> 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<Void> 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 <T1> Func1<T1, Void> toFunc(final Action1<T1> 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 <T1, T2> Func2<T1, T2, Void> toFunc(final Action2<T1, T2> 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 <T1, T2, T3> Func3<T1, T2, T3, Void> toFunc(final Action3<T1, T2, T3> 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 <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Void> toFunc(final Action4<T1, T2, T3, T4> 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 <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Void> toFunc(
-            final Action5<T1, T2, T3, T4, T5> 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 <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Void> toFunc(
-            final Action6<T1, T2, T3, T4, T5, T6> 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 <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Void> toFunc(
-            final Action7<T1, T2, T3, T4, T5, T6, T7> 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 <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7, T8, Void> toFunc(
-            final Action8<T1, T2, T3, T4, T5, T6, T7, T8> 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 <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, Void> toFunc(
-            final Action9<T1, T2, T3, T4, T5, T6, T7, T8, T9> 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<Void> 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 <R> Func0<R> toFunc(final Action0 action, final R result) {
-        return new Func0<R>() {
-            @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 <T1, R> Func1<T1, R> toFunc(final Action1<T1> action, final R result) {
-        return new Func1<T1, R>() {
-            @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 <T1, T2, R> Func2<T1, T2, R> toFunc(final Action2<T1, T2> action, final R result) {
-        return new Func2<T1, T2, R>() {
-            @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 <T1, T2, T3, R> Func3<T1, T2, T3, R> toFunc(final Action3<T1, T2, T3> action, final R result) {
-        return new Func3<T1, T2, T3, R>() {
-            @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 <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, R> toFunc(final Action4<T1, T2, T3, T4> action, final R result) {
-        return new Func4<T1, T2, T3, T4, R>() {
-            @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 <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, R> toFunc(
-            final Action5<T1, T2, T3, T4, T5> action, final R result) {
-        return new Func5<T1, T2, T3, T4, T5, R>() {
-            @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 <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, R> toFunc(
-            final Action6<T1, T2, T3, T4, T5, T6> action, final R result) {
-        return new Func6<T1, T2, T3, T4, T5, T6, R>() {
-            @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 <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7, R> toFunc(
-            final Action7<T1, T2, T3, T4, T5, T6, T7> action, final R result) {
-        return new Func7<T1, T2, T3, T4, T5, T6, T7, R>() {
-            @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 <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6, T7, T8, R> toFunc(
-            final Action8<T1, T2, T3, T4, T5, T6, T7, T8> action, final R result) {
-        return new Func8<T1, T2, T3, T4, T5, T6, T7, T8, R>() {
-            @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 <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> toFunc(
-            final Action9<T1, T2, T3, T4, T5, T6, T7, T8, T9> action, final R result) {
-        return new Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>() {
-            @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 <R> FuncN<R> toFunc(
-            final ActionN action, final R result) {
-        return new FuncN<R>() {
-            @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
deleted file mode 100644
index ef238acdc1..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func0.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func0<R> extends rx.functions.Func0<R>, 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
deleted file mode 100644
index 6f58689895..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func1.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func1<T1, R> extends rx.functions.Func1<T1, R>, 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
deleted file mode 100644
index ea2b5a2ee2..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func2.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func2<T1, T2, R> extends rx.functions.Func2<T1, T2, R>, 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
deleted file mode 100644
index 198cc8dfea..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func3.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func3<T1, T2, T3, R> extends rx.functions.Func3<T1, T2, T3, R>, 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
deleted file mode 100644
index a3f3bc6c45..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func4.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func4<T1, T2, T3, T4, R> extends rx.functions.Func4<T1, T2, T3, T4, R>, 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
deleted file mode 100644
index 8dd96ba9e3..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func5.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func5<T1, T2, T3, T4, T5, R> extends rx.functions.Func5<T1, T2, T3, T4, T5, R>, 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
deleted file mode 100644
index b049b12772..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func6.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func6<T1, T2, T3, T4, T5, T6, R> extends rx.functions.Func6<T1, T2, T3, T4, T5, T6, R>, 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
deleted file mode 100644
index c807188c5f..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func7.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func7<T1, T2, T3, T4, T5, T6, T7, R> extends rx.functions.Func7<T1, T2, T3, T4, T5, T6, T7, R>, 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
deleted file mode 100644
index bc3ca7afc6..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func8.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func8<T1, T2, T3, T4, T5, T6, T7, T8, R> extends rx.functions.Func8<T1, T2, T3, T4, T5, T6, T7, T8, R>, 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
deleted file mode 100644
index 51f18c43b1..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Func9.java
+++ /dev/null
@@ -1,23 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> extends rx.functions.Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R>, 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
deleted file mode 100644
index 144bdeb13b..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/FuncN.java
+++ /dev/null
@@ -1,24 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public interface FuncN<R> 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
deleted file mode 100644
index facacfd2ee..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Function.java
+++ /dev/null
@@ -1,24 +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.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
deleted file mode 100644
index a0a8f01130..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Functions.java
+++ /dev/null
@@ -1,365 +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.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 <R> FuncN<R> fromFunc(final Func0<? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, R> FuncN<R> fromFunc(final Func1<? super T0, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, R> FuncN<R> fromFunc(final Func2<? super T0, ? super T1, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, T2, R> FuncN<R> fromFunc(final Func3<? super T0, ? super T1, ? super T2, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, T2, T3, R> FuncN<R> fromFunc(final Func4<? super T0, ? super T1, ? super T2, ? super T3, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, T2, T3, T4, R> FuncN<R> fromFunc(final Func5<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, T2, T3, T4, T5, R> FuncN<R> fromFunc(final Func6<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, T2, T3, T4, T5, T6, R> FuncN<R> fromFunc(final Func7<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, T2, T3, T4, T5, T6, T7, R> FuncN<R> fromFunc(final Func8<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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 <T0, T1, T2, T3, T4, T5, T6, T7, T8, R> FuncN<R> fromFunc(final Func9<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> f) {
-        return new FuncN<R>() {
-
-            @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<Void> fromAction(final Action0 f) {
-        return new FuncN<Void>() {
-
-            @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 <T0> FuncN<Void> fromAction(final Action1<? super T0> f) {
-        return new FuncN<Void>() {
-
-            @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 <T0, T1> FuncN<Void> fromAction(final Action2<? super T0, ? super T1> f) {
-        return new FuncN<Void>() {
-
-            @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 <T0, T1, T2> FuncN<Void> fromAction(final Action3<? super T0, ? super T1, ? super T2> f) {
-        return new FuncN<Void>() {
-
-            @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 <T> Func1<T, Boolean> not(Func1<? super T, Boolean> predicate) {
-        return new Not<T>(predicate);
-    }
-
-    public static <T> Func1<? super T, Boolean> alwaysTrue() {
-        return AlwaysTrue.INSTANCE;
-    }
-
-    public static <T> Func1<? super T, Boolean> alwaysFalse() {
-        return AlwaysFalse.INSTANCE;
-    }
-
-    public static <T> Func1<T, T> identity() {
-        return new Func1<T, T>() {
-            @Override
-            public T call(T o) {
-                return o;
-            }
-        };
-    }
-
-    private enum AlwaysTrue implements Func1<Object, Boolean> {
-        INSTANCE;
-
-        @Override
-        public Boolean call(Object o) {
-            return true;
-        }
-    }
-
-    private enum AlwaysFalse implements Func1<Object, Boolean> {
-        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
deleted file mode 100644
index 5c2726c3fe..0000000000
--- a/rxjava-core/src/main/java/rx/util/functions/Not.java
+++ /dev/null
@@ -1,40 +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.functions;
-
-/**
- * @deprecated
- */
-@Deprecated
-public class Not<T> implements Func1<T, Boolean> {
-    private final Func1<? super T, Boolean> 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<? super T, Boolean> predicate) {
-        this.predicate = predicate;
-    }
-
-    @Override
-    public Boolean call(T param) {
-        return !predicate.call(param);
-    }
-}
\ No newline at end of file
diff --git a/rxjava-core/src/perf/java/rx/archive/composition/RangeMapTakeOnNextPerf.java b/rxjava-core/src/perf/java/rx/archive/composition/RangeMapTakeOnNextPerf.java
index 3ca90131a4..af756b9da2 100644
--- a/rxjava-core/src/perf/java/rx/archive/composition/RangeMapTakeOnNextPerf.java
+++ b/rxjava-core/src/perf/java/rx/archive/composition/RangeMapTakeOnNextPerf.java
@@ -3,8 +3,8 @@
 import rx.Observable;
 import rx.archive.perf.AbstractPerformanceTester;
 import rx.archive.perf.IntegerSumObserver;
-import rx.util.functions.Action0;
-import rx.util.functions.Func1;
+import rx.functions.Action0;
+import rx.functions.Func1;
 
 public class RangeMapTakeOnNextPerf extends AbstractPerformanceTester {
 
diff --git a/rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java b/rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java
index 84bce3b841..20e3c1ae61 100644
--- a/rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java
+++ b/rxjava-core/src/perf/java/rx/subjects/ReplaySubjectPerf.java
@@ -15,15 +15,16 @@
  */
 package rx.subjects;
 
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicLong;
+
 import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
 import org.openjdk.jmh.annotations.Param;
 import org.openjdk.jmh.annotations.Scope;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.logic.BlackHole;
-import rx.Observer;
 
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicLong;
+import rx.Observer;
 
 /**
  * Benchmarks the {@link ReplaySubject}.
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
index ea58175832..6bcaf9c6ba 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
@@ -15,19 +15,23 @@
  */
 package rx.operators;
 
+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 java.util.concurrent.TimeUnit;
+
 import org.junit.Test;
 import org.mockito.InOrder;
+
 import rx.Observable;
 import rx.Observer;
 import rx.operators.OperationSkipTest.CustomException;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-import java.util.concurrent.TimeUnit;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.*;
-
 public class OperatorSkipLastTimedTest {
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
index 3438665ea6..5cb0edb2e4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
@@ -6,7 +6,6 @@
 
 import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
index c751c6a17e..846340a88a 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -30,7 +30,6 @@
 import org.mockito.Mockito;
 
 import rx.Scheduler;
-import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Func1;
 
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index e4ec1e9fef..a1307a2713 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -29,7 +29,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
-import rx.util.functions.Func1;
+import rx.functions.Func1;
 
 public class BehaviorSubjectTest {
 
diff --git a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
index cbd7b8b90f..258ad98d26 100644
--- a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -314,7 +314,7 @@ public void testUnsubscriptionCase() {
             String v = "" + i;
             System.out.printf("Turn: %d%n", i);
             src.first()
-                .flatMap(new rx.util.functions.Func1<String, Observable<String>>() {
+                .flatMap(new Func1<String, Observable<String>>() {
 
                     @Override
                     public Observable<String> call(String t1) {

From e505cee3972180f6b39215995df595e8b968a70c Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Sat, 19 Apr 2014 22:26:13 -0700
Subject: [PATCH 241/422] Remove deprecated methods/classes from rxjava-core

Cleanup on path to 1.0: https://github.com/Netflix/RxJava/issues/1001#issuecomment-40888251
---
 .../src/main/clojure/rx/lang/clojure/core.clj |  14 +-
 .../clojure/rx/lang/clojure/core_test.clj     |  14 +-
 .../rx/lang/groovy/ObservableTests.groovy     |   2 +-
 .../main/scala/rx/lang/scala/Observable.scala |   4 +-
 .../src/main/java/rx/Notification.java        |  37 -
 rxjava-core/src/main/java/rx/Observable.java  | 672 +-------------
 .../rx/observers/SynchronizedObserver.java    |  84 --
 .../rx/observers/SynchronizedSubscriber.java  |  68 --
 .../rx/operators/BlockingOperatorLatest.java  |   2 +-
 .../java/rx/operators/OperationAverage.java   | 349 --------
 .../java/rx/operators/OperationGroupJoin.java |  10 +-
 .../main/java/rx/operators/OperationJoin.java |  10 +-
 .../java/rx/operators/OperationMinMax.java    | 147 ----
 .../rx/operators/OperationSequenceEqual.java  |   8 +-
 .../java/rx/operators/OperationSkipUntil.java |   4 +-
 .../main/java/rx/operators/OperationSum.java  |  89 --
 .../java/rx/operators/OperationSwitch.java    |   2 +-
 .../rx/operators/OperatorSynchronize.java     |  75 --
 .../main/java/rx/subjects/AsyncSubject.java   |   2 +-
 .../java/rx/subjects/BehaviorSubject.java     |  14 +-
 .../MultipleAssignmentSubscription.java       |  10 -
 .../subscriptions/RefCountSubscription.java   |   5 -
 .../rx/subscriptions/SerialSubscription.java  |  10 -
 .../OperatorSerializePerformance.java         |  15 -
 .../OperatorSynchronizePerformance.java       | 236 -----
 .../rx/operators/OperatorSerializePerf.java   |   5 -
 .../src/test/java/rx/ObservableTests.java     |   4 +-
 .../observers/SynchronizedObserverTest.java   | 821 ------------------
 .../rx/operators/OperationAverageTest.java    | 350 --------
 .../rx/operators/OperationGroupJoinTest.java  |   2 +-
 .../rx/operators/OperationMinMaxTest.java     | 360 --------
 .../java/rx/operators/OperationSumTest.java   | 352 --------
 .../rx/operators/OperatorSynchronizeTest.java | 692 ---------------
 .../test/java/rx/util/AssertObservable.java   |   2 +-
 34 files changed, 57 insertions(+), 4414 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
 delete mode 100644 rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationAverage.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationMinMax.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSum.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSynchronize.java
 delete mode 100644 rxjava-core/src/perf/java/rx/archive/operators/OperatorSynchronizePerformance.java
 delete mode 100644 rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationSumTest.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java

diff --git a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
index b89141dd26..9af3891494 100644
--- a/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
+++ b/language-adaptors/rxjava-clojure/src/main/clojure/rx/lang/clojure/core.clj
@@ -292,16 +292,14 @@
 ;################################################################################
 ; Operators
 
-(defn synchronize
-  "Synchronize execution.
+(defn serialize
+  "Serialize execution.
 
   See:
-    rx.Observable/synchronize
+    rx.Observable/serialize
   "
   ([^Observable xs]
-  (.synchronize xs))
-  ([lock ^Observable xs]
-  (.synchronize xs lock)))
+  (.serialize xs)))
 
 (defn merge*
   "Merge an Observable of Observables into a single Observable
@@ -472,10 +470,10 @@
   empty Observable if xs is empty.
 
   See:
-    rx.Observable/takeFirst
+    rx.Observable/take(1)
   "
   [^Observable xs]
-  (.takeFirst xs))
+  (.take xs 1))
 
 (defn ^Observable group-by
   "Returns an Observable of clojure.lang.MapEntry where the key is the result of
diff --git a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
index d77b184bd8..a4d842e32c 100644
--- a/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
+++ b/language-adaptors/rxjava-clojure/src/test/clojure/rx/lang/clojure/core_test.clj
@@ -96,20 +96,14 @@
                     (b/into []))]
     (is (= [2 4] result))))
 
-(deftest test-syncrhonize
-  ; I'm going to believe synchronize works and just exercise it
+(deftest test-serialize
+  ; I'm going to believe serialize works and just exercise it
   ; here for sanity.
   (is (= [1 2 3]
          (->> [1 2 3]
               (rx/seq->o)
-              (rx/synchronize)
-              (b/into []))))
-  (let [lock (Object.)]
-    (is (= [1 2 3]
-           (->> [1 2 3]
-                (rx/seq->o)
-                (rx/synchronize lock)
-                (b/into []))))))
+              (rx/serialize)
+              (b/into [])))))
 
 (let [expected-result [[1 3 5] [2 4 6]]
       sleepy-o        #(f/future-generator*
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 1bc87c0ee5..e459e14de4 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
@@ -322,7 +322,7 @@ def class ObservableTests {
         
         Observable.from("one", "two", "three", "four", "five", "six")
         .groupBy({String s -> s.length()})
-        .mapMany({
+        .flatMap({
             groupObservable ->
             
             return groupObservable.map({
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 977f333398..56171b4853 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
@@ -268,8 +268,8 @@ trait Observable[+T]
    * @return an Observable that is a chronologically well-behaved version of the source
    *         Observable, and that synchronously notifies its [[rx.lang.scala.Observer]]s
    */
-  def synchronize: Observable[T] = {
-    toScalaObservable[T](asJavaObservable.synchronize)
+  def serialize: Observable[T] = {
+    toScalaObservable[T](asJavaObservable.serialize)
   }
 
   /**
diff --git a/rxjava-core/src/main/java/rx/Notification.java b/rxjava-core/src/main/java/rx/Notification.java
index df3e22b3a2..2934eca77d 100644
--- a/rxjava-core/src/main/java/rx/Notification.java
+++ b/rxjava-core/src/main/java/rx/Notification.java
@@ -52,43 +52,6 @@ private Notification(Kind kind, T value, Throwable e) {
         this.kind = kind;
     }
 
-    /**
-     * A constructor used to represent an onNext notification.
-     * 
-     * @param value
-     *            The data passed to the onNext method.
-     */
-    @Deprecated
-    public Notification(T value) {
-        this.value = value;
-        this.throwable = null;
-        this.kind = Kind.OnNext;
-    }
-
-    /**
-     * A constructor used to represent an onError notification.
-     * 
-     * @param exception
-     *            The exception passed to the onError notification.
-     * @deprecated Because type Throwable can't disambiguate the constructors if both onNext and onError are type "Throwable"
-     */
-    @Deprecated
-    public Notification(Throwable exception) {
-        this.throwable = exception;
-        this.value = null;
-        this.kind = Kind.OnError;
-    }
-
-    /**
-     * A constructor used to represent an onCompleted notification.
-     */
-    @Deprecated
-    public Notification() {
-        this.throwable = null;
-        this.value = null;
-        this.kind = Kind.OnCompleted;
-    }
-
     /**
      * Retrieves the exception associated with an onError notification.
      * 
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index fa31251247..297d715318 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -17,7 +17,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -52,7 +51,6 @@
 import rx.operators.OperationAll;
 import rx.operators.OperationAny;
 import rx.operators.OperationAsObservable;
-import rx.operators.OperationAverage;
 import rx.operators.OperationBuffer;
 import rx.operators.OperationCombineLatest;
 import rx.operators.OperationConcat;
@@ -71,7 +69,6 @@
 import rx.operators.OperationJoin;
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
-import rx.operators.OperationMinMax;
 import rx.operators.OperationMulticast;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
@@ -82,7 +79,6 @@
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSkip;
 import rx.operators.OperationSkipUntil;
-import rx.operators.OperationSum;
 import rx.operators.OperationSwitch;
 import rx.operators.OperationTakeLast;
 import rx.operators.OperationTakeTimed;
@@ -121,7 +117,6 @@
 import rx.operators.OperatorSkipLastTimed;
 import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
-import rx.operators.OperatorSynchronize;
 import rx.operators.OperatorTake;
 import rx.operators.OperatorTimeout;
 import rx.operators.OperatorTimeoutWithSelector;
@@ -238,8 +233,9 @@ public void call(Subscriber<? super T> observer) {
     }
 
     /**
-     * 
+     * @deprecated use {@link #OnSubscribe}
      */
+    @Deprecated
     public static interface OnSubscribeFunc<T> extends Function {
 
         public Subscription onSubscribe(Observer<? super T> op);
@@ -500,84 +496,6 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
         return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
     }
 
-    /**
-     * @deprecated use {@link #averageInteger}
-     */
-    @Deprecated
-    public final static Observable<Integer> average(Observable<Integer> source) {
-        return OperationAverage.average(source);
-    }
-
-    /**
-     * Returns an Observable that emits the average of the Doubles emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Double> averageDouble(Observable<Double> source) {
-        return OperationAverage.averageDoubles(source);
-    }
-
-    /**
-     * Returns an Observable that emits the average of the Floats emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Float> averageFloat(Observable<Float> source) {
-        return OperationAverage.averageFloats(source);
-    }
-
-    /**
-     * Returns an Observable that emits the average of the Integers emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
-     * 
-     * @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
-     * @throws IllegalArgumentException
-     *             if the source Observable emits no items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Integer> averageInteger(Observable<Integer> source) {
-        return OperationAverage.average(source);
-    }
-
-    /**
-     * Returns an Observable that emits the average of the Longs emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Long> averageLong(Observable<Long> source) {
-        return OperationAverage.averageLongs(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
@@ -1269,6 +1187,7 @@ public final static <T> Observable<T> from(Iterable<? extends T> iterable, Sched
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      */
     // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> from(T t1) {
         return from(Arrays.asList(t1));
     }
@@ -1286,10 +1205,9 @@ public final static <T> Observable<T> from(T t1) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> from(T t1, T t2) {
         return from(Arrays.asList(t1, t2));
     }
@@ -1309,10 +1227,9 @@ public final static <T> Observable<T> from(T t1, T t2) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> from(T t1, T t2, T t3) {
         return from(Arrays.asList(t1, t2, t3));
     }
@@ -1334,10 +1251,9 @@ public final static <T> Observable<T> from(T t1, T t2, T t3) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> from(T t1, T t2, T t3, T t4) {
         return from(Arrays.asList(t1, t2, t3, t4));
     }
@@ -1361,10 +1277,9 @@ public final static <T> Observable<T> from(T t1, T t2, T t3, T t4) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5) {
         return from(Arrays.asList(t1, t2, t3, t4, t5));
     }
@@ -1390,10 +1305,9 @@ public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5) {
      *            the type of these items
      * @return an Observable that emits each item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6) {
         return from(Arrays.asList(t1, t2, t3, t4, t5, t6));
     }
@@ -1421,10 +1335,9 @@ public final static <T> Observable<T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> 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));
     }
@@ -1454,10 +1367,9 @@ public final static <T> Observable<T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> 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));
     }
@@ -1489,10 +1401,9 @@ public final static <T> Observable<T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> 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));
     }
@@ -1527,10 +1438,9 @@ public final static <T> Observable<T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @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
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> 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));
     }
@@ -1547,7 +1457,6 @@ public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6, T
      * @return an Observable that emits each item in the source Array
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      */
-    //    @SafeVarargs // commenting out until we figure out if we can do Java7 compilation without breaking Android for just this feature
     public final static <T> Observable<T> from(T... t1) {
         return from(Arrays.asList(t1));
     }
@@ -1656,33 +1565,11 @@ public void call(Subscriber<? super T> s) {
      * @return an Observable that emits {@code value} as a single item and then completes, on a specified
      *         Scheduler
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-just">RxJava Wiki: just()</a>
-     * @deprecated use {@link #from(T)}
      */
-    @Deprecated
     public final static <T> Observable<T> just(T value, Scheduler scheduler) {
         return just(value).subscribeOn(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/max.png">
-     * 
-     * @param source
-     *            an Observable to scan for the maximum emitted item
-     * @return an Observable that emits this maximum item
-     * @throws IllegalArgumentException
-     *             if the source is empty
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211837.aspx">MSDN: Observable.Max</a>
-     * @deprecated use rxjava-math module instead
-     */
-    public final static <T extends Comparable<? super T>> Observable<T> max(Observable<T> source) {
-        return OperationMinMax.max(source);
-    }
-
     /**
      * Flattens an Iterable of Observables into one Observable, without any transformation.
      * <p>
@@ -1834,6 +1721,7 @@ public final static <T> Observable<T> merge(Observable<? extends Observable<? ex
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2) {
         return merge(from(Arrays.asList(t1, t2)));
     }
@@ -1856,6 +1744,7 @@ public final static <T> Observable<T> merge(Observable<? extends T> t1, Observab
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
         return merge(from(Arrays.asList(t1, t2, t3)));
     }
@@ -1880,6 +1769,7 @@ public final static <T> Observable<T> merge(Observable<? extends T> t1, Observab
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
         return merge(from(Arrays.asList(t1, t2, t3, t4)));
     }
@@ -1906,6 +1796,7 @@ public final static <T> Observable<T> merge(Observable<? extends T> t1, Observab
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
         return merge(from(Arrays.asList(t1, t2, t3, t4, t5)));
     }
@@ -1934,6 +1825,7 @@ public final static <T> Observable<T> merge(Observable<? extends T> t1, Observab
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
         return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6)));
     }
@@ -1964,6 +1856,7 @@ public final static <T> Observable<T> merge(Observable<? extends T> t1, Observab
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
         return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7)));
     }
@@ -1997,6 +1890,7 @@ public final static <T> Observable<T> merge(Observable<? extends T> t1, Observab
      * @return an Observable that emits all of the items emitted by the source Observables
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
         return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8)));
     }
@@ -2031,7 +1925,7 @@ public final static <T> Observable<T> merge(Observable<? extends T> t1, Observab
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    // suppress because the types are checked by the method signature before using a vararg
+    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
         return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9)));
     }
@@ -2372,24 +2266,6 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
         return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }
 
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/min.png">
-     * 
-     * @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 <a href="http://msdn.microsoft.com/en-us/library/hh229715.aspx">MSDN: Observable.Min</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static <T extends Comparable<? super T>> Observable<T> min(Observable<T> source) {
-        return OperationMinMax.min(source);
-    }
-
     /**
      * Convert the current {@code Observable<T>} into an {@code Observable<Observable<T>>}.
      * <p>
@@ -2591,117 +2467,6 @@ public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T
         return OperationSequenceEqual.sequenceEqual(first, second, equality);
     }
 
-    /**
-     * Returns an Observable that emits the sum of all the Doubles emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
-     * 
-     * @param source
-     *            the source Observable to compute the sum of
-     * @return an Observable that emits a single item: the sum of all the Doubles emitted by the source
-     *         Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Double> sumDouble(Observable<Double> source) {
-        return OperationSum.sumDoubles(source);
-    }
-
-    /**
-     * Returns an Observable that emits the sum of all the Floats emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Float> sumFloat(Observable<Float> source) {
-        return OperationSum.sumFloats(source);
-    }
-
-    /**
-     * Returns an Observable that emits the sum of all the Integers emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Integer> sumInteger(Observable<Integer> source) {
-        return OperationSum.sumIntegers(source);
-    }
-
-    /**
-     * Returns an Observable that emits the sum of all the Longs emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.png">
-     * 
-     * @param source
-     *            source Observable to compute the sum of
-     * @return an Observable that emits a single item: the sum of all the Longs emitted by the
-     *         source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final static Observable<Long> sumLong(Observable<Long> source) {
-        return OperationSum.sumLongs(source);
-    }
-
-    /**
-     * Given an Observable that emits Observables, returns an Observable that emits the items emitted by the
-     * most recently emitted of those Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchDo.png">
-     * <p> {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-switchonnext">RxJava Wiki: switchOnNext()</a>
-     * @deprecated use {@link #switchOnNext}
-     */
-    @Deprecated
-    public final static <T> Observable<T> switchDo(Observable<? extends Observable<? extends T>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchLatest.png">
-     * <p> {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-switchonnext">RxJava Wiki: switchOnNext()</a>
-     * @see #switchOnNext(Observable)
-     */
-    public final static <T> Observable<T> switchLatest(Observable<? extends Observable<? extends T>> 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.
@@ -2722,14 +2487,6 @@ public final static <T> Observable<T> switchOnNext(Observable<? extends Observab
         return create(OperationSwitch.switchDo(sequenceOfSequences));
     }
 
-    /**
-     * @deprecated use {@link #synchronize()} or {@link #synchronize(Object)}
-     */
-    @Deprecated
-    public final static <T> Observable<T> synchronize(Observable<T> source) {
-        return source.synchronize();
-    }
-
     /**
      * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after
      * each {@code period} of time thereafter.
@@ -3171,34 +2928,6 @@ public final static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Ob
         return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8, o9 }).lift(new OperatorZip<R>(zipFunction));
     }
 
-    /**
-     * Synonymous with {@code reduce()}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/aggregate.png">
-     * 
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-reduce">RxJava Wiki: reduce()</a>
-     * @see #reduce(Func2)
-     * @deprecated use {@link #reduce(Func2)}
-     */
-    @Deprecated
-    public final Observable<T> aggregate(Func2<T, T, T> accumulator) {
-        return reduce(accumulator);
-    }
-
-    /**
-     * Synonymous with {@code reduce()}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/aggregateSeed.png">
-     * 
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-reduce">RxJava Wiki: reduce()</a>
-     * @see #reduce(Object, Func2)
-     * @deprecated use {@link #reduce(Object, Func2)}
-     */
-    @Deprecated
-    public final <R> Observable<R> aggregate(R initialValue, Func2<R, ? super T, R> accumulator) {
-        return reduce(initialValue, accumulator);
-    }
-
     /**
      * Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source
      * Observable satisfy a condition.
@@ -3226,78 +2955,6 @@ public final Observable<T> asObservable() {
         return create(new OperationAsObservable<T>(this));
     }
 
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageDouble()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtractor) {
-        return create(new OperationAverage.AverageDoubleExtractor<T>(this, valueExtractor));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageFloat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtractor) {
-        return create(new OperationAverage.AverageFloatExtractor<T>(this, valueExtractor));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageInteger()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueExtractor) {
-        return create(new OperationAverage.AverageIntegerExtractor<T>(this, valueExtractor));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/average.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-averageinteger-averagelong-averagefloat-and-averagedouble">RxJava Wiki: averageLong()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor) {
-        return create(new OperationAverage.AverageLongExtractor<T>(this, 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
@@ -4607,30 +4264,6 @@ public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
         return lift(new OperatorMap<T, R>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mapMany.png">
-     * <p>
-     * <em>Note:</em> {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-mapmany-or-flatmap-and-mapmanydelayerror">RxJava Wiki: mapMany()</a>
-     * @see #flatMap(Func1)
-     * @deprecated use {@link #flatMap(Func1)}
-     */
-    @Deprecated
-    public final <R> Observable<R> mapMany(Func1<? super T, ? extends Observable<R>> 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.
@@ -4646,64 +4279,6 @@ public final Observable<Notification<T>> materialize() {
         return lift(new OperatorMaterialize<T>());
     }
 
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/max.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-max">RxJava Wiki: max()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211635.aspx">MSDN: Observable.Max</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<T> max(Comparator<? super T> comparator) {
-        return OperationMinMax.max(this, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/maxBy.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-maxby">RxJava Wiki: maxBy()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229058.aspx">MSDN: Observable.MaxBy</a>
-     */
-    public final <R extends Comparable<? super R>> Observable<List<T>> maxBy(Func1<T, R> selector) {
-        return OperationMinMax.maxBy(this, selector);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/maxBy.png">
-     * 
-     * @param selector
-     *            this function accepts an item emitted by the source Observable and returns a key
-     * @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
-     *         largest key value of all of the emitted items according to the specified comparator
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-maxby">RxJava Wiki: maxBy()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244330.aspx">MSDN: Observable.MaxBy</a>
-     */
-    public final <R> Observable<List<T>> maxBy(Func1<T, R> selector, Comparator<? super R> comparator) {
-        return OperationMinMax.maxBy(this, selector, comparator);
-    }
-
     /**
      * Returns an Observable that emits the results of applying a specified function to each item emitted by the
      * source Observable, where that function returns an Observable, and then merging those resulting
@@ -4815,64 +4390,6 @@ public final <U, R> Observable<R> mergeMapIterable(Func1<? super T, ? extends It
         return mergeMap(OperationFlatMap.flatMapIterableFunc(collectionSelector), resultSelector);
     }
 
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/min.png">
-     * 
-     * @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
-     * @throws IllegalArgumentException
-     *             if the source is empty
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-min">RxJava Wiki: min()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229095.aspx">MSDN: Observable.Min</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<T> min(Comparator<? super T> comparator) {
-        return OperationMinMax.min(this, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/minBy.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-minby">RxJava Wiki: minBy()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228970.aspx">MSDN: Observable.MinBy</a>
-     */
-    public final <R extends Comparable<? super R>> Observable<List<T>> minBy(Func1<T, R> selector) {
-        return OperationMinMax.minBy(this, selector);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/minBy.png">
-     * 
-     * @param selector
-     *            the key selector function
-     * @param comparator
-     *            the comparator used to compare key values
-     * @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 according to the specified
-     *         comparator
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-minby">RxJava Wiki: minBy()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228970.aspx">MSDN: Observable.MinBy</a>
-     */
-    public final <R> Observable<List<T>> minBy(Func1<T, R> selector, Comparator<? super R> comparator) {
-        return OperationMinMax.minBy(this, selector, comparator);
-    }
-
     /**
      * Returns an Observable that emits items produced by multicasting the source Observable within a selector
      * function.
@@ -6838,78 +6355,6 @@ public final Observable<T> subscribeOn(Scheduler scheduler) {
         return nest().lift(new OperatorSubscribeOn<T>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumDouble()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtractor) {
-        return OperationSum.sumAtLeastOneDoubles(map(valueExtractor));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumFloat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor) {
-        return OperationSum.sumAtLeastOneFloats(map(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumInteger()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtractor) {
-        return OperationSum.sumAtLeastOneIntegers(map(valueExtractor));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sum.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-suminteger-sumlong-sumfloat-and-sumdouble">RxJava Wiki: sumLong()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
-     * @deprecated Use rxjava-math module instead
-     */
-    public final Observable<Long> sumLong(Func1<? super T, Long> valueExtractor) {
-        return OperationSum.sumAtLeastOneLongs(map(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
@@ -6926,48 +6371,6 @@ public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<?
         return switchOnNext(map(func));
     }
 
-    /**
-     * Wraps the source Observable in another Observable that ensures that the resulting Observable is
-     * chronologically well-behaved.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/synchronize.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-synchronize">RxJava Wiki: synchronize()</a>
-     * @deprecated Use {@link #serialize()} instead as it doesn't block threads while emitting notification.
-     */
-    public final Observable<T> synchronize() {
-        return lift(new OperatorSynchronize<T>());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/synchronize.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-synchronize">RxJava Wiki: synchronize()</a>
-     * @deprecated Use {@link #serialize()} instead as it doesn't block threads while emitting notification.
-     */
-    public final Observable<T> synchronize(Object lock) {
-        return lift(new OperatorSynchronize<T>(lock));
-    }
-
     /**
      * Returns an Observable that emits only the first {@code num} items emitted by the source Observable.
      * <p>
@@ -7023,22 +6426,6 @@ public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler) {
         return create(new OperationTakeTimed.TakeTimed<T>(this, time, unit, scheduler));
     }
 
-    /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeFirst.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see "MSDN: Observable.firstAsync()"
-     * @deprecated use {@code take(1)} directly
-     */
-    @Deprecated
-    public final Observable<T> takeFirst() {
-        return take(1);
-    }
-
     /**
      * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
      * a specified condition.
@@ -7936,25 +7323,6 @@ public final Observable<T> unsubscribeOn(Scheduler scheduler) {
         return lift(new OperatorUnsubscribeOn<T>(scheduler));
     }
 
-    /**
-     * Returns an Observable that represents a filtered version of the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/where.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-filter-or-where">RxJava Wiki: where()</a>
-     * @see #filter(Func1)
-     * @deprecated use {@link #filter(Func1)}
-     */
-    @Deprecated
-    public final Observable<T> where(Func1<? super T, Boolean> predicate) {
-        return filter(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
diff --git a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java b/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
deleted file mode 100644
index dbcbb9bc35..0000000000
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedObserver.java
+++ /dev/null
@@ -1,84 +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.observers;
-
-import rx.Observer;
-
-/**
- * Synchronize execution to be single-threaded.
- * <p>
- * This ONLY does synchronization. It does not involve itself in safety or subscriptions. See SafeSubscriber for that.
- * 
- * @param <T>
- * @deprecated Use SerializedObserver instead as it doesn't block threads during event notification.
- */
-@Deprecated
-public final class SynchronizedObserver<T> implements Observer<T> {
-
-    /**
-     * Intrinsic synchronized locking with double-check short-circuiting was chosen after testing several other implementations.
-     * 
-     * The code and results can be found here:
-     * - https://github.com/benjchristensen/JavaLockPerformanceTests/tree/master/results/Observer
-     * - https://github.com/benjchristensen/JavaLockPerformanceTests/tree/master/src/com/benjchristensen/performance/locks/Observer
-     * 
-     * The major characteristic that made me choose synchronized instead of Reentrant or a customer AbstractQueueSynchronizer implementation
-     * is that intrinsic locking performed better when nested, and AtomicObserver will end up nested most of the time since Rx is
-     * compositional by its very nature.
-     * 
-     * // TODO composing of this class should rarely happen now with updated design so this decision should be revisited
-     */
-
-    private final Observer<? super T> observer;
-    private final Object lock;
-    private boolean isTerminated = false;
-
-    public SynchronizedObserver(Observer<? super T> subscriber) {
-        this.observer = subscriber;
-        this.lock = this;
-    }
-
-    public SynchronizedObserver(Observer<? super T> subscriber, Object lock) {
-        this.observer = subscriber;
-        this.lock = lock;
-    }
-
-    public void onNext(T arg) {
-        synchronized (lock) {
-            if (!isTerminated) {
-                observer.onNext(arg);
-            }
-        }
-    }
-
-    public void onError(Throwable e) {
-        synchronized (lock) {
-            if (!isTerminated) {
-                isTerminated = true;
-                observer.onError(e);
-            }
-        }
-    }
-
-    public void onCompleted() {
-        synchronized (lock) {
-            if (!isTerminated) {
-                isTerminated = true;
-                observer.onCompleted();
-            }
-        }
-    }
-}
\ 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
deleted file mode 100644
index 9f1b3dec90..0000000000
--- a/rxjava-core/src/main/java/rx/observers/SynchronizedSubscriber.java
+++ /dev/null
@@ -1,68 +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.observers;
-
-import rx.Observer;
-import rx.Subscriber;
-
-/**
- * A thread-safe Observer for transitioning states in operators.
- * <p>
- * Execution rules are:
- * <ul>
- * <li>Allow only single-threaded, synchronous, ordered execution of onNext, onCompleted, onError</li>
- * <li>Once an onComplete or onError are performed, no further calls can be executed</li>
- * <li>If unsubscribe is called, this means we call completed() and don't allow any further onNext calls.</li>
- * </ul>
- * 
- * @param <T>
- * @deprecated Use SerializedSubscriber instead as it doesn't block threads during event notification.
- */
-@Deprecated
-public final class SynchronizedSubscriber<T> extends Subscriber<T> {
-
-    private final Observer<? super T> observer;
-
-    public SynchronizedSubscriber(Subscriber<? super T> subscriber, Object lock) {
-        super(subscriber);
-        this.observer = new SynchronizedObserver<T>(subscriber, lock);
-    }
-
-    /**
-     * Used when synchronizing an Subscriber without access to the subscription.
-     * 
-     * @param subscriber
-     */
-    public SynchronizedSubscriber(Subscriber<? super T> subscriber) {
-        this(subscriber, new Object());
-    }
-
-    @Override
-    public void onCompleted() {
-        observer.onCompleted();
-    }
-
-    @Override
-    public void onError(Throwable e) {
-        observer.onError(e);
-    }
-
-    @Override
-    public void onNext(T t) {
-        observer.onNext(t);
-    }
-
-}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/BlockingOperatorLatest.java b/rxjava-core/src/main/java/rx/operators/BlockingOperatorLatest.java
index 5b98cfa269..0c16bb399e 100644
--- a/rxjava-core/src/main/java/rx/operators/BlockingOperatorLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/BlockingOperatorLatest.java
@@ -85,7 +85,7 @@ public boolean hasNext() {
                         notify.acquire();
                     } catch (InterruptedException ex) {
                         Thread.currentThread().interrupt();
-                        iNotif = new Notification<T>(ex);
+                        iNotif = Notification.createOnError(ex);
                         throw Exceptions.propagate(ex);
                     }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAverage.java b/rxjava-core/src/main/java/rx/operators/OperationAverage.java
deleted file mode 100644
index 0b9c5e14e9..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationAverage.java
+++ /dev/null
@@ -1,349 +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.Subscriber;
-import rx.Subscription;
-import rx.functions.Func1;
-import rx.functions.Func2;
-
-/**
- * A few operators for implementing the averaging operation.
- * 
- * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average%28v=vs.103%29.aspx">MSDN: Observable.Average</a>
- */
-public final class OperationAverage {
-    private static final class Tuple2<T> {
-        private final T current;
-        private final Integer count;
-
-        private Tuple2(T v1, Integer v2) {
-            current = v1;
-            count = v2;
-        }
-    }
-
-    public static Observable<Integer> average(Observable<Integer> source) {
-        return source.reduce(new Tuple2<Integer>(0, 0), new Func2<Tuple2<Integer>, Integer, Tuple2<Integer>>() {
-            @Override
-            public Tuple2<Integer> call(Tuple2<Integer> accu, Integer next) {
-                return new Tuple2<Integer>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Integer>, Integer>() {
-            @Override
-            public Integer call(Tuple2<Integer> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    public static Observable<Long> averageLongs(Observable<Long> source) {
-        return source.reduce(new Tuple2<Long>(0L, 0), new Func2<Tuple2<Long>, Long, Tuple2<Long>>() {
-            @Override
-            public Tuple2<Long> call(Tuple2<Long> accu, Long next) {
-                return new Tuple2<Long>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Long>, Long>() {
-            @Override
-            public Long call(Tuple2<Long> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    public static Observable<Float> averageFloats(Observable<Float> source) {
-        return source.reduce(new Tuple2<Float>(0.0f, 0), new Func2<Tuple2<Float>, Float, Tuple2<Float>>() {
-            @Override
-            public Tuple2<Float> call(Tuple2<Float> accu, Float next) {
-                return new Tuple2<Float>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Float>, Float>() {
-            @Override
-            public Float call(Tuple2<Float> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    public static Observable<Double> averageDoubles(Observable<Double> source) {
-        return source.reduce(new Tuple2<Double>(0.0d, 0), new Func2<Tuple2<Double>, Double, Tuple2<Double>>() {
-            @Override
-            public Tuple2<Double> call(Tuple2<Double> accu, Double next) {
-                return new Tuple2<Double>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Double>, Double>() {
-            @Override
-            public Double call(Tuple2<Double> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    /**
-     * Compute the average by extracting integer values from the source via an
-     * extractor function.
-     * 
-     * @param <T>
-     *            the source value type
-     */
-    public static final class AverageIntegerExtractor<T> implements OnSubscribeFunc<Integer> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Integer> valueExtractor;
-
-        public AverageIntegerExtractor(Observable<? extends T> source, Func1<? super T, Integer> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Integer> t1) {
-            return source.unsafeSubscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver extends Subscriber<T> {
-            final Observer<? super Integer> observer;
-            int sum;
-            int count;
-
-            public AverageObserver(Observer<? super Integer> 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 <T>
-     *            the source value type
-     */
-    public static final class AverageLongExtractor<T> implements OnSubscribeFunc<Long> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Long> valueExtractor;
-
-        public AverageLongExtractor(Observable<? extends T> source, Func1<? super T, Long> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Long> t1) {
-            return source.unsafeSubscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver extends Subscriber<T> {
-            final Observer<? super Long> observer;
-            long sum;
-            int count;
-
-            public AverageObserver(Observer<? super Long> 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 <T>
-     *            the source value type
-     */
-    public static final class AverageFloatExtractor<T> implements OnSubscribeFunc<Float> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Float> valueExtractor;
-
-        public AverageFloatExtractor(Observable<? extends T> source, Func1<? super T, Float> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Float> t1) {
-            return source.unsafeSubscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver extends Subscriber<T> {
-            final Observer<? super Float> observer;
-            float sum;
-            int count;
-
-            public AverageObserver(Observer<? super Float> 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 <T>
-     *            the source value type
-     */
-    public static final class AverageDoubleExtractor<T> implements OnSubscribeFunc<Double> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Double> valueExtractor;
-
-        public AverageDoubleExtractor(Observable<? extends T> source, Func1<? super T, Double> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Double> t1) {
-            return source.unsafeSubscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver extends Subscriber<T> {
-            final Observer<? super Double> observer;
-            double sum;
-            int count;
-
-            public AverageObserver(Observer<? super Double> 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/OperationGroupJoin.java b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
index adf69e3deb..0abd6e12dd 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
@@ -91,8 +91,8 @@ public void init() {
             group.add(s1);
             group.add(s2);
 
-            s1.setSubscription(left.unsafeSubscribe(new LeftObserver(s1)));
-            s2.setSubscription(right.unsafeSubscribe(new RightObserver(s2)));
+            s1.set(left.unsafeSubscribe(new LeftObserver(s1)));
+            s2.set(right.unsafeSubscribe(new RightObserver(s2)));
 
         }
 
@@ -139,7 +139,7 @@ public void onNext(T1 args) {
 
                     SerialSubscription sduration = new SerialSubscription();
                     group.add(sduration);
-                    sduration.setSubscription(duration.unsafeSubscribe(new LeftDurationObserver(id, sduration, subj)));
+                    sduration.set(duration.unsafeSubscribe(new LeftDurationObserver(id, sduration, subj)));
 
                     R result = resultSelector.call(args, window);
 
@@ -200,7 +200,7 @@ public void onNext(T2 args) {
 
                     SerialSubscription sduration = new SerialSubscription();
                     group.add(sduration);
-                    sduration.setSubscription(duration.unsafeSubscribe(new RightDurationObserver(id, sduration)));
+                    sduration.set(duration.unsafeSubscribe(new RightDurationObserver(id, sduration)));
 
                     synchronized (guard) {
                         for (Observer<T2> o : leftMap.values()) {
@@ -325,7 +325,7 @@ public WindowObservableFunc(Observable<T> underlying, RefCountSubscription refCo
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
             CompositeSubscription cs = new CompositeSubscription();
-            cs.add(refCount.getSubscription());
+            cs.add(refCount.get());
             WindowObserver wo = new WindowObserver(t1, cs);
             cs.add(underlying.unsafeSubscribe(wo));
             return cs;
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
index 779d8716d0..21f667bbe3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
@@ -55,7 +55,7 @@ public OperationJoin(
     public Subscription onSubscribe(Observer<? super R> t1) {
         SerialSubscription cancel = new SerialSubscription();
         ResultSink result = new ResultSink(t1, cancel);
-        cancel.setSubscription(result.run());
+        cancel.set(result.run());
         return cancel;
     }
 
@@ -84,8 +84,8 @@ public Subscription run() {
             group.add(leftCancel);
             group.add(rightCancel);
 
-            leftCancel.setSubscription(left.unsafeSubscribe(new LeftObserver(leftCancel)));
-            rightCancel.setSubscription(right.unsafeSubscribe(new RightObserver(rightCancel)));
+            leftCancel.set(left.unsafeSubscribe(new LeftObserver(leftCancel)));
+            rightCancel.set(right.unsafeSubscribe(new RightObserver(rightCancel)));
 
             return group;
         }
@@ -129,7 +129,7 @@ public void onNext(TLeft args) {
                     return;
                 }
 
-                md.setSubscription(duration.unsafeSubscribe(new LeftDurationObserver(id, md)));
+                md.set(duration.unsafeSubscribe(new LeftDurationObserver(id, md)));
 
                 synchronized (gate) {
                     for (Map.Entry<Integer, TRight> entry : rightMap.entrySet()) {
@@ -236,7 +236,7 @@ public void onNext(TRight args) {
                     return;
                 }
 
-                md.setSubscription(duration.unsafeSubscribe(new RightDurationObserver(id, md)));
+                md.set(duration.unsafeSubscribe(new RightDurationObserver(id, md)));
 
                 synchronized (gate) {
                     for (Map.Entry<Integer, TLeft> entry : leftMap.entrySet()) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
deleted file mode 100644
index b6490e9ef9..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationMinMax.java
+++ /dev/null
@@ -1,147 +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.Comparator;
-import java.util.List;
-
-import rx.Observable;
-import rx.functions.Func1;
-import rx.functions.Func2;
-
-/**
- * Returns the minimum element in an observable sequence.
- */
-public class OperationMinMax {
-
-    public static <T extends Comparable<? super T>> Observable<T> min(
-            Observable<T> source) {
-        return minMax(source, -1L);
-    }
-
-    public static <T> Observable<T> min(Observable<T> source,
-            final Comparator<? super T> comparator) {
-        return minMax(source, comparator, -1L);
-    }
-
-    public static <T, R extends Comparable<? super R>> Observable<List<T>> minBy(
-            Observable<T> source, final Func1<T, R> selector) {
-        return minMaxBy(source, selector, -1L);
-    }
-
-    public static <T, R> Observable<List<T>> minBy(Observable<T> source,
-            final Func1<T, R> selector, final Comparator<? super R> comparator) {
-        return minMaxBy(source, selector, comparator, -1L);
-    }
-
-    public static <T extends Comparable<? super T>> Observable<T> max(
-            Observable<T> source) {
-        return minMax(source, 1L);
-    }
-
-    public static <T> Observable<T> max(Observable<T> source,
-            final Comparator<? super T> comparator) {
-        return minMax(source, comparator, 1L);
-    }
-
-    public static <T, R extends Comparable<? super R>> Observable<List<T>> maxBy(
-            Observable<T> source, final Func1<T, R> selector) {
-        return minMaxBy(source, selector, 1L);
-    }
-
-    public static <T, R> Observable<List<T>> maxBy(Observable<T> source,
-            final Func1<T, R> selector, final Comparator<? super R> comparator) {
-        return minMaxBy(source, selector, comparator, 1L);
-    }
-
-    private static <T extends Comparable<? super T>> Observable<T> minMax(
-            Observable<T> source, final long flag) {
-        return source.reduce(new Func2<T, T, T>() {
-            @Override
-            public T call(T acc, T value) {
-                if (flag * acc.compareTo(value) > 0) {
-                    return acc;
-                }
-                return value;
-            }
-        });
-    }
-
-    private static <T> Observable<T> minMax(Observable<T> source,
-            final Comparator<? super T> comparator, final long flag) {
-        return source.reduce(new Func2<T, T, T>() {
-            @Override
-            public T call(T acc, T value) {
-                if (flag * comparator.compare(acc, value) > 0) {
-                    return acc;
-                }
-                return value;
-            }
-        });
-    }
-
-    private static <T, R extends Comparable<? super R>> Observable<List<T>> minMaxBy(
-            Observable<T> source, final Func1<T, R> selector, final long flag) {
-        return source.reduce(new ArrayList<T>(),
-                new Func2<List<T>, T, List<T>>() {
-
-                    @Override
-                    public List<T> call(List<T> acc, T value) {
-                        if (acc.isEmpty()) {
-                            acc.add(value);
-                        } else {
-                            int compareResult = selector.call(acc.get(0))
-                                    .compareTo(selector.call(value));
-                            if (compareResult == 0) {
-                                acc.add(value);
-                            } else if (flag * compareResult < 0) {
-                                acc.clear();
-                                acc.add(value);
-                            }
-                        }
-                        return acc;
-                    }
-                });
-    }
-
-    private static <T, R> Observable<List<T>> minMaxBy(Observable<T> source,
-            final Func1<T, R> selector, final Comparator<? super R> comparator,
-            final long flag) {
-        return source.reduce(new ArrayList<T>(),
-                new Func2<List<T>, T, List<T>>() {
-
-                    @Override
-                    public List<T> call(List<T> acc, T value) {
-                        if (acc.isEmpty()) {
-                            acc.add(value);
-                        } else {
-                            int compareResult = comparator.compare(
-                                    selector.call(acc.get(0)),
-                                    selector.call(value));
-                            if (compareResult == 0) {
-                                acc.add(value);
-                            } else if (flag * compareResult < 0) {
-                                acc.clear();
-                                acc.add(value);
-                            }
-                        }
-                        return acc;
-                    }
-                });
-    }
-
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
index 22e42ff34a..9d9792edfb 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
@@ -38,20 +38,20 @@ public static <T> Observable<Boolean> sequenceEqual(
 
                     @Override
                     public Notification<T> call(T t1) {
-                        return new Notification<T>(t1);
+                        return Notification.createOnNext(t1);
                     }
 
-                }), from(new Notification<T>()));
+                }), from(Notification.<T>createOnCompleted()));
 
         Observable<Notification<T>> secondObservable = concat(
                 second.map(new Func1<T, Notification<T>>() {
 
                     @Override
                     public Notification<T> call(T t1) {
-                        return new Notification<T>(t1);
+                        return Notification.createOnNext(t1);
                     }
 
-                }), from(new Notification<T>()));
+                }), from(Notification.<T>createOnCompleted()));
 
         return zip(firstObservable, secondObservable,
                 new Func2<Notification<T>, Notification<T>, Boolean>() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
index d9a607ab54..19e0aef60b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
@@ -66,8 +66,8 @@ public ResultManager init() {
             cancel.add(toSource);
             cancel.add(toOther);
 
-            toSource.setSubscription(source.unsafeSubscribe(Subscribers.from(this)));
-            toOther.setSubscription(other.unsafeSubscribe(new OtherObserver(toOther)));
+            toSource.set(source.unsafeSubscribe(Subscribers.from(this)));
+            toOther.set(other.unsafeSubscribe(new OtherObserver(toOther)));
 
             return this;
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSum.java b/rxjava-core/src/main/java/rx/operators/OperationSum.java
deleted file mode 100644
index 7c2177836f..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSum.java
+++ /dev/null
@@ -1,89 +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.functions.Func2;
-
-/**
- * A few operators for implementing the sum operation.
- * 
- * @see <a
- *      href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum%28v=vs.103%29.aspx">MSDN:
- *      Observable.Sum</a>
- */
-public final class OperationSum {
-
-    public static Observable<Integer> sumIntegers(Observable<Integer> source) {
-        return source.reduce(0, ACCUM_INT);
-    }
-
-    public static Observable<Long> sumLongs(Observable<Long> source) {
-        return source.reduce(0l, ACCUM_LONG);
-    }
-
-    public static Observable<Float> sumFloats(Observable<Float> source) {
-        return source.reduce(0.0f, ACCUM_FLOAT);
-    }
-
-    public static Observable<Double> sumDoubles(Observable<Double> source) {
-        return source.reduce(0.0d, ACCUM_DOUBLE);
-    }
-
-    public static Observable<Integer> sumAtLeastOneIntegers(Observable<Integer> source) {
-        return source.reduce(ACCUM_INT);
-    }
-
-    public static Observable<Long> sumAtLeastOneLongs(Observable<Long> source) {
-        return source.reduce(ACCUM_LONG);
-    }
-
-    public static Observable<Float> sumAtLeastOneFloats(Observable<Float> source) {
-        return source.reduce(ACCUM_FLOAT);
-    }
-
-    public static Observable<Double> sumAtLeastOneDoubles(Observable<Double> source) {
-        return source.reduce(ACCUM_DOUBLE);
-    }
-
-    private static final Func2<Integer, Integer, Integer> ACCUM_INT = new Func2<Integer, Integer, Integer>() {
-        @Override
-        public Integer call(Integer accu, Integer next) {
-            return accu + next;
-        }
-    };
-
-    private static final Func2<Long, Long, Long> ACCUM_LONG = new Func2<Long, Long, Long>() {
-        @Override
-        public Long call(Long accu, Long next) {
-            return accu + next;
-        }
-    };
-
-    private static final Func2<Float, Float, Float> ACCUM_FLOAT = new Func2<Float, Float, Float>() {
-        @Override
-        public Float call(Float accu, Float next) {
-            return accu + next;
-        }
-    };
-
-    private static final Func2<Double, Double, Double> ACCUM_DOUBLE = new Func2<Double, Double, Double>() {
-        @Override
-        public Double call(Double accu, Double next) {
-            return accu + next;
-        }
-    };
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
index 3332a49f2a..4af058f283 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
@@ -144,7 +144,7 @@ public void onCompleted() {
 
             }));
 
-            this.child.setSubscription(sub);
+            this.child.set(sub);
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSynchronize.java b/rxjava-core/src/main/java/rx/operators/OperatorSynchronize.java
deleted file mode 100644
index 0cdc9eded8..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperatorSynchronize.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.operators;
-
-import rx.Observable;
-import rx.Observable.Operator;
-import rx.Subscriber;
-import rx.observers.SynchronizedSubscriber;
-
-/**
- * Wraps an Observable in another Observable that ensures that the resulting Observable is
- * chronologically well-behaved.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/synchronize.png">
- * <p>
- * A well-behaved Observable does not interleave its invocations of the <code>onNext</code>,
- * <code>onCompleted</code>, and <code>onError</code> methods of its Observers; it invokes
- * <code>onCompleted</code> or <code>onError</code> only once; and it never invokes
- * <code>onNext</code> after invoking either <code>onCompleted</code> or <code>onError</code>. The
- * synchronize operation enforces this, and the Observable it returns invokes <code>onNext</code>
- * and <code>onCompleted</code> or <code>onError</code> synchronously.
- * <p>
- * NOTE: {@link Observable#create} already wraps Observables so this is generally redundant.
- * 
- * @param <T>
- *            The type of the observable sequence.
- */
-public final class OperatorSynchronize<T> implements Operator<T, T> {
-
-    final Object lock;
-
-    public OperatorSynchronize(Object lock) {
-        this.lock = lock;
-    }
-
-    public OperatorSynchronize() {
-        this.lock = new Object();
-    }
-
-    @Override
-    public Subscriber<? super T> call(final Subscriber<? super T> s) {
-        return new SynchronizedSubscriber<T>(new Subscriber<T>(s) {
-
-            @Override
-            public void onCompleted() {
-                s.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                s.onError(e);
-            }
-
-            @Override
-            public void onNext(T t) {
-                s.onNext(t);
-            }
-
-        }, lock);
-    }
-
-}
diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index 2a12a840ff..f95ab6e216 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -57,7 +57,7 @@ public final class AsyncSubject<T> extends Subject<T, T> {
 
     public static <T> AsyncSubject<T> create() {
         final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
-        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>(new Notification<T>());
+        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>(Notification.<T>createOnCompleted());
 
         OnSubscribe<T> onSubscribe = subscriptionManager.getOnSubscribeFunc(
                 /**
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 9100caa3c3..c6c3214afa 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -67,18 +67,6 @@
  */
 public final class BehaviorSubject<T> extends Subject<T, T> {
 
-    /**
-     * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
-     * 
-     * @param defaultValue
-     *            the value which will be published to any {@link Observer} as long as the {@link BehaviorSubject} has not yet received any events
-     * @return the constructed {@link BehaviorSubject}
-     * @deprecated use {@link #create(T)} instead
-     */
-    public static <T> BehaviorSubject<T> createWithDefaultValue(T defaultValue) {
-        return create(defaultValue);
-    }
-
     /**
      * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
      * 
@@ -89,7 +77,7 @@ public static <T> BehaviorSubject<T> createWithDefaultValue(T defaultValue) {
     public static <T> BehaviorSubject<T> create(T defaultValue) {
         final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
         // set a default value so subscriptions will immediately receive this until a new notification is received
-        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>(new Notification<T>(defaultValue));
+        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>(Notification.createOnNext(defaultValue));
 
         OnSubscribe<T> onSubscribe = subscriptionManager.getOnSubscribeFunc(
                 /**
diff --git a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
index ea5d430fbe..296cd231cd 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/MultipleAssignmentSubscription.java
@@ -67,11 +67,6 @@ public void unsubscribe() {
         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");
@@ -89,11 +84,6 @@ public void set(Subscription s) {
         } while (!state.compareAndSet(oldState, newState));
     }
 
-    @Deprecated
-    public Subscription getSubscription() {
-        return get();
-    }
-
     public Subscription get() {
         return state.get().subscription;
     }
diff --git a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
index 6165b7f627..fdc9641dd8 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/RefCountSubscription.java
@@ -65,11 +65,6 @@ public RefCountSubscription(Subscription s) {
         this.actual = s;
     }
 
-    @Deprecated
-    public Subscription getSubscription() {
-        return get();
-    }
-
     /**
      * Returns a new sub-subscription.
      */
diff --git a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
index 8f1e5b5f4c..77b6226db6 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/SerialSubscription.java
@@ -67,11 +67,6 @@ public void unsubscribe() {
         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");
@@ -90,11 +85,6 @@ public void set(Subscription s) {
         oldState.subscription.unsubscribe();
     }
 
-    @Deprecated
-    public Subscription getSubscription() {
-        return get();
-    }
-
     public Subscription get() {
         return state.get().subscription;
     }
diff --git a/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
index 7eb94edd3b..ad386fcb53 100644
--- a/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
+++ b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSerializePerformance.java
@@ -91,21 +91,6 @@ public void serializedSingleStream(Input input) {
         }
     }
 
-    /**
-     * Run: 10 - 9,475,925 ops/sec
-     * Run: 11 - 9,501,341 ops/sec
-     * Run: 12 - 9,550,495 ops/sec
-     * Run: 13 - 9,510,303 ops/sec
-     * Run: 14 - 9,690,300 ops/sec
-     * 
-     * @param input
-     */
-    public void synchronizedSingleStream(Input input) {
-        for (int i = 0; i < reps; i++) {
-            input.observable.synchronize().subscribe(input.subscriber);
-        }
-    }
-
     /**
      * 1 streams emitting in a tight loop. Testing for single-threaded overhead.
      * 
diff --git a/rxjava-core/src/perf/java/rx/archive/operators/OperatorSynchronizePerformance.java b/rxjava-core/src/perf/java/rx/archive/operators/OperatorSynchronizePerformance.java
deleted file mode 100644
index dd5e2f0703..0000000000
--- a/rxjava-core/src/perf/java/rx/archive/operators/OperatorSynchronizePerformance.java
+++ /dev/null
@@ -1,236 +0,0 @@
-package rx.archive.operators;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-import rx.Observable;
-import rx.Observable.OnSubscribe;
-import rx.Subscriber;
-import rx.archive.perf.AbstractPerformanceTester;
-import rx.archive.perf.IntegerSumObserver;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.functions.Func1;
-import rx.schedulers.Schedulers;
-
-public class OperatorSynchronizePerformance extends AbstractPerformanceTester {
-    static int reps = Integer.MAX_VALUE / 1024;
-
-    //    static int reps = 1000; // timeTwoStreamsIntervals
-
-    OperatorSynchronizePerformance() {
-        super(reps);
-    }
-
-    public static void main(String args[]) {
-
-        final OperatorSynchronizePerformance spt = new OperatorSynchronizePerformance();
-        try {
-            spt.runTest(new Action0() {
-
-                @Override
-                public void call() {
-                    spt.timeTwoStreams();
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-    }
-
-    /**
-     * Run: 10 - 59,593,390 ops/sec
-     * Run: 11 - 55,784,194 ops/sec
-     * Run: 12 - 58,778,300 ops/sec
-     * Run: 13 - 60,679,696 ops/sec
-     * Run: 14 - 59,370,693 ops/sec
-     */
-    public long timeSingleStream() {
-
-        final Observable<Integer> s1 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
-
-        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
-
-            @Override
-            public void call(final Subscriber<? super Integer> s) {
-                final CountDownLatch latch = new CountDownLatch(1);
-                // first
-                s1.doOnTerminate(new Action0() {
-
-                    @Override
-                    public void call() {
-                        latch.countDown();
-                    }
-
-                }).subscribe(new Action1<Integer>() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        s.onNext(t1);
-                    }
-
-                });
-
-                try {
-                    latch.await();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                s.onCompleted();
-            }
-
-        }).synchronize();
-
-        IntegerSumObserver o = new IntegerSumObserver();
-        s.subscribe(o);
-        //        System.out.println("sum : " + o.sum);
-
-        return o.sum;
-    }
-
-    /**
-     * Run: 10 - 9,139,226 ops/sec
-     * Run: 11 - 8,456,526 ops/sec
-     * Run: 12 - 8,072,174 ops/sec
-     * Run: 13 - 8,667,381 ops/sec
-     * Run: 14 - 8,853,370 ops/sec
-     */
-    public long timeTwoStreams() {
-
-        final Observable<Integer> s1 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
-        final Observable<Integer> s2 = Observable.range(0, reps).subscribeOn(Schedulers.newThread());
-
-        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
-
-            @Override
-            public void call(final Subscriber<? super Integer> s) {
-                final CountDownLatch latch = new CountDownLatch(2);
-                // first
-                s1.doOnTerminate(new Action0() {
-
-                    @Override
-                    public void call() {
-                        latch.countDown();
-                    }
-
-                }).subscribe(new Action1<Integer>() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        s.onNext(t1);
-                    }
-
-                });
-
-                // second
-                s2.doOnTerminate(new Action0() {
-
-                    @Override
-                    public void call() {
-                        latch.countDown();
-                    }
-
-                }).subscribe(new Action1<Integer>() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        s.onNext(t1);
-                    }
-
-                });
-
-                try {
-                    latch.await();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                s.onCompleted();
-            }
-
-        }).synchronize();
-
-        IntegerSumObserver o = new IntegerSumObserver();
-        s.subscribe(o);
-        //        System.out.println("sum : " + o.sum);
-
-        return o.sum;
-    }
-
-    /**
-     * Run: 10 - 1,996 ops/sec
-     * Run: 11 - 1,997 ops/sec
-     * Run: 12 - 1,996 ops/sec
-     * Run: 13 - 1,996 ops/sec
-     * Run: 14 - 1,995 ops/sec
-     * 
-     * @return
-     */
-    public long timeTwoStreamsIntervals() {
-
-        final Observable<Integer> s1 = Observable.interval(1, TimeUnit.MILLISECONDS).take(reps / 2).flatMap(new Func1<Long, Observable<Integer>>() {
-
-            @Override
-            public Observable<Integer> call(Long l) {
-                return Observable.range(l.intValue(), 100);
-            }
-
-        }).subscribeOn(Schedulers.newThread());
-        final Observable<Integer> s2 = Observable.range(1, reps / 2).subscribeOn(Schedulers.newThread());
-
-        Observable<Integer> s = Observable.create(new OnSubscribe<Integer>() {
-
-            @Override
-            public void call(final Subscriber<? super Integer> s) {
-                final CountDownLatch latch = new CountDownLatch(2);
-                // first
-                s1.doOnTerminate(new Action0() {
-
-                    @Override
-                    public void call() {
-                        latch.countDown();
-                    }
-
-                }).subscribe(new Action1<Integer>() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        s.onNext(t1);
-                    }
-
-                });
-
-                // second
-                s2.doOnTerminate(new Action0() {
-
-                    @Override
-                    public void call() {
-                        latch.countDown();
-                    }
-
-                }).subscribe(new Action1<Integer>() {
-
-                    @Override
-                    public void call(Integer t1) {
-                        s.onNext(t1);
-                    }
-
-                });
-
-                try {
-                    latch.await();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                s.onCompleted();
-            }
-
-        }).synchronize();
-
-        IntegerSumObserver o = new IntegerSumObserver();
-        s.subscribe(o);
-        //                System.out.println("sum : " + o.sum);
-
-        return o.sum;
-    }
-}
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java
index 925e9906c7..56b9f75707 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorSerializePerf.java
@@ -42,11 +42,6 @@ public void serializedSingleStream(Input input) {
         input.observable.serialize().subscribe(input.subscriber);
     }
 
-    @GenerateMicroBenchmark
-    public void synchronizedSingleStream(Input input) {
-        input.observable.synchronize().subscribe(input.subscriber);
-    }
-
     @State(Scope.Thread)
     public static class Input {
 
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index f105cc44bc..8dbeb63832 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -193,7 +193,7 @@ public void testTakeFirstWithPredicateOfNoneMatchingThePredicate() {
     @Test
     public void testTakeFirstOfSome() {
         Observable<Integer> observable = Observable.from(1, 2, 3);
-        observable.takeFirst().subscribe(w);
+        observable.take(1).subscribe(w);
         verify(w, times(1)).onNext(anyInt());
         verify(w).onNext(1);
         verify(w, times(1)).onCompleted();
@@ -203,7 +203,7 @@ public void testTakeFirstOfSome() {
     @Test
     public void testTakeFirstOfNone() {
         Observable<Integer> observable = Observable.empty();
-        observable.takeFirst().subscribe(w);
+        observable.take(1).subscribe(w);
         verify(w, never()).onNext(anyInt());
         verify(w, times(1)).onCompleted();
         verify(w, never()).onError(any(Throwable.class));
diff --git a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
deleted file mode 100644
index 7cd36caf71..0000000000
--- a/rxjava-core/src/test/java/rx/observers/SynchronizedObserverTest.java
+++ /dev/null
@@ -1,821 +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.observers;
-
-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.mockito.Matchers.any;
-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.Random;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
-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.Subscriber;
-import rx.Subscription;
-
-public class SynchronizedObserverTest {
-
-    @Mock
-    Subscriber<String> observer;
-
-    @Before
-    public void before() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void testSingleThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        SynchronizedObserver<String> aw = new SynchronizedObserver<String>(observer);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        verify(observer, times(1)).onNext("one");
-        verify(observer, times(1)).onNext("two");
-        verify(observer, times(1)).onNext("three");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-    }
-
-    @Test
-    public void testMultiThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-        SynchronizedObserver<String> aw = new SynchronizedObserver<String>(busyObserver);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        assertEquals(3, busyObserver.onNextCount.get());
-        assertFalse(busyObserver.onError);
-        assertTrue(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedBasicWithLock() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-
-        Object lock = new Object();
-        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyObserver, lock, 10, 100);
-
-        SynchronizedObserver<String> aw = new SynchronizedObserver<String>(busyObserver, lock);
-
-        externalBusyThread.start();
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        try {
-            externalBusyThread.join(10000);
-            assertFalse(externalBusyThread.isAlive());
-            assertFalse(externalBusyThread.fail);
-        } catch (InterruptedException e) {
-            // ignore
-        }
-
-        assertEquals(3, busyObserver.onNextCount.get());
-        assertFalse(busyObserver.onError);
-        assertTrue(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPE() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-        SynchronizedObserver<String> aw = new SynchronizedObserver<String>(busyObserver);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-
-        // we can't know how many onNext calls will occur since they each run on a separate thread
-        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
-        // assertEquals(3, busyObserver.onNextCount.get());
-        assertTrue(busyObserver.onNextCount.get() < 4);
-        assertTrue(busyObserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPEAndLock() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-
-        Object lock = new Object();
-        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyObserver, lock, 10, 100);
-
-        SynchronizedObserver<String> aw = new SynchronizedObserver<String>(busyObserver, lock);
-
-        externalBusyThread.start();
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        try {
-            externalBusyThread.join(10000);
-            assertFalse(externalBusyThread.isAlive());
-            assertFalse(externalBusyThread.fail);
-        } catch (InterruptedException e) {
-            // ignore
-        }
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-
-        // we can't know how many onNext calls will occur since they each run on a separate thread
-        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
-        // assertEquals(3, busyObserver.onNextCount.get());
-        assertTrue(busyObserver.onNextCount.get() < 4);
-        assertTrue(busyObserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPEinMiddle() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-        SynchronizedObserver<String> aw = new SynchronizedObserver<String>(busyObserver);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-        // this should not be the full number of items since the error should stop it before it completes all 9
-        System.out.println("onNext count: " + busyObserver.onNextCount.get());
-        assertTrue(busyObserver.onNextCount.get() < 9);
-        assertTrue(busyObserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        // verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPEinMiddleAndLock() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-
-        Object lock = new Object();
-        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyObserver, lock, 10, 100);
-
-        SynchronizedObserver<String> aw = new SynchronizedObserver<String>(busyObserver, lock);
-
-        externalBusyThread.start();
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        try {
-            externalBusyThread.join(10000);
-            assertFalse(externalBusyThread.isAlive());
-            assertFalse(externalBusyThread.fail);
-        } catch (InterruptedException e) {
-            // ignore
-        }
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-        // this should not be the full number of items since the error should stop it before it completes all 9
-        System.out.println("onNext count: " + busyObserver.onNextCount.get());
-        assertTrue(busyObserver.onNextCount.get() < 9);
-        assertTrue(busyObserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        // verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-    }
-
-    /**
-     * A non-realistic use case that tries to expose thread-safety issues by throwing lots of out-of-order
-     * events on many threads.
-     * 
-     * @param w
-     * @param tw
-     */
-    @Test
-    public void runOutOfOrderConcurrencyTest() {
-        ExecutorService tp = Executors.newFixedThreadPool(20);
-        try {
-            TestConcurrencyObserver tw = new TestConcurrencyObserver();
-            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
-            SynchronizedObserver<String> w = new SynchronizedObserver<String>(new SafeSubscriber<String>(tw));
-
-            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
-            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
-            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
-            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
-            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
-            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
-            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
-            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
-
-            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4, f5, f6, f7, f8));
-            try {
-                Thread.sleep(1);
-            } catch (InterruptedException e) {
-                // ignore
-            }
-            Future<?> f11 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            Future<?> f12 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            Future<?> f13 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            Future<?> f14 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f4, f6, f7));
-            // // the next 4 onError events should wait on same as f10
-            Future<?> f15 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-            Future<?> f16 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-            Future<?> f17 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-            Future<?> f18 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onError, f1, f2, f3, f4));
-
-            waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10, f11, f12, f13, f14, f15, f16, f17, f18);
-            @SuppressWarnings("unused")
-            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
-            // System.out.println("Number of events executed: " + numNextEvents);
-        } catch (Throwable e) {
-            fail("Concurrency test failed: " + e.getMessage());
-            e.printStackTrace();
-        } finally {
-            tp.shutdown();
-            try {
-                tp.awaitTermination(5000, TimeUnit.MILLISECONDS);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    /**
-     * 
-     * @param w
-     * @param tw
-     */
-    @Test
-    public void runConcurrencyTest() {
-        ExecutorService tp = Executors.newFixedThreadPool(20);
-        try {
-            TestConcurrencyObserver tw = new TestConcurrencyObserver();
-            // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle
-            SynchronizedObserver<String> w = new SynchronizedObserver<String>(new SafeSubscriber<String>(tw));
-
-            Future<?> f1 = tp.submit(new OnNextThread(w, 12000));
-            Future<?> f2 = tp.submit(new OnNextThread(w, 5000));
-            Future<?> f3 = tp.submit(new OnNextThread(w, 75000));
-            Future<?> f4 = tp.submit(new OnNextThread(w, 13500));
-            Future<?> f5 = tp.submit(new OnNextThread(w, 22000));
-            Future<?> f6 = tp.submit(new OnNextThread(w, 15000));
-            Future<?> f7 = tp.submit(new OnNextThread(w, 7500));
-            Future<?> f8 = tp.submit(new OnNextThread(w, 23500));
-
-            // 12000 + 5000 + 75000 + 13500 + 22000 + 15000 + 7500 + 23500 = 173500
-
-            Future<?> f10 = tp.submit(new CompletionThread(w, TestConcurrencyObserverEvent.onCompleted, f1, f2, f3, f4, f5, f6, f7, f8));
-            try {
-                Thread.sleep(1);
-            } catch (InterruptedException e) {
-                // ignore
-            }
-
-            waitOnThreads(f10);
-            @SuppressWarnings("unused")
-            int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
-            assertEquals(173500, numNextEvents);
-            // System.out.println("Number of events executed: " + numNextEvents);
-        } catch (Throwable e) {
-            fail("Concurrency test failed: " + e.getMessage());
-            e.printStackTrace();
-        } finally {
-            tp.shutdown();
-            try {
-                tp.awaitTermination(5000, TimeUnit.MILLISECONDS);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private static void waitOnThreads(Future<?>... futures) {
-        for (Future<?> f : futures) {
-            try {
-                f.get(10, TimeUnit.SECONDS);
-            } catch (Throwable e) {
-                System.err.println("Failed while waiting on future.");
-                e.printStackTrace();
-            }
-        }
-    }
-
-    /**
-     * A thread that will pass data to onNext
-     */
-    public static class OnNextThread implements Runnable {
-
-        private final Observer<String> Observer;
-        private final int numStringsToSend;
-
-        OnNextThread(Observer<String> Observer, int numStringsToSend) {
-            this.Observer = Observer;
-            this.numStringsToSend = numStringsToSend;
-        }
-
-        @Override
-        public void run() {
-            for (int i = 0; i < numStringsToSend; i++) {
-                Observer.onNext("aString");
-            }
-        }
-    }
-
-    /**
-     * A thread that will call onError or onNext
-     */
-    public static class CompletionThread implements Runnable {
-
-        private final Observer<String> Observer;
-        private final TestConcurrencyObserverEvent event;
-        private final Future<?>[] waitOnThese;
-
-        CompletionThread(Observer<String> Observer, TestConcurrencyObserverEvent event, Future<?>... waitOnThese) {
-            this.Observer = Observer;
-            this.event = event;
-            this.waitOnThese = waitOnThese;
-        }
-
-        @Override
-        public void run() {
-            /* if we have 'waitOnThese' futures, we'll wait on them before proceeding */
-            if (waitOnThese != null) {
-                for (Future<?> f : waitOnThese) {
-                    try {
-                        f.get();
-                    } catch (Throwable e) {
-                        System.err.println("Error while waiting on future in CompletionThread");
-                    }
-                }
-            }
-
-            /* send the event */
-            if (event == TestConcurrencyObserverEvent.onError) {
-                Observer.onError(new RuntimeException("mocked exception"));
-            } else if (event == TestConcurrencyObserverEvent.onCompleted) {
-                Observer.onCompleted();
-
-            } else {
-                throw new IllegalArgumentException("Expecting either onError or onCompleted");
-            }
-        }
-    }
-
-    private static enum TestConcurrencyObserverEvent {
-        onCompleted, onError, onNext
-    }
-
-    private static class TestConcurrencyObserver extends Subscriber<String> {
-
-        /**
-         * used to store the order and number of events received
-         */
-        private final LinkedBlockingQueue<TestConcurrencyObserverEvent> events = new LinkedBlockingQueue<TestConcurrencyObserverEvent>();
-        private final int waitTime;
-
-        @SuppressWarnings("unused")
-        public TestConcurrencyObserver(int waitTimeInNext) {
-            this.waitTime = waitTimeInNext;
-        }
-
-        public TestConcurrencyObserver() {
-            this.waitTime = 0;
-        }
-
-        @Override
-        public void onCompleted() {
-            events.add(TestConcurrencyObserverEvent.onCompleted);
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            events.add(TestConcurrencyObserverEvent.onError);
-        }
-
-        @Override
-        public void onNext(String args) {
-            events.add(TestConcurrencyObserverEvent.onNext);
-            // do some artificial work to make the thread scheduling/timing vary
-            int s = 0;
-            for (int i = 0; i < 20; i++) {
-                s += s * i;
-            }
-
-            if (waitTime > 0) {
-                try {
-                    Thread.sleep(waitTime);
-                } catch (InterruptedException e) {
-                    // ignore
-                }
-            }
-        }
-
-        /**
-         * Assert the order of events is correct and return the number of onNext executions.
-         * 
-         * @param expectedEndingEvent
-         * @return int count of onNext calls
-         * @throws IllegalStateException
-         *             If order of events was invalid.
-         */
-        public int assertEvents(TestConcurrencyObserverEvent expectedEndingEvent) throws IllegalStateException {
-            int nextCount = 0;
-            boolean finished = false;
-            for (TestConcurrencyObserverEvent e : events) {
-                if (e == TestConcurrencyObserverEvent.onNext) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onNext but we're already finished.");
-                    }
-                    nextCount++;
-                } else if (e == TestConcurrencyObserverEvent.onError) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onError but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onError != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                } else if (e == TestConcurrencyObserverEvent.onCompleted) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onCompleted but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyObserverEvent.onCompleted != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                }
-            }
-
-            return nextCount;
-        }
-
-    }
-
-    /**
-     * This spawns a single thread for the subscribe execution
-     */
-    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
-
-        final Subscription s;
-        final String[] values;
-        private Thread t = null;
-
-        public TestSingleThreadedObservable(final Subscription s, final String... values) {
-            this.s = s;
-            this.values = values;
-
-        }
-
-        public Subscription onSubscribe(final Observer<? super String> observer) {
-            System.out.println("TestSingleThreadedObservable subscribed to ...");
-            t = new Thread(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        System.out.println("running TestSingleThreadedObservable thread");
-                        for (String s : values) {
-                            System.out.println("TestSingleThreadedObservable onNext: " + s);
-                            observer.onNext(s);
-                        }
-                        observer.onCompleted();
-                    } catch (Throwable e) {
-                        throw new RuntimeException(e);
-                    }
-                }
-
-            });
-            System.out.println("starting TestSingleThreadedObservable thread");
-            t.start();
-            System.out.println("done starting TestSingleThreadedObservable thread");
-            return s;
-        }
-
-        public void waitToFinish() {
-            try {
-                t.join();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-    }
-
-    /**
-     * This spawns a thread for the subscription, then a separate thread for each onNext call.
-     */
-    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
-
-        final Subscription s;
-        final String[] values;
-        Thread t = null;
-        AtomicInteger threadsRunning = new AtomicInteger();
-        AtomicInteger maxConcurrentThreads = new AtomicInteger();
-        ExecutorService threadPool;
-
-        public TestMultiThreadedObservable(Subscription s, String... values) {
-            this.s = s;
-            this.values = values;
-            this.threadPool = Executors.newCachedThreadPool();
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
-            System.out.println("TestMultiThreadedObservable subscribed to ...");
-            t = new Thread(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        System.out.println("running TestMultiThreadedObservable thread");
-                        for (final String s : values) {
-                            threadPool.execute(new Runnable() {
-
-                                @Override
-                                public void run() {
-                                    threadsRunning.incrementAndGet();
-                                    try {
-                                        // perform onNext call
-                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
-                                        if (s == null) {
-                                            // force an error
-                                            throw new NullPointerException();
-                                        }
-                                        observer.onNext(s);
-                                        // capture 'maxThreads'
-                                        int concurrentThreads = threadsRunning.get();
-                                        int maxThreads = maxConcurrentThreads.get();
-                                        if (concurrentThreads > maxThreads) {
-                                            maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-                                        }
-                                    } catch (Throwable e) {
-                                        observer.onError(e);
-                                    } finally {
-                                        threadsRunning.decrementAndGet();
-                                    }
-                                }
-                            });
-                        }
-                        // we are done spawning threads
-                        threadPool.shutdown();
-                    } catch (Throwable e) {
-                        throw new RuntimeException(e);
-                    }
-
-                    // wait until all threads are done, then mark it as COMPLETED
-                    try {
-                        // wait for all the threads to finish
-                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
-                    } catch (InterruptedException e) {
-                        throw new RuntimeException(e);
-                    }
-                    observer.onCompleted();
-                }
-            });
-            System.out.println("starting TestMultiThreadedObservable thread");
-            t.start();
-            System.out.println("done starting TestMultiThreadedObservable thread");
-            return s;
-        }
-
-        public void waitToFinish() {
-            try {
-                t.join();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-
-    private static class BusyObserver extends Subscriber<String> {
-        volatile boolean onCompleted = false;
-        volatile boolean onError = false;
-        AtomicInteger onNextCount = new AtomicInteger();
-        AtomicInteger threadsRunning = new AtomicInteger();
-        AtomicInteger maxConcurrentThreads = new AtomicInteger();
-
-        @Override
-        public void onCompleted() {
-            threadsRunning.incrementAndGet();
-
-            System.out.println(">>> BusyObserver received onCompleted");
-            onCompleted = true;
-
-            int concurrentThreads = threadsRunning.get();
-            int maxThreads = maxConcurrentThreads.get();
-            if (concurrentThreads > maxThreads) {
-                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-            }
-            threadsRunning.decrementAndGet();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            threadsRunning.incrementAndGet();
-
-            System.out.println(">>> BusyObserver received onError: " + e.getMessage());
-            onError = true;
-
-            int concurrentThreads = threadsRunning.get();
-            int maxThreads = maxConcurrentThreads.get();
-            if (concurrentThreads > maxThreads) {
-                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-            }
-            threadsRunning.decrementAndGet();
-        }
-
-        @Override
-        public void onNext(String args) {
-            threadsRunning.incrementAndGet();
-            try {
-                onNextCount.incrementAndGet();
-                System.out.println(">>> BusyObserver received onNext: " + args);
-                try {
-                    // simulate doing something computational
-                    Thread.sleep(200);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-            } finally {
-                // capture 'maxThreads'
-                int concurrentThreads = threadsRunning.get();
-                int maxThreads = maxConcurrentThreads.get();
-                if (concurrentThreads > maxThreads) {
-                    maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-                }
-                threadsRunning.decrementAndGet();
-            }
-        }
-
-    }
-
-    private static class ExternalBusyThread extends Thread {
-
-        private BusyObserver observer;
-        private Object lock;
-        private int lockTimes;
-        private int waitTime;
-        public volatile boolean fail;
-
-        public ExternalBusyThread(BusyObserver observer, Object lock, int lockTimes, int waitTime) {
-            this.observer = observer;
-            this.lock = lock;
-            this.lockTimes = lockTimes;
-            this.waitTime = waitTime;
-            this.fail = false;
-        }
-
-        @Override
-        public void run() {
-            Random r = new Random();
-            for (int i = 0; i < lockTimes; i++) {
-                synchronized (lock) {
-                    int oldOnNextCount = observer.onNextCount.get();
-                    boolean oldOnCompleted = observer.onCompleted;
-                    boolean oldOnError = observer.onError;
-                    try {
-                        Thread.sleep(r.nextInt(waitTime));
-                    } catch (InterruptedException e) {
-                        // ignore
-                    }
-                    // Since we own the lock, onNextCount, onCompleted and
-                    // onError must not be changed.
-                    int newOnNextCount = observer.onNextCount.get();
-                    boolean newOnCompleted = observer.onCompleted;
-                    boolean newOnError = observer.onError;
-                    if (oldOnNextCount != newOnNextCount) {
-                        System.out.println(">>> ExternalBusyThread received different onNextCount: "
-                                + oldOnNextCount
-                                + " -> "
-                                + newOnNextCount);
-                        fail = true;
-                        break;
-                    }
-                    if (oldOnCompleted != newOnCompleted) {
-                        System.out.println(">>> ExternalBusyThread received different onCompleted: "
-                                + oldOnCompleted
-                                + " -> "
-                                + newOnCompleted);
-                        fail = true;
-                        break;
-                    }
-                    if (oldOnError != newOnError) {
-                        System.out.println(">>> ExternalBusyThread received different onError: "
-                                + oldOnError
-                                + " -> "
-                                + newOnError);
-                        fail = true;
-                        break;
-                    }
-                }
-            }
-        }
-
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java b/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
deleted file mode 100644
index fb93d6c916..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationAverageTest.java
+++ /dev/null
@@ -1,350 +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.any;
-import static org.mockito.Matchers.anyDouble;
-import static org.mockito.Matchers.anyFloat;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.isA;
-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.OperationAverage.average;
-import static rx.operators.OperationAverage.averageDoubles;
-import static rx.operators.OperationAverage.averageFloats;
-import static rx.operators.OperationAverage.averageLongs;
-
-import org.junit.Test;
-
-import rx.Observable;
-import rx.Observer;
-import rx.functions.Func1;
-import rx.operators.OperationReduceTest.CustomException;
-
-public class OperationAverageTest {
-
-    @SuppressWarnings("unchecked")
-    Observer<Integer> w = mock(Observer.class);
-    @SuppressWarnings("unchecked")
-    Observer<Long> wl = mock(Observer.class);
-    @SuppressWarnings("unchecked")
-    Observer<Float> wf = mock(Observer.class);
-    @SuppressWarnings("unchecked")
-    Observer<Double> wd = mock(Observer.class);
-
-    @Test
-    public void testAverageOfAFewInts() throws Throwable {
-        Observable<Integer> src = Observable.from(1, 2, 3, 4, 6);
-        average(src).subscribe(w);
-
-        verify(w, times(1)).onNext(anyInt());
-        verify(w).onNext(3);
-        verify(w, never()).onError(any(Throwable.class));
-        verify(w, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptyAverage() throws Throwable {
-        Observable<Integer> src = Observable.empty();
-        average(src).subscribe(w);
-
-        verify(w, never()).onNext(anyInt());
-        verify(w, times(1)).onError(isA(IllegalArgumentException.class));
-        verify(w, never()).onCompleted();
-    }
-
-    @Test
-    public void testAverageOfAFewLongs() throws Throwable {
-        Observable<Long> src = Observable.from(1L, 2L, 3L, 4L, 6L);
-        averageLongs(src).subscribe(wl);
-
-        verify(wl, times(1)).onNext(anyLong());
-        verify(wl).onNext(3L);
-        verify(wl, never()).onError(any(Throwable.class));
-        verify(wl, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptyAverageLongs() throws Throwable {
-        Observable<Long> src = Observable.empty();
-        averageLongs(src).subscribe(wl);
-
-        verify(wl, never()).onNext(anyLong());
-        verify(wl, times(1)).onError(isA(IllegalArgumentException.class));
-        verify(wl, never()).onCompleted();
-    }
-
-    @Test
-    public void testAverageOfAFewFloats() throws Throwable {
-        Observable<Float> src = Observable.from(1.0f, 2.0f);
-        averageFloats(src).subscribe(wf);
-
-        verify(wf, times(1)).onNext(anyFloat());
-        verify(wf).onNext(1.5f);
-        verify(wf, never()).onError(any(Throwable.class));
-        verify(wf, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptyAverageFloats() throws Throwable {
-        Observable<Float> src = Observable.empty();
-        averageFloats(src).subscribe(wf);
-
-        verify(wf, never()).onNext(anyFloat());
-        verify(wf, times(1)).onError(isA(IllegalArgumentException.class));
-        verify(wf, never()).onCompleted();
-    }
-
-    @Test
-    public void testAverageOfAFewDoubles() throws Throwable {
-        Observable<Double> src = Observable.from(1.0d, 2.0d);
-        averageDoubles(src).subscribe(wd);
-
-        verify(wd, times(1)).onNext(anyDouble());
-        verify(wd).onNext(1.5d);
-        verify(wd, never()).onError(any(Throwable.class));
-        verify(wd, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptyAverageDoubles() throws Throwable {
-        Observable<Double> src = Observable.empty();
-        averageDoubles(src).subscribe(wd);
-
-        verify(wd, never()).onNext(anyDouble());
-        verify(wd, times(1)).onError(isA(IllegalArgumentException.class));
-        verify(wd, never()).onCompleted();
-    }
-
-    void testThrows(Observer<Object> o, Class<? extends Throwable> errorClass) {
-        verify(o, never()).onNext(any());
-        verify(o, never()).onCompleted();
-        verify(o, times(1)).onError(any(errorClass));
-    }
-
-    <N extends Number> void testValue(Observer<Object> 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<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Integer> length = new Func1<String, Integer>() {
-            @Override
-            public Integer call(String t1) {
-                return t1.length();
-            }
-        };
-
-        Observable<Integer> result = source.averageInteger(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 2);
-    }
-
-    @Test
-    public void testLongAverageSelector() {
-        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Long> length = new Func1<String, Long>() {
-            @Override
-            public Long call(String t1) {
-                return (long) t1.length();
-            }
-        };
-
-        Observable<Long> result = source.averageLong(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 2L);
-    }
-
-    @Test
-    public void testFloatAverageSelector() {
-        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Float> length = new Func1<String, Float>() {
-            @Override
-            public Float call(String t1) {
-                return (float) t1.length();
-            }
-        };
-
-        Observable<Float> result = source.averageFloat(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 2.5f);
-    }
-
-    @Test
-    public void testDoubleAverageSelector() {
-        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Double> length = new Func1<String, Double>() {
-            @Override
-            public Double call(String t1) {
-                return (double) t1.length();
-            }
-        };
-
-        Observable<Double> result = source.averageDouble(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 2.5d);
-    }
-
-    @Test
-    public void testIntegerAverageSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Integer> length = new Func1<String, Integer>() {
-            @Override
-            public Integer call(String t1) {
-                return t1.length();
-            }
-        };
-
-        Observable<Integer> result = source.averageInteger(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testLongAverageSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Long> length = new Func1<String, Long>() {
-            @Override
-            public Long call(String t1) {
-                return (long) t1.length();
-            }
-        };
-
-        Observable<Long> result = source.averageLong(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testFloatAverageSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Float> length = new Func1<String, Float>() {
-            @Override
-            public Float call(String t1) {
-                return (float) t1.length();
-            }
-        };
-
-        Observable<Float> result = source.averageFloat(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testDoubleAverageSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Double> length = new Func1<String, Double>() {
-            @Override
-            public Double call(String t1) {
-                return (double) t1.length();
-            }
-        };
-
-        Observable<Double> result = source.averageDouble(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testIntegerAverageSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Integer> length = new Func1<String, Integer>() {
-            @Override
-            public Integer call(String t1) {
-                throw new CustomException();
-            }
-        };
-
-        Observable<Integer> result = source.averageInteger(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, CustomException.class);
-    }
-
-    @Test
-    public void testLongAverageSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Long> length = new Func1<String, Long>() {
-            @Override
-            public Long call(String t1) {
-                throw new CustomException();
-            }
-        };
-
-        Observable<Long> result = source.averageLong(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, CustomException.class);
-    }
-
-    @Test
-    public void testFloatAverageSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Float> length = new Func1<String, Float>() {
-            @Override
-            public Float call(String t1) {
-                throw new CustomException();
-            }
-        };
-
-        Observable<Float> result = source.averageFloat(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, CustomException.class);
-    }
-
-    @Test
-    public void testDoubleAverageSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Double> length = new Func1<String, Double>() {
-            @Override
-            public Double call(String t1) {
-                throw new CustomException();
-            }
-        };
-
-        Observable<Double> result = source.averageDouble(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, CustomException.class);
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
index 3085c3c633..31d2fa1577 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
@@ -177,7 +177,7 @@ public PPF call(Person t1, Observable<PersonFruit> t2) {
                 new Subscriber<PPF>() {
                     @Override
                     public void onNext(final PPF ppf) {
-                        ppf.fruits.where(new Func1<PersonFruit, Boolean>() {
+                        ppf.fruits.filter(new Func1<PersonFruit, Boolean>() {
                             @Override
                             public Boolean call(PersonFruit t1) {
                                 return ppf.person.id == t1.personId;
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
deleted file mode 100644
index a4074495d6..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java
+++ /dev/null
@@ -1,360 +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.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 java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-import java.util.NoSuchElementException;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-
-import rx.Observable;
-import rx.Observer;
-import rx.functions.Func1;
-
-public class OperationMinMaxTest {
-    @Test
-    public void testMin() {
-        Observable<Integer> observable = min(Observable.from(2, 3, 1, 4));
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) 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 testMinWithEmpty() {
-        Observable<Integer> observable = min(Observable.<Integer> empty());
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onError(
-                isA(NoSuchElementException.class));
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMinWithComparator() {
-        Observable<Integer> observable = min(Observable.from(2, 3, 1, 4),
-                new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(4);
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMinWithComparatorAndEmpty() {
-        Observable<Integer> observable = min(Observable.<Integer> empty(),
-                new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onError(
-                isA(NoSuchElementException.class));
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMinBy() {
-        Observable<List<String>> observable = minBy(
-                Observable.from("1", "2", "3", "4", "5", "6"),
-                new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6"));
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMinByWithEmpty() {
-        Observable<List<String>> observable = minBy(
-                Observable.<String> empty(), new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMinByWithComparator() {
-        Observable<List<String>> observable = minBy(
-                Observable.from("1", "2", "3", "4", "5", "6"),
-                new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                }, new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5"));
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMinByWithComparatorAndEmpty() {
-        Observable<List<String>> observable = minBy(
-                Observable.<String> empty(), new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                }, new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMax() {
-        Observable<Integer> observable = max(Observable.from(2, 3, 1, 4));
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(4);
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMaxWithEmpty() {
-        Observable<Integer> observable = max(Observable.<Integer> empty());
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onError(
-                isA(NoSuchElementException.class));
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMaxWithComparator() {
-        Observable<Integer> observable = max(Observable.from(2, 3, 1, 4),
-                new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) 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 testMaxWithComparatorAndEmpty() {
-        Observable<Integer> observable = max(Observable.<Integer> empty(),
-                new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = (Observer<Integer>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onError(
-                isA(NoSuchElementException.class));
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMaxBy() {
-        Observable<List<String>> observable = maxBy(
-                Observable.from("1", "2", "3", "4", "5", "6"),
-                new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5"));
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMaxByWithEmpty() {
-        Observable<List<String>> observable = maxBy(
-                Observable.<String> empty(), new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMaxByWithComparator() {
-        Observable<List<String>> observable = maxBy(
-                Observable.from("1", "2", "3", "4", "5", "6"),
-                new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                }, new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6"));
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-
-    @Test
-    public void testMaxByWithComparatorAndEmpty() {
-        Observable<List<String>> observable = maxBy(
-                Observable.<String> empty(), new Func1<String, Integer>() {
-                    @Override
-                    public Integer call(String t1) {
-                        return Integer.parseInt(t1) % 2;
-                    }
-                }, new Comparator<Integer>() {
-                    @Override
-                    public int compare(Integer o1, Integer o2) {
-                        return o2 - o1;
-                    }
-                });
-
-        @SuppressWarnings("unchecked")
-        Observer<List<String>> observer = (Observer<List<String>>) mock(Observer.class);
-
-        observable.subscribe(observer);
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer, times(1)).onNext(new ArrayList<String>());
-        inOrder.verify(observer, times(1)).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java b/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
deleted file mode 100644
index b8dc9d16bf..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationSumTest.java
+++ /dev/null
@@ -1,352 +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.any;
-import static org.mockito.Matchers.anyDouble;
-import static org.mockito.Matchers.anyFloat;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.anyLong;
-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.OperationSum.sumDoubles;
-import static rx.operators.OperationSum.sumFloats;
-import static rx.operators.OperationSum.sumIntegers;
-import static rx.operators.OperationSum.sumLongs;
-
-import org.junit.Test;
-
-import rx.Observable;
-import rx.Observer;
-import rx.functions.Func1;
-
-public class OperationSumTest {
-
-    @SuppressWarnings("unchecked")
-    Observer<Integer> w = mock(Observer.class);
-    @SuppressWarnings("unchecked")
-    Observer<Long> wl = mock(Observer.class);
-    @SuppressWarnings("unchecked")
-    Observer<Float> wf = mock(Observer.class);
-    @SuppressWarnings("unchecked")
-    Observer<Double> wd = mock(Observer.class);
-
-    @Test
-    public void testSumOfAFewInts() throws Throwable {
-        Observable<Integer> src = Observable.from(1, 2, 3, 4, 5);
-        sumIntegers(src).subscribe(w);
-
-        verify(w, times(1)).onNext(anyInt());
-        verify(w).onNext(15);
-        verify(w, never()).onError(any(Throwable.class));
-        verify(w, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptySum() throws Throwable {
-        Observable<Integer> src = Observable.empty();
-        sumIntegers(src).subscribe(w);
-
-        verify(w, times(1)).onNext(anyInt());
-        verify(w).onNext(0);
-        verify(w, never()).onError(any(Throwable.class));
-        verify(w, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testSumOfAFewLongs() throws Throwable {
-        Observable<Long> src = Observable.from(1L, 2L, 3L, 4L, 5L);
-        sumLongs(src).subscribe(wl);
-
-        verify(wl, times(1)).onNext(anyLong());
-        verify(wl).onNext(15L);
-        verify(wl, never()).onError(any(Throwable.class));
-        verify(wl, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptySumLongs() throws Throwable {
-        Observable<Long> src = Observable.empty();
-        sumLongs(src).subscribe(wl);
-
-        verify(wl, times(1)).onNext(anyLong());
-        verify(wl).onNext(0L);
-        verify(wl, never()).onError(any(Throwable.class));
-        verify(wl, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testSumOfAFewFloats() throws Throwable {
-        Observable<Float> src = Observable.from(1.0f);
-        sumFloats(src).subscribe(wf);
-
-        verify(wf, times(1)).onNext(anyFloat());
-        verify(wf).onNext(1.0f);
-        verify(wf, never()).onError(any(Throwable.class));
-        verify(wf, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptySumFloats() throws Throwable {
-        Observable<Float> src = Observable.empty();
-        sumFloats(src).subscribe(wf);
-
-        verify(wf, times(1)).onNext(anyFloat());
-        verify(wf).onNext(0.0f);
-        verify(wf, never()).onError(any(Throwable.class));
-        verify(wf, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testSumOfAFewDoubles() throws Throwable {
-        Observable<Double> src = Observable.from(0.0d, 1.0d, 0.5d);
-        sumDoubles(src).subscribe(wd);
-
-        verify(wd, times(1)).onNext(anyDouble());
-        verify(wd).onNext(1.5d);
-        verify(wd, never()).onError(any(Throwable.class));
-        verify(wd, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testEmptySumDoubles() throws Throwable {
-        Observable<Double> src = Observable.empty();
-        sumDoubles(src).subscribe(wd);
-
-        verify(wd, times(1)).onNext(anyDouble());
-        verify(wd).onNext(0.0d);
-        verify(wd, never()).onError(any(Throwable.class));
-        verify(wd, times(1)).onCompleted();
-    }
-
-    void testThrows(Observer<Object> o, Class<? extends Throwable> errorClass) {
-        verify(o, never()).onNext(any());
-        verify(o, never()).onCompleted();
-        verify(o, times(1)).onError(any(errorClass));
-    }
-
-    <N extends Number> void testValue(Observer<Object> 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<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Integer> length = new Func1<String, Integer>() {
-            @Override
-            public Integer call(String t1) {
-                return t1.length();
-            }
-        };
-
-        Observable<Integer> result = source.sumInteger(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 10);
-    }
-
-    @Test
-    public void testLongSumSelector() {
-        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Long> length = new Func1<String, Long>() {
-            @Override
-            public Long call(String t1) {
-                return (long) t1.length();
-            }
-        };
-
-        Observable<Long> result = source.sumLong(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 10L);
-    }
-
-    @Test
-    public void testFloatSumSelector() {
-        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Float> length = new Func1<String, Float>() {
-            @Override
-            public Float call(String t1) {
-                return (float) t1.length();
-            }
-        };
-
-        Observable<Float> result = source.sumFloat(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 10f);
-    }
-
-    @Test
-    public void testDoubleSumSelector() {
-        Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
-        Func1<String, Double> length = new Func1<String, Double>() {
-            @Override
-            public Double call(String t1) {
-                return (double) t1.length();
-            }
-        };
-
-        Observable<Double> result = source.sumDouble(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testValue(o, 10d);
-    }
-
-    @Test
-    public void testIntegerSumSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Integer> length = new Func1<String, Integer>() {
-            @Override
-            public Integer call(String t1) {
-                return t1.length();
-            }
-        };
-
-        Observable<Integer> result = source.sumInteger(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testLongSumSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Long> length = new Func1<String, Long>() {
-            @Override
-            public Long call(String t1) {
-                return (long) t1.length();
-            }
-        };
-
-        Observable<Long> result = source.sumLong(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testFloatSumSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Float> length = new Func1<String, Float>() {
-            @Override
-            public Float call(String t1) {
-                return (float) t1.length();
-            }
-        };
-
-        Observable<Float> result = source.sumFloat(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testDoubleSumSelectorEmpty() {
-        Observable<String> source = Observable.empty();
-        Func1<String, Double> length = new Func1<String, Double>() {
-            @Override
-            public Double call(String t1) {
-                return (double) t1.length();
-            }
-        };
-
-        Observable<Double> result = source.sumDouble(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, IllegalArgumentException.class);
-    }
-
-    @Test
-    public void testIntegerSumSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Integer> length = new Func1<String, Integer>() {
-            @Override
-            public Integer call(String t1) {
-                throw new OperationReduceTest.CustomException();
-            }
-        };
-
-        Observable<Integer> result = source.sumInteger(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, OperationReduceTest.CustomException.class);
-    }
-
-    @Test
-    public void testLongSumSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Long> length = new Func1<String, Long>() {
-            @Override
-            public Long call(String t1) {
-                throw new OperationReduceTest.CustomException();
-            }
-        };
-
-        Observable<Long> result = source.sumLong(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, OperationReduceTest.CustomException.class);
-    }
-
-    @Test
-    public void testFloatSumSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Float> length = new Func1<String, Float>() {
-            @Override
-            public Float call(String t1) {
-                throw new OperationReduceTest.CustomException();
-            }
-        };
-
-        Observable<Float> result = source.sumFloat(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, OperationReduceTest.CustomException.class);
-    }
-
-    @Test
-    public void testDoubleSumSelectorThrows() {
-        Observable<String> source = Observable.from("a");
-        Func1<String, Double> length = new Func1<String, Double>() {
-            @Override
-            public Double call(String t1) {
-                throw new OperationReduceTest.CustomException();
-            }
-        };
-
-        Observable<Double> result = source.sumDouble(length);
-        Observer<Object> o = mock(Observer.class);
-        result.subscribe(o);
-
-        testThrows(o, OperationReduceTest.CustomException.class);
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java
deleted file mode 100644
index a134bb3c9d..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperatorSynchronizeTest.java
+++ /dev/null
@@ -1,692 +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.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-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.Random;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
-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.Subscriber;
-import rx.Subscription;
-
-public class OperatorSynchronizeTest {
-
-    @Mock
-    Observer<String> observer;
-
-    @Before
-    public void before() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test
-    public void testSingleThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        w.synchronize().subscribe(observer);
-        onSubscribe.waitToFinish();
-
-        verify(observer, times(1)).onNext("one");
-        verify(observer, times(1)).onNext("two");
-        verify(observer, times(1)).onNext("three");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-    }
-
-    @Test
-    public void testMultiThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyobserver = new BusyObserver();
-
-        w.synchronize().subscribe(busyobserver);
-        onSubscribe.waitToFinish();
-
-        assertEquals(3, busyobserver.onNextCount.get());
-        assertFalse(busyobserver.onError);
-        assertTrue(busyobserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyobserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedBasicWithLock() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyobserver = new BusyObserver();
-
-        Object lock = new Object();
-        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyobserver, lock, 10, 100);
-
-        externalBusyThread.start();
-
-        w.synchronize(lock).subscribe(busyobserver);
-        onSubscribe.waitToFinish();
-
-        try {
-            externalBusyThread.join(10000);
-            assertFalse(externalBusyThread.isAlive());
-            assertFalse(externalBusyThread.fail);
-        } catch (InterruptedException e) {
-            // ignore
-        }
-
-        assertEquals(3, busyobserver.onNextCount.get());
-        assertFalse(busyobserver.onError);
-        assertTrue(busyobserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //            verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyobserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPE() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyobserver = new BusyObserver();
-
-        w.synchronize().subscribe(busyobserver);
-        onSubscribe.waitToFinish();
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-
-        // we can't know how many onNext calls will occur since they each run on a separate thread
-        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
-        // assertEquals(3, busyobserver.onNextCount.get());
-        assertTrue(busyobserver.onNextCount.get() < 4);
-        assertTrue(busyobserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyobserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyobserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPEAndLock() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyobserver = new BusyObserver();
-
-        Object lock = new Object();
-        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyobserver, lock, 10, 100);
-
-        externalBusyThread.start();
-
-        w.synchronize(lock).subscribe(busyobserver);
-        onSubscribe.waitToFinish();
-
-        try {
-            externalBusyThread.join(10000);
-            assertFalse(externalBusyThread.isAlive());
-            assertFalse(externalBusyThread.fail);
-        } catch (InterruptedException e) {
-            // ignore
-        }
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-
-        // we can't know how many onNext calls will occur since they each run on a separate thread
-        // that depends on thread scheduling so 0, 1, 2 and 3 are all valid options
-        // assertEquals(3, busyobserver.onNextCount.get());
-        assertTrue(busyobserver.onNextCount.get() < 4);
-        assertTrue(busyobserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyobserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        //verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyobserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPEinMiddle() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyobserver = new BusyObserver();
-
-        w.synchronize().subscribe(busyobserver);
-        onSubscribe.waitToFinish();
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-        // this should not be the full number of items since the error should stop it before it completes all 9
-        System.out.println("onNext count: " + busyobserver.onNextCount.get());
-        assertTrue(busyobserver.onNextCount.get() < 9);
-        assertTrue(busyobserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyobserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        // verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyobserver.maxConcurrentThreads.get());
-    }
-
-    @Test
-    public void testMultiThreadedWithNPEinMiddleAndLock() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyobserver = new BusyObserver();
-
-        Object lock = new Object();
-        ExternalBusyThread externalBusyThread = new ExternalBusyThread(busyobserver, lock, 10, 100);
-
-        externalBusyThread.start();
-
-        w.synchronize(lock).subscribe(busyobserver);
-        onSubscribe.waitToFinish();
-
-        try {
-            externalBusyThread.join(10000);
-            assertFalse(externalBusyThread.isAlive());
-            assertFalse(externalBusyThread.fail);
-        } catch (InterruptedException e) {
-            // ignore
-        }
-
-        System.out.println("maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get());
-        // this should not be the full number of items since the error should stop it before it completes all 9
-        System.out.println("onNext count: " + busyobserver.onNextCount.get());
-        assertTrue(busyobserver.onNextCount.get() < 9);
-        assertTrue(busyobserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyobserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        // verify(s, times(1)).unsubscribe();
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyobserver.maxConcurrentThreads.get());
-    }
-
-    /**
-     * A thread that will pass data to onNext
-     */
-    public static class OnNextThread implements Runnable {
-
-        private final Observer<String> observer;
-        private final int numStringsToSend;
-
-        OnNextThread(Observer<String> observer, int numStringsToSend) {
-            this.observer = observer;
-            this.numStringsToSend = numStringsToSend;
-        }
-
-        @Override
-        public void run() {
-            for (int i = 0; i < numStringsToSend; i++) {
-                observer.onNext("aString");
-            }
-        }
-    }
-
-    /**
-     * A thread that will call onError or onNext
-     */
-    public static class CompletionThread implements Runnable {
-
-        private final Observer<String> observer;
-        private final TestConcurrencyobserverEvent event;
-        private final Future<?>[] waitOnThese;
-
-        CompletionThread(Observer<String> observer, TestConcurrencyobserverEvent event, Future<?>... waitOnThese) {
-            this.observer = observer;
-            this.event = event;
-            this.waitOnThese = waitOnThese;
-        }
-
-        @Override
-        public void run() {
-            /* if we have 'waitOnThese' futures, we'll wait on them before proceeding */
-            if (waitOnThese != null) {
-                for (Future<?> f : waitOnThese) {
-                    try {
-                        f.get();
-                    } catch (Throwable e) {
-                        System.err.println("Error while waiting on future in CompletionThread");
-                    }
-                }
-            }
-
-            /* send the event */
-            if (event == TestConcurrencyobserverEvent.onError) {
-                observer.onError(new RuntimeException("mocked exception"));
-            } else if (event == TestConcurrencyobserverEvent.onCompleted) {
-                observer.onCompleted();
-
-            } else {
-                throw new IllegalArgumentException("Expecting either onError or onCompleted");
-            }
-        }
-    }
-
-    private static enum TestConcurrencyobserverEvent {
-        onCompleted, onError, onNext
-    }
-
-    private static class TestConcurrencyobserver extends Subscriber<String> {
-
-        /**
-         * used to store the order and number of events received
-         */
-        private final LinkedBlockingQueue<TestConcurrencyobserverEvent> events = new LinkedBlockingQueue<TestConcurrencyobserverEvent>();
-        private final int waitTime;
-
-        @SuppressWarnings("unused")
-        public TestConcurrencyobserver(int waitTimeInNext) {
-            this.waitTime = waitTimeInNext;
-        }
-
-        public TestConcurrencyobserver() {
-            this.waitTime = 0;
-        }
-
-        @Override
-        public void onCompleted() {
-            events.add(TestConcurrencyobserverEvent.onCompleted);
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            events.add(TestConcurrencyobserverEvent.onError);
-        }
-
-        @Override
-        public void onNext(String args) {
-            events.add(TestConcurrencyobserverEvent.onNext);
-            // do some artificial work to make the thread scheduling/timing vary
-            int s = 0;
-            for (int i = 0; i < 20; i++) {
-                s += s * i;
-            }
-
-            if (waitTime > 0) {
-                try {
-                    Thread.sleep(waitTime);
-                } catch (InterruptedException e) {
-                    // ignore
-                }
-            }
-        }
-
-        /**
-         * Assert the order of events is correct and return the number of onNext executions.
-         * 
-         * @param expectedEndingEvent
-         * @return int count of onNext calls
-         * @throws IllegalStateException
-         *             If order of events was invalid.
-         */
-        public int assertEvents(TestConcurrencyobserverEvent expectedEndingEvent) throws IllegalStateException {
-            int nextCount = 0;
-            boolean finished = false;
-            for (TestConcurrencyobserverEvent e : events) {
-                if (e == TestConcurrencyobserverEvent.onNext) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onNext but we're already finished.");
-                    }
-                    nextCount++;
-                } else if (e == TestConcurrencyobserverEvent.onError) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onError but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onError != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                } else if (e == TestConcurrencyobserverEvent.onCompleted) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onCompleted but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onCompleted != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                }
-            }
-
-            return nextCount;
-        }
-
-    }
-
-    /**
-     * This spawns a single thread for the subscribe execution
-     */
-    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
-
-        final Subscription s;
-        final String[] values;
-        private Thread t = null;
-
-        public TestSingleThreadedObservable(final Subscription s, final String... values) {
-            this.s = s;
-            this.values = values;
-
-        }
-
-        public Subscription onSubscribe(final Observer<? super String> observer) {
-            System.out.println("TestSingleThreadedObservable subscribed to ...");
-            t = new Thread(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        System.out.println("running TestSingleThreadedObservable thread");
-                        for (String s : values) {
-                            System.out.println("TestSingleThreadedObservable onNext: " + s);
-                            observer.onNext(s);
-                        }
-                        observer.onCompleted();
-                    } catch (Throwable e) {
-                        throw new RuntimeException(e);
-                    }
-                }
-
-            });
-            System.out.println("starting TestSingleThreadedObservable thread");
-            t.start();
-            System.out.println("done starting TestSingleThreadedObservable thread");
-            return s;
-        }
-
-        public void waitToFinish() {
-            try {
-                t.join();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        }
-
-    }
-
-    /**
-     * This spawns a thread for the subscription, then a separate thread for each onNext call.
-     */
-    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
-
-        final Subscription s;
-        final String[] values;
-        Thread t = null;
-        AtomicInteger threadsRunning = new AtomicInteger();
-        AtomicInteger maxConcurrentThreads = new AtomicInteger();
-        ExecutorService threadPool;
-
-        public TestMultiThreadedObservable(Subscription s, String... values) {
-            this.s = s;
-            this.values = values;
-            this.threadPool = Executors.newCachedThreadPool();
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
-            System.out.println("TestMultiThreadedObservable subscribed to ...");
-            t = new Thread(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        System.out.println("running TestMultiThreadedObservable thread");
-                        for (final String s : values) {
-                            threadPool.execute(new Runnable() {
-
-                                @Override
-                                public void run() {
-                                    threadsRunning.incrementAndGet();
-                                    try {
-                                        // perform onNext call
-                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
-                                        if (s == null) {
-                                            // force an error
-                                            throw new NullPointerException();
-                                        }
-                                        observer.onNext(s);
-                                        // capture 'maxThreads'
-                                        int concurrentThreads = threadsRunning.get();
-                                        int maxThreads = maxConcurrentThreads.get();
-                                        if (concurrentThreads > maxThreads) {
-                                            maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-                                        }
-                                    } catch (Throwable e) {
-                                        observer.onError(e);
-                                    } finally {
-                                        threadsRunning.decrementAndGet();
-                                    }
-                                }
-                            });
-                        }
-                        // we are done spawning threads
-                        threadPool.shutdown();
-                    } catch (Throwable e) {
-                        throw new RuntimeException(e);
-                    }
-
-                    // wait until all threads are done, then mark it as COMPLETED
-                    try {
-                        // wait for all the threads to finish
-                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
-                    } catch (InterruptedException e) {
-                        throw new RuntimeException(e);
-                    }
-                    observer.onCompleted();
-                }
-            });
-            System.out.println("starting TestMultiThreadedObservable thread");
-            t.start();
-            System.out.println("done starting TestMultiThreadedObservable thread");
-            return s;
-        }
-
-        public void waitToFinish() {
-            try {
-                t.join();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-        }
-    }
-
-    private static class BusyObserver extends Subscriber<String> {
-        volatile boolean onCompleted = false;
-        volatile boolean onError = false;
-        AtomicInteger onNextCount = new AtomicInteger();
-        AtomicInteger threadsRunning = new AtomicInteger();
-        AtomicInteger maxConcurrentThreads = new AtomicInteger();
-
-        @Override
-        public void onCompleted() {
-            threadsRunning.incrementAndGet();
-
-            System.out.println(">>> Busyobserver received onCompleted");
-            onCompleted = true;
-
-            int concurrentThreads = threadsRunning.get();
-            int maxThreads = maxConcurrentThreads.get();
-            if (concurrentThreads > maxThreads) {
-                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-            }
-            threadsRunning.decrementAndGet();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            threadsRunning.incrementAndGet();
-
-            System.out.println(">>> Busyobserver received onError: " + e.getMessage());
-            onError = true;
-
-            int concurrentThreads = threadsRunning.get();
-            int maxThreads = maxConcurrentThreads.get();
-            if (concurrentThreads > maxThreads) {
-                maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-            }
-            threadsRunning.decrementAndGet();
-        }
-
-        @Override
-        public void onNext(String args) {
-            threadsRunning.incrementAndGet();
-            try {
-                onNextCount.incrementAndGet();
-                System.out.println(">>> Busyobserver received onNext: " + args);
-                try {
-                    // simulate doing something computational
-                    Thread.sleep(200);
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-            } finally {
-                // capture 'maxThreads'
-                int concurrentThreads = threadsRunning.get();
-                int maxThreads = maxConcurrentThreads.get();
-                if (concurrentThreads > maxThreads) {
-                    maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads);
-                }
-                threadsRunning.decrementAndGet();
-            }
-        }
-
-    }
-
-    private static class ExternalBusyThread extends Thread {
-
-        private BusyObserver observer;
-        private Object lock;
-        private int lockTimes;
-        private int waitTime;
-        public volatile boolean fail;
-
-        public ExternalBusyThread(BusyObserver observer, Object lock, int lockTimes, int waitTime) {
-            this.observer = observer;
-            this.lock = lock;
-            this.lockTimes = lockTimes;
-            this.waitTime = waitTime;
-            this.fail = false;
-        }
-
-        @Override
-        public void run() {
-            Random r = new Random();
-            for (int i = 0; i < lockTimes; i++) {
-                synchronized (lock) {
-                    int oldOnNextCount = observer.onNextCount.get();
-                    boolean oldOnCompleted = observer.onCompleted;
-                    boolean oldOnError = observer.onError;
-                    try {
-                        Thread.sleep(r.nextInt(waitTime));
-                    } catch (InterruptedException e) {
-                        // ignore
-                    }
-                    // Since we own the lock, onNextCount, onCompleted and
-                    // onError must not be changed.
-                    int newOnNextCount = observer.onNextCount.get();
-                    boolean newOnCompleted = observer.onCompleted;
-                    boolean newOnError = observer.onError;
-                    if (oldOnNextCount != newOnNextCount) {
-                        System.out.println(">>> ExternalBusyThread received different onNextCount: "
-                                + oldOnNextCount
-                                + " -> "
-                                + newOnNextCount);
-                        fail = true;
-                        break;
-                    }
-                    if (oldOnCompleted != newOnCompleted) {
-                        System.out.println(">>> ExternalBusyThread received different onCompleted: "
-                                + oldOnCompleted
-                                + " -> "
-                                + newOnCompleted);
-                        fail = true;
-                        break;
-                    }
-                    if (oldOnError != newOnError) {
-                        System.out.println(">>> ExternalBusyThread received different onError: "
-                                + oldOnError
-                                + " -> "
-                                + newOnError);
-                        fail = true;
-                        break;
-                    }
-                }
-            }
-        }
-
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/util/AssertObservable.java b/rxjava-core/src/test/java/rx/util/AssertObservable.java
index 571bf7df63..f2249aa60b 100644
--- a/rxjava-core/src/test/java/rx/util/AssertObservable.java
+++ b/rxjava-core/src/test/java/rx/util/AssertObservable.java
@@ -137,7 +137,7 @@ public Notification<String> call(Notification<String> a, Notification<String> b)
             }
         };
 
-        Observable<Void> outcomeObservable = Observable.zip(expected.materialize(), actual.materialize(), zipFunction).aggregate(accumulator).map(new Func1<Notification<String>, Notification<Void>>() {
+        Observable<Void> outcomeObservable = Observable.zip(expected.materialize(), actual.materialize(), zipFunction).reduce(accumulator).map(new Func1<Notification<String>, Notification<Void>>() {
             @Override
             public Notification<Void> call(Notification<String> outcome) {
                 if (outcome.isOnError()) {

From f5d8f210214aa3890c72f5a9cdc6ba43275a5075 Mon Sep 17 00:00:00 2001
From: pron <ron.pressler@gmail.com>
Date: Sun, 20 Apr 2014 15:17:35 +0300
Subject: [PATCH 242/422] close #1054

---
 rxjava-contrib/rxjava-quasar/build.gradle                       | 2 ++
 .../rxjava-quasar/src/main/resources/META-INF/suspendables      | 1 +
 2 files changed, 3 insertions(+)

diff --git a/rxjava-contrib/rxjava-quasar/build.gradle b/rxjava-contrib/rxjava-quasar/build.gradle
index fdcac9663f..c7fd1dbb83 100644
--- a/rxjava-contrib/rxjava-quasar/build.gradle
+++ b/rxjava-contrib/rxjava-quasar/build.gradle
@@ -32,9 +32,11 @@ jar {
 }
 
 tasks.withType(Test) {
+    // systemProperty 'co.paralleluniverse.fibers.verifyInstrumentation', 'true'
     jvmArgs "-javaagent:${configurations.quasar.iterator().next()}" // =vdmc (verbose, debug, allow monitors, check class)
 }
 
 tasks.withType(JavaExec) {
+    // systemProperty 'co.paralleluniverse.fibers.verifyInstrumentation', 'true'
     jvmArgs "-javaagent:${configurations.quasar.iterator().next()}" // =vdmc (verbose, debug, allow monitors, check class)
 }
diff --git a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
index d364ba2406..bcdf11a8d3 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
+++ b/rxjava-contrib/rxjava-quasar/src/main/resources/META-INF/suspendables
@@ -1 +1,2 @@
 rx.Observable.subscribe
+rx.Observable$2.call

From 6b4d8f57a03c06214cd1d516b66e4301dfb886cc Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 20 Apr 2014 21:05:58 +0800
Subject: [PATCH 243/422] Add drop and dropRight to rxscala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 26 ++++++
 .../main/scala/rx/lang/scala/Observable.scala | 81 +++++++++++++++++++
 rxjava-core/src/main/java/rx/Observable.java  |  6 +-
 3 files changed, 112 insertions(+), 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 e5746fc2a7..8d04e9f053 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
@@ -400,6 +400,32 @@ class RxScalaDemo extends JUnitSuite {
     assertEquals(1, List(1).toObservable.toBlockingObservable.single)
   }
 
+  @Test def dropExample() {
+    val o = List(1, 2, 3, 4).toObservable
+    assertEquals(List(3, 4), o.drop(2).toBlockingObservable.toList)
+  }
+
+  @Test def dropWithTimeExample() {
+    val o = List(1, 2, 3, 4).toObservable.zip(
+      Observable.interval(500 millis, IOScheduler())).map(_._1) // emit every 500 millis
+    println(
+      o.drop(1250 millis, IOScheduler()).toBlockingObservable.toList // output List(3, 4)
+    )
+  }
+
+  @Test def dropRightExample() {
+    val o = List(1, 2, 3, 4).toObservable
+    assertEquals(List(1, 2), o.dropRight(2).toBlockingObservable.toList)
+  }
+
+  @Test def dropRightWithTimeExample() {
+    val o = List(1, 2, 3, 4).toObservable.zip(
+      Observable.interval(500 millis, IOScheduler())).map(_._1) // emit every 500 millis
+    println(
+      o.dropRight(750 millis, IOScheduler()).toBlockingObservable.toList // output List(1, 2)
+    )
+  }
+
   def square(x: Int): Int = {
     println(s"$x*$x is being calculated on thread ${Thread.currentThread().getId}")
     Thread.sleep(100) // calculating a square is heavy work :)
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 56171b4853..4595127bde 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
@@ -1231,6 +1231,35 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.skip(n))
   }
 
+  /**
+   * Returns an Observable that drops values emitted by the source Observable before a specified time window
+   * elapses.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.t.png">
+   *
+   * @param time the length of the time window to drop
+   * @return an Observable that drops values emitted by the source Observable before the time window defined
+   *         by `time` elapses and emits the remainder
+   */
+  def drop(time: Duration): Observable[T] = {
+    toScalaObservable(asJavaObservable.skip(time.length, time.unit))
+  }
+
+  /**
+   * Returns an Observable that drops values emitted by the source Observable before a specified time window
+   * elapses.
+   *
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.t.png">
+   *
+   * @param time the length of the time window to drop
+   * @param scheduler the `Scheduler` on which the timed wait happens
+   * @return an Observable that drops values emitted by the source Observable before the time window defined
+   *         by `time` elapses and emits the remainder
+   */
+  def drop(time: Duration, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable(asJavaObservable.skip(time.length, time.unit, scheduler))
+  }
+
   /**
    * Returns an Observable that bypasses all items from the source Observable as long as the specified
    * condition holds true. Emits all further source items as soon as the condition becomes false.
@@ -1246,6 +1275,58 @@ trait Observable[+T]
     toScalaObservable(asJavaObservable.skipWhile(predicate))
   }
 
+  /**
+   * Returns an Observable that drops a specified number of items from the end of the sequence emitted by the
+   * source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.png">
+   * <p>
+   * This Observer accumulates a queue long enough to store the first `n` 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 n 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
+   * @throws IndexOutOfBoundsException if `n` is less than zero
+   */
+  def dropRight(n: Int): Observable[T] = {
+    toScalaObservable(asJavaObservable.skipLast(n))
+  }
+
+  /**
+   * Returns an Observable that drops items emitted by the source Observable during a specified time window
+   * before the source completes.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.t.png">
+   *
+   * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
+   *
+   * @param time the length of the time window
+   * @return an Observable that drops those items emitted by the source Observable in a time window before the
+   *         source completes defined by `time`
+   */
+  def dropRight(time: Duration): Observable[T] = {
+    toScalaObservable(asJavaObservable.skipLast(time.length, time.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.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.ts.png">
+   *
+   * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
+   *
+   * @param time the length of the time window
+   * @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 `time` and `scheduler`
+   */
+  def dropRight(time: Duration, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable(asJavaObservable.skipLast(time.length, time.unit, scheduler))
+  }
+
   /**
    * Returns an Observable that emits only the first `num` items emitted by the source
    * Observable.
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 297d715318..0c7e64802e 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5566,6 +5566,8 @@ public final Observable<T> skipLast(int count) {
      * before the source completes.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.t.png">
+     *
+     * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
      * 
      * @param time
      *            the length of the time window
@@ -5585,7 +5587,9 @@ public final Observable<T> skipLast(long time, TimeUnit unit) {
      * (defined on a specified scheduler) before the source completes.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.ts.png">
-     * 
+     *
+     * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
+     *
      * @param time
      *            the length of the time window
      * @param unit

From b07bae9669e5e6e20ded9dcec8a4a6328969d277 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 20 Apr 2014 22:48:23 +0800
Subject: [PATCH 244/422] Fix issue #1044

---
 .../scala/rx/lang/scala/examples/RxScalaDemo.scala     | 10 ++++++++++
 .../src/main/scala/rx/lang/scala/Observable.scala      |  2 +-
 2 files changed, 11 insertions(+), 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 e5746fc2a7..825c0ce5fb 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
@@ -609,4 +609,14 @@ class RxScalaDemo extends JUnitSuite {
     val m = o.toMap(keySelector, valueSelector, mapFactory)
     println(m.toBlockingObservable.single)
   }
+
+  @Test def retryExample1(): Unit = {
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable
+    assertEquals(List("alice", "bob", "carol"), o.retry.toBlockingObservable.toList)
+  }
+
+  @Test def retryExample2(): Unit = {
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable
+    assertEquals(List("alice", "bob", "carol"), o.retry(3).toBlockingObservable.toList)
+  }
 }
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 56171b4853..79780493cd 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
@@ -2115,7 +2115,7 @@ trait Observable[+T]
    * emits [1, 2, 3, 4, 5] then the complete output would be [1, 2, 1, 2, 3, 4, 5, onCompleted].
    * @return Observable with retry logic.
    */
-  def retry: Observable[T] = {
+  def retry(): Observable[T] = {
     toScalaObservable[T](asJavaObservable.retry())
   }
 

From f959dfd92eeacf3d4e741a04a90ff76620e2fa89 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 21 Apr 2014 18:48:14 +0800
Subject: [PATCH 245/422] Deprecate Observable.apply

---
 .../src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala | 2 +-
 .../rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala  | 1 +
 2 files changed, 2 insertions(+), 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 825c0ce5fb..d763bc0f3f 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
@@ -578,7 +578,7 @@ class RxScalaDemo extends JUnitSuite {
 
   @Test def elementAtExample(): Unit = {
     val o = List("red", "green", "blue").toObservable
-    println(o(2).toBlockingObservable.single)
+    println(o.elementAt(2).toBlockingObservable.single)
   }
 
   @Test def elementAtOrDefaultExample(): Unit = {
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 79780493cd..13cfbf86d2 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
@@ -2350,6 +2350,7 @@ trait Observable[+T]
    * @throws IndexOutOfBoundsException
    *             if index is less than 0
    * @see `Observable.elementAt`
+   * @deprecated("Use `elementAt`", "0.18.0")
    */
   def apply(index: Int): Observable[T] = elementAt(index)
 

From 65d86eb406ab328ead6d001c13794eb3a9646f9b Mon Sep 17 00:00:00 2001
From: Jacek Laskowski <jacek@japila.pl>
Date: Mon, 21 Apr 2014 21:47:58 +0200
Subject: [PATCH 246/422] typo

---
 .../rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala  | 2 +-
 1 file changed, 1 insertion(+), 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 56171b4853..8e5d75f96b 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
@@ -2526,7 +2526,7 @@ object Observable {
   */
 
   /**
-   * Returns an Observable that will execute the specified function when a someone subscribes to it.
+   * Returns an Observable that will execute the specified function when someone subscribes to it.
    *
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/create.png">
    *

From f4d468fc1dac20244e5ec6631cfcc1274ae43e24 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 22 Apr 2014 10:56:11 +0200
Subject: [PATCH 247/422] OperatorAll

---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 .../main/java/rx/operators/OperationAll.java  | 90 -------------------
 .../main/java/rx/operators/OperatorAll.java   | 73 +++++++++++++++
 ...ationAllTest.java => OperatorAllTest.java} | 19 ++--
 4 files changed, 84 insertions(+), 102 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationAll.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorAll.java
 rename rxjava-core/src/test/java/rx/operators/{OperationAllTest.java => OperatorAllTest.java} (84%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 0c7e64802e..e5eccfe598 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -48,7 +48,7 @@
 import rx.observers.SafeSubscriber;
 import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
-import rx.operators.OperationAll;
+import rx.operators.OperatorAll;
 import rx.operators.OperationAny;
 import rx.operators.OperationAsObservable;
 import rx.operators.OperationBuffer;
@@ -2941,7 +2941,7 @@ public final static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Ob
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-all">RxJava Wiki: all()</a>
      */
     public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
-        return create(OperationAll.all(this, predicate));
+        return lift(new OperatorAll<T>(predicate));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAll.java b/rxjava-core/src/main/java/rx/operators/OperationAll.java
deleted file mode 100644
index 9ad2d942ad..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationAll.java
+++ /dev/null
@@ -1,90 +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.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func1;
-
-/**
- * Returns an Observable that emits a Boolean that indicates whether all items emitted by an
- * Observable satisfy a condition.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/all.png">
- */
-public class OperationAll {
-
-    public static <T> OnSubscribeFunc<Boolean> all(Observable<? extends T> sequence, Func1<? super T, Boolean> predicate) {
-        return new AllObservable<T>(sequence, predicate);
-    }
-
-    private static class AllObservable<T> implements OnSubscribeFunc<Boolean> {
-        private final Observable<? extends T> sequence;
-        private final Func1<? super T, Boolean> predicate;
-
-        private AllObservable(Observable<? extends T> sequence, Func1<? super T, Boolean> predicate) {
-            this.sequence = sequence;
-            this.predicate = predicate;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super Boolean> observer) {
-            return sequence.unsafeSubscribe(new AllObserver(observer));
-
-        }
-
-        private class AllObserver extends Subscriber<T> {
-            private final Observer<? super Boolean> underlying;
-
-            private final AtomicBoolean status = new AtomicBoolean(true);
-
-            public AllObserver(Observer<? super Boolean> underlying) {
-                this.underlying = underlying;
-            }
-
-            @Override
-            public void onCompleted() {
-                if (status.get()) {
-                    underlying.onNext(true);
-                    underlying.onCompleted();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                underlying.onError(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                boolean result = predicate.call(args);
-                boolean changed = status.compareAndSet(true, result);
-
-                if (changed && !result) {
-                    underlying.onNext(false);
-                    underlying.onCompleted();
-                    unsubscribe();
-                }
-            }
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAll.java b/rxjava-core/src/main/java/rx/operators/OperatorAll.java
new file mode 100644
index 0000000000..7b1124836f
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAll.java
@@ -0,0 +1,73 @@
+/**
+ * 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.AtomicBoolean;
+
+import rx.Observable;
+import rx.Observable.OnSubscribeFunc;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.functions.Func1;
+
+/**
+ * Returns an Observable that emits a Boolean that indicates whether all items emitted by an
+ * Observable satisfy a condition.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/all.png">
+ */
+public final class OperatorAll<T> implements Operator<Boolean, T> {
+    private final Func1<? super T, Boolean> predicate;
+
+    public OperatorAll(Func1<? super T, Boolean> predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super Boolean> child) {
+        Subscriber s = new Subscriber<T>() {
+            boolean done;
+            @Override
+            public void onNext(T t) {
+                boolean result = predicate.call(t);
+                if (!result && !done) {
+                    done = true;
+                    child.onNext(false);
+                    child.onCompleted();
+                    unsubscribe();
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!done) {
+                    done = true;
+                    child.onNext(true);
+                    child.onCompleted();
+                }
+            }
+        };
+        child.add(s);
+        return s;
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAllTest.java
similarity index 84%
rename from rxjava-core/src/test/java/rx/operators/OperationAllTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorAllTest.java
index c76fad7a13..a36933ce27 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAllTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAllTest.java
@@ -18,7 +18,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static rx.operators.OperationAll.all;
 
 import org.junit.Test;
 
@@ -26,7 +25,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 
-public class OperationAllTest {
+public class OperatorAllTest {
 
     @Test
     @SuppressWarnings("unchecked")
@@ -34,12 +33,12 @@ public void testAll() {
         Observable<String> obs = Observable.from("one", "two", "six");
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
+        obs.all(new Func1<String, Boolean>() {
             @Override
             public Boolean call(String s) {
                 return s.length() == 3;
             }
-        })).subscribe(observer);
+        }).subscribe(observer);
 
         verify(observer).onNext(true);
         verify(observer).onCompleted();
@@ -52,12 +51,12 @@ public void testNotAll() {
         Observable<String> obs = Observable.from("one", "two", "three", "six");
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
+        obs.all(new Func1<String, Boolean>() {
             @Override
             public Boolean call(String s) {
                 return s.length() == 3;
             }
-        })).subscribe(observer);
+        }).subscribe(observer);
 
         verify(observer).onNext(false);
         verify(observer).onCompleted();
@@ -70,12 +69,12 @@ public void testEmpty() {
         Observable<String> obs = Observable.empty();
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
+        obs.all(new Func1<String, Boolean>() {
             @Override
             public Boolean call(String s) {
                 return s.length() == 3;
             }
-        })).subscribe(observer);
+        }).subscribe(observer);
 
         verify(observer).onNext(true);
         verify(observer).onCompleted();
@@ -89,12 +88,12 @@ public void testError() {
         Observable<String> obs = Observable.error(error);
 
         Observer<Boolean> observer = mock(Observer.class);
-        Observable.create(all(obs, new Func1<String, Boolean>() {
+        obs.all(new Func1<String, Boolean>() {
             @Override
             public Boolean call(String s) {
                 return s.length() == 3;
             }
-        })).subscribe(observer);
+        }).subscribe(observer);
 
         verify(observer).onError(error);
         verifyNoMoreInteractions(observer);

From fbaa5e08393df234c5661feda7d2393dc8e0ac15 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 22 Apr 2014 11:36:00 +0200
Subject: [PATCH 248/422] OperatorAny

---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../main/java/rx/operators/OperationAny.java  | 127 ------------------
 .../main/java/rx/operators/OperatorAny.java   |  76 +++++++++++
 .../java/rx/operators/OperationAnyTest.java   |  32 +++--
 4 files changed, 94 insertions(+), 147 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationAny.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorAny.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 0c7e64802e..7e5221defa 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -49,7 +49,7 @@
 import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationAll;
-import rx.operators.OperationAny;
+import rx.operators.OperatorAny;
 import rx.operators.OperationAsObservable;
 import rx.operators.OperationBuffer;
 import rx.operators.OperationCombineLatest;
@@ -3893,7 +3893,7 @@ public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211993.aspx">MSDN: Observable.Any (Note: the description in this page was wrong at the time of this writing)</a>
      */
     public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
-        return create(OperationAny.exists(this, predicate));
+        return lift(new OperatorAny<T>(predicate, false));
     }
 
     /**
@@ -4126,7 +4126,7 @@ public final Observable<T> ignoreElements() {
      * @see <a href= "http://msdn.microsoft.com/en-us/library/hh229905.aspx">MSDN: Observable.Any</a>
      */
     public final Observable<Boolean> isEmpty() {
-        return create(OperationAny.isEmpty(this));
+        return lift(new OperatorAny<T>(Functions.alwaysTrue(), true)); // create(OperatorAny.isEmpty(this));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAny.java b/rxjava-core/src/main/java/rx/operators/OperationAny.java
deleted file mode 100644
index b64bf419c7..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationAny.java
+++ /dev/null
@@ -1,127 +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 rx.functions.Functions.alwaysTrue;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func1;
-
-/**
- * Returns an {@link Observable} that emits <code>true</code> if any element of
- * an observable sequence satisfies a condition, otherwise <code>false</code>.
- */
-public final class OperationAny {
-
-    /**
-     * Returns an {@link Observable} that emits <code>true</code> if the source {@link Observable} is not empty, otherwise <code>false</code>.
-     * 
-     * @param source
-     *            The source {@link Observable} to check if not empty.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T> OnSubscribeFunc<Boolean> any(Observable<? extends T> source) {
-        return new Any<T>(source, alwaysTrue(), false);
-    }
-
-    public static <T> OnSubscribeFunc<Boolean> isEmpty(Observable<? extends T> source) {
-        return new Any<T>(source, alwaysTrue(), true);
-    }
-
-    /**
-     * Returns an {@link Observable} that emits <code>true</code> if any element
-     * of the source {@link Observable} satisfies the given condition, otherwise
-     * <code>false</code>. Note: always emit <code>false</code> if the source {@link Observable} is empty.
-     * 
-     * @param source
-     *            The source {@link Observable} to check if any element
-     *            satisfies the given condition.
-     * @param predicate
-     *            The condition to test every element.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T> OnSubscribeFunc<Boolean> any(Observable<? extends T> source, Func1<? super T, Boolean> predicate) {
-        return new Any<T>(source, predicate, false);
-    }
-
-    public static <T> OnSubscribeFunc<Boolean> exists(Observable<? extends T> source, Func1<? super T, Boolean> predicate) {
-        return any(source, predicate);
-    }
-
-    private static class Any<T> implements OnSubscribeFunc<Boolean> {
-
-        private final Observable<? extends T> source;
-        private final Func1<? super T, Boolean> predicate;
-        private final boolean returnOnEmpty;
-
-        private Any(Observable<? extends T> source, Func1<? super T, Boolean> predicate, boolean returnOnEmpty) {
-            this.source = source;
-            this.predicate = predicate;
-            this.returnOnEmpty = returnOnEmpty;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super Boolean> observer) {
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(source.unsafeSubscribe(new Subscriber<T>() {
-
-                private final AtomicBoolean hasEmitted = new AtomicBoolean(false);
-
-                @Override
-                public void onNext(T value) {
-                    try {
-                        if (hasEmitted.get() == false) {
-                            if (predicate.call(value) == true
-                                    && hasEmitted.getAndSet(true) == false) {
-                                observer.onNext(!returnOnEmpty);
-                                observer.onCompleted();
-                                // this will work if the sequence is asynchronous, it
-                                // will have no effect on a synchronous observable
-                                subscription.unsubscribe();
-                            }
-                        }
-                    } 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();
-                    }
-
-                }
-
-                @Override
-                public void onError(Throwable ex) {
-                    observer.onError(ex);
-                }
-
-                @Override
-                public void onCompleted() {
-                    if (!hasEmitted.get()) {
-                        observer.onNext(returnOnEmpty);
-                        observer.onCompleted();
-                    }
-                }
-            }));
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAny.java b/rxjava-core/src/main/java/rx/operators/OperatorAny.java
new file mode 100644
index 0000000000..4dee1e2c8d
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAny.java
@@ -0,0 +1,76 @@
+/**
+ * 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.functions.Func1;
+
+/**
+ * Returns an {@link Observable} that emits <code>true</code> if any element of
+ * an observable sequence satisfies a condition, otherwise <code>false</code>.
+ */
+public final class OperatorAny<T> implements Operator<Boolean, T> {
+    private final Func1<? super T, Boolean> predicate;
+    private final boolean returnOnEmpty;
+
+    public OperatorAny(Func1<? super T, Boolean> predicate, boolean returnOnEmpty) {
+        this.predicate = predicate;
+        this.returnOnEmpty = returnOnEmpty;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super Boolean> child) {
+        Subscriber<T> s = new Subscriber<T>() {
+            boolean hasElements;
+            boolean done;
+            @Override
+            public void onNext(T t) {
+                hasElements = true;
+                boolean result = predicate.call(t);
+                if (result && !done) {
+                    done = true;
+                    child.onNext(!returnOnEmpty);
+                    child.onCompleted();
+                    unsubscribe();
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!done) {
+                    done = true;
+                    if (hasElements) {
+                        child.onNext(false);
+                    } else {
+                        child.onNext(returnOnEmpty);
+                    }
+                    child.onCompleted();
+                }
+            }
+            
+        };
+        child.add(s);
+        return s;
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
index d2687a90f7..b664949fff 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
@@ -19,22 +19,20 @@
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationAny.any;
-import static rx.operators.OperationAny.exists;
-import static rx.operators.OperationAny.isEmpty;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
 import rx.functions.Func1;
+import rx.functions.Functions;
 
 public class OperationAnyTest {
 
     @Test
     public void testAnyWithTwoItems() {
         Observable<Integer> w = Observable.from(1, 2);
-        Observable<Boolean> observable = Observable.create(any(w));
+        Observable<Boolean> observable = w.exists(Functions.alwaysTrue());
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -48,7 +46,7 @@ public void testAnyWithTwoItems() {
     @Test
     public void testIsEmptyWithTwoItems() {
         Observable<Integer> w = Observable.from(1, 2);
-        Observable<Boolean> observable = Observable.create(isEmpty(w));
+        Observable<Boolean> observable = w.isEmpty();
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -62,7 +60,7 @@ public void testIsEmptyWithTwoItems() {
     @Test
     public void testAnyWithOneItem() {
         Observable<Integer> w = Observable.from(1);
-        Observable<Boolean> observable = Observable.create(any(w));
+        Observable<Boolean> observable = w.exists(Functions.alwaysTrue());
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -76,7 +74,7 @@ public void testAnyWithOneItem() {
     @Test
     public void testIsEmptyWithOneItem() {
         Observable<Integer> w = Observable.from(1);
-        Observable<Boolean> observable = Observable.create(isEmpty(w));
+        Observable<Boolean> observable = w.isEmpty();
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -90,7 +88,7 @@ public void testIsEmptyWithOneItem() {
     @Test
     public void testAnyWithEmpty() {
         Observable<Integer> w = Observable.empty();
-        Observable<Boolean> observable = Observable.create(any(w));
+        Observable<Boolean> observable = w.exists(Functions.alwaysTrue());
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -104,7 +102,7 @@ public void testAnyWithEmpty() {
     @Test
     public void testIsEmptyWithEmpty() {
         Observable<Integer> w = Observable.empty();
-        Observable<Boolean> observable = Observable.create(isEmpty(w));
+        Observable<Boolean> observable = w.isEmpty();
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -118,14 +116,14 @@ public void testIsEmptyWithEmpty() {
     @Test
     public void testAnyWithPredicate1() {
         Observable<Integer> w = Observable.from(1, 2, 3);
-        Observable<Boolean> observable = Observable.create(any(w,
+        Observable<Boolean> observable = w.exists(
                 new Func1<Integer, Boolean>() {
 
                     @Override
                     public Boolean call(Integer t1) {
                         return t1 < 2;
                     }
-                }));
+                });
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -139,14 +137,14 @@ public Boolean call(Integer t1) {
     @Test
     public void testExists1() {
         Observable<Integer> w = Observable.from(1, 2, 3);
-        Observable<Boolean> observable = Observable.create(exists(w,
+        Observable<Boolean> observable = w.exists(
                 new Func1<Integer, Boolean>() {
 
                     @Override
                     public Boolean call(Integer t1) {
                         return t1 < 2;
                     }
-                }));
+                });
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -160,14 +158,14 @@ public Boolean call(Integer t1) {
     @Test
     public void testAnyWithPredicate2() {
         Observable<Integer> w = Observable.from(1, 2, 3);
-        Observable<Boolean> observable = Observable.create(any(w,
+        Observable<Boolean> observable = w.exists(
                 new Func1<Integer, Boolean>() {
 
                     @Override
                     public Boolean call(Integer t1) {
                         return t1 < 1;
                     }
-                }));
+                });
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);
@@ -182,14 +180,14 @@ public Boolean call(Integer t1) {
     public void testAnyWithEmptyAndPredicate() {
         // If the source is empty, always output false.
         Observable<Integer> w = Observable.empty();
-        Observable<Boolean> observable = Observable.create(any(w,
+        Observable<Boolean> observable = w.exists(
                 new Func1<Integer, Boolean>() {
 
                     @Override
                     public Boolean call(Integer t1) {
                         return true;
                     }
-                }));
+                });
 
         @SuppressWarnings("unchecked")
         Observer<Boolean> observer = mock(Observer.class);

From 77e27713eae8decb8369c4f2e27df4144f205257 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 22 Apr 2014 17:48:03 +0800
Subject: [PATCH 249/422] Fix bugs in equals and hashCode

---
 rxjava-core/src/main/java/rx/schedulers/Timestamped.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/Timestamped.java b/rxjava-core/src/main/java/rx/schedulers/Timestamped.java
index c75da13ae8..ac2c110a7e 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Timestamped.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Timestamped.java
@@ -50,6 +50,9 @@ public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
+        if (obj == null) {
+            return false;
+        }
         if (!(obj instanceof Timestamped)) {
             return false;
         }
@@ -71,7 +74,7 @@ public boolean equals(Object obj) {
     public int hashCode() {
         final int prime = 31;
         int result = 1;
-        result = prime * result + (int) (timestampMillis ^ (timestampMillis));
+        result = prime * result + (int) (timestampMillis ^ (timestampMillis >>> 32));
         result = prime * result + ((value == null) ? 0 : value.hashCode());
         return result;
     }

From 073418f72f1ab9c865f20d554a29d4a9b1b08001 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 22 Apr 2014 12:38:39 +0200
Subject: [PATCH 250/422] OperatorAsObservable

---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 ...ervable.java => OperatorAsObservable.java} | 19 ++----
 .../operators/OperatorAsObservableTest.java   | 65 +++++++++++++++++++
 3 files changed, 73 insertions(+), 15 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationAsObservable.java => OperatorAsObservable.java} (61%)
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 0c7e64802e..81d76ca63e 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -50,7 +50,7 @@
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationAll;
 import rx.operators.OperationAny;
-import rx.operators.OperationAsObservable;
+import rx.operators.OperatorAsObservable;
 import rx.operators.OperationBuffer;
 import rx.operators.OperationCombineLatest;
 import rx.operators.OperationConcat;
@@ -2952,7 +2952,7 @@ public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
      * @return an Observable that hides the identity of this Observable
      */
     public final Observable<T> asObservable() {
-        return create(new OperationAsObservable<T>(this));
+        return lift(new OperatorAsObservable<T>());
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorAsObservable.java
similarity index 61%
rename from rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
rename to rxjava-core/src/main/java/rx/operators/OperatorAsObservable.java
index d5c907ff5d..e675311ad9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationAsObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAsObservable.java
@@ -15,11 +15,8 @@
  */
 package rx.operators;
 
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-import rx.observers.Subscribers;
+import rx.Observable.Operator;
+import rx.Subscriber;
 
 /**
  * Hides the identity of another observable.
@@ -27,15 +24,11 @@
  * @param <T>
  *            the return value type of the wrapped observable.
  */
-public final class OperationAsObservable<T> implements OnSubscribeFunc<T> {
-    private final Observable<? extends T> source;
-
-    public OperationAsObservable(Observable<? extends T> source) {
-        this.source = source;
-    }
+public final class OperatorAsObservable<T> implements Operator<T, T> {
 
     @Override
-    public Subscription onSubscribe(final Observer<? super T> t1) {
-        return source.unsafeSubscribe(Subscribers.from(t1));
+    public Subscriber<? super T> call(Subscriber<? super T> t1) {
+        return t1;
     }
+    
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java
new file mode 100644
index 0000000000..f1eb08e345
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.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 static org.junit.Assert.assertFalse;
+import org.junit.Test;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+import rx.Observable;
+import rx.Observer;
+import rx.subjects.PublishSubject;
+
+public class OperatorAsObservableTest {
+    @Test
+    public void testHiding() {
+        PublishSubject<Integer> src = PublishSubject.create();
+        
+        Observable<Integer> dst = src.asObservable();
+        
+        assertFalse(dst instanceof PublishSubject);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        dst.subscribe(o);
+        
+        src.onNext(1);
+        src.onCompleted();
+        
+        verify(o).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testHidingError() {
+        PublishSubject<Integer> src = PublishSubject.create();
+        
+        Observable<Integer> dst = src.asObservable();
+        
+        assertFalse(dst instanceof PublishSubject);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        dst.subscribe(o);
+        
+        src.onError(new OperationReduceTest.CustomException());
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+}

From e679dba0a4f06e8f9df08600b637638e033b73ab Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 22 Apr 2014 12:39:07 +0200
Subject: [PATCH 251/422] OperatorAsObservable LF

---
 .../operators/OperatorAsObservableTest.java   | 130 +++++++++---------
 1 file changed, 65 insertions(+), 65 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java
index f1eb08e345..c1773f1c4d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java
@@ -1,65 +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 static org.junit.Assert.assertFalse;
-import org.junit.Test;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.*;
-import rx.Observable;
-import rx.Observer;
-import rx.subjects.PublishSubject;
-
-public class OperatorAsObservableTest {
-    @Test
-    public void testHiding() {
-        PublishSubject<Integer> src = PublishSubject.create();
-        
-        Observable<Integer> dst = src.asObservable();
-        
-        assertFalse(dst instanceof PublishSubject);
-        
-        Observer<Object> o = mock(Observer.class);
-        
-        dst.subscribe(o);
-        
-        src.onNext(1);
-        src.onCompleted();
-        
-        verify(o).onNext(1);
-        verify(o).onCompleted();
-        verify(o, never()).onError(any(Throwable.class));
-    }
-    @Test
-    public void testHidingError() {
-        PublishSubject<Integer> src = PublishSubject.create();
-        
-        Observable<Integer> dst = src.asObservable();
-        
-        assertFalse(dst instanceof PublishSubject);
-        
-        Observer<Object> o = mock(Observer.class);
-        
-        dst.subscribe(o);
-        
-        src.onError(new OperationReduceTest.CustomException());
-        
-        verify(o, never()).onNext(any());
-        verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
-    }
-}
+/**
+ * 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.assertFalse;
+import org.junit.Test;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+import rx.Observable;
+import rx.Observer;
+import rx.subjects.PublishSubject;
+
+public class OperatorAsObservableTest {
+    @Test
+    public void testHiding() {
+        PublishSubject<Integer> src = PublishSubject.create();
+        
+        Observable<Integer> dst = src.asObservable();
+        
+        assertFalse(dst instanceof PublishSubject);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        dst.subscribe(o);
+        
+        src.onNext(1);
+        src.onCompleted();
+        
+        verify(o).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testHidingError() {
+        PublishSubject<Integer> src = PublishSubject.create();
+        
+        Observable<Integer> dst = src.asObservable();
+        
+        assertFalse(dst instanceof PublishSubject);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        dst.subscribe(o);
+        
+        src.onError(new OperationReduceTest.CustomException());
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+}

From 756e699dfe10ffaf2544a9eb75cba573273636eb Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 22 Apr 2014 21:06:31 +0800
Subject: [PATCH 252/422] Only cache the latest items in the time window

---
 .../main/scala/rx/lang/scala/Observable.scala |  4 +-
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 .../rx/operators/OperatorSkipLastTimed.java   | 45 +++++++++----------
 3 files changed, 25 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 d278ab0270..78b5cedd97 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
@@ -1300,7 +1300,7 @@ trait Observable[+T]
    * <p>
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.t.png">
    *
-   * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
+   * Note: this action will cache the latest items arriving in the specified time window.
    *
    * @param time the length of the time window
    * @return an Observable that drops those items emitted by the source Observable in a time window before the
@@ -1316,7 +1316,7 @@ trait Observable[+T]
    * <p>
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.ts.png">
    *
-   * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
+   * Note: this action will cache the latest items arriving in the specified time window.
    *
    * @param time the length of the time window
    * @param scheduler the scheduler used as the time source
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 0c7e64802e..e03eceed2f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5567,7 +5567,7 @@ public final Observable<T> skipLast(int count) {
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.t.png">
      *
-     * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
+     * Note: this action will cache the latest items arriving in the specified time window.
      * 
      * @param time
      *            the length of the time window
@@ -5588,7 +5588,7 @@ public final Observable<T> skipLast(long time, TimeUnit unit) {
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.ts.png">
      *
-     * Note: this action will cache all items until "onCompleted" arrives. So don't use it on an infinite Observable.
+     * Note: this action will cache the latest items arriving in the specified time window.
      *
      * @param time
      *            the length of the time window
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
index f5d92583c1..cd4e107923 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipLastTimed.java
@@ -15,9 +15,8 @@
  */
 package rx.operators;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.ArrayDeque;
+import java.util.Deque;
 import java.util.concurrent.TimeUnit;
 
 import rx.Observable.Operator;
@@ -42,39 +41,37 @@ public OperatorSkipLastTimed(long time, TimeUnit unit, Scheduler scheduler) {
     public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
         return new Subscriber<T>(subscriber) {
 
-            private List<Timestamped<T>> buffer = new ArrayList<Timestamped<T>>();
+            private Deque<Timestamped<T>> buffer = new ArrayDeque<Timestamped<T>>();
+
+            private void emitItemsOutOfWindow(long now) {
+                long limit = now - timeInMillis;
+                while (!buffer.isEmpty()) {
+                    Timestamped<T> v = buffer.getFirst();
+                    if (v.getTimestampMillis() < limit) {
+                        buffer.removeFirst();
+                        subscriber.onNext(v.getValue());
+                    } else {
+                        break;
+                    }
+                }
+            }
 
             @Override
             public void onNext(T value) {
-                buffer.add(new Timestamped<T>(scheduler.now(), value));
+                long now = scheduler.now();
+                emitItemsOutOfWindow(now);
+                buffer.offerLast(new Timestamped<T>(now, value));
             }
 
             @Override
             public void onError(Throwable e) {
-                buffer = Collections.emptyList();
                 subscriber.onError(e);
             }
 
             @Override
             public void onCompleted() {
-                long limit = scheduler.now() - timeInMillis;
-                try {
-                    for (Timestamped<T> v : buffer) {
-                        if (v.getTimestampMillis() < limit) {
-                            try {
-                                subscriber.onNext(v.getValue());
-                            } catch (Throwable t) {
-                                subscriber.onError(t);
-                                return;
-                            }
-                        } else {
-                            break;
-                        }
-                    }
-                    subscriber.onCompleted();
-                } finally {
-                    buffer = Collections.emptyList();
-                }
+                emitItemsOutOfWindow(scheduler.now());
+                subscriber.onCompleted();
             }
 
         };

From 96b06f9b509ada79f687769e078ff6338e172655 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Tue, 22 Apr 2014 18:00:22 +0200
Subject: [PATCH 253/422] CompositeSubscription fix

---
 .../rx/subscriptions/CompositeSubscription.java     |  2 +-
 .../rx/subscriptions/CompositeSubscriptionTest.java | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index 5aef85181d..f9f045def7 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -72,7 +72,7 @@ State remove(Subscription s) {
             for (Subscription _s : subscriptions) {
                 if (!_s.equals(s)) {
                     // was not in this composite
-                    if (idx == subscriptions.length) {
+                    if (idx == newSubscriptions.length) {
                         return this;
                     }
                     newSubscriptions[idx] = _s;
diff --git a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
index 2e44a69d30..4cff2a3e6a 100644
--- a/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
+++ b/rxjava-core/src/test/java/rx/subscriptions/CompositeSubscriptionTest.java
@@ -324,4 +324,17 @@ public void run() {
         // we should have only unsubscribed once
         assertEquals(1, counter.get());
     }
+    @Test
+    public void testTryRemoveIfNotIn() {
+        CompositeSubscription csub = new CompositeSubscription();
+        
+        CompositeSubscription csub1 = new CompositeSubscription();
+        CompositeSubscription csub2 = new CompositeSubscription();
+        
+        csub.add(csub1);
+        csub.remove(csub1);
+        csub.add(csub2);
+        
+        csub.remove(csub1); // try removing agian
+    }
 }

From 69a1dbd753d1f060df38e47e6179cf05b6b62d63 Mon Sep 17 00:00:00 2001
From: Dave Moten <davidmoten@gmail.com>
Date: Wed, 23 Apr 2014 13:47:29 +1000
Subject: [PATCH 254/422] add synchronous test of resubscribe after error

---
 .../java/rx/operators/OperatorRetryTest.java  | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
index 645895817b..a564e71a10 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRetryTest.java
@@ -18,6 +18,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
 import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -30,6 +31,7 @@
 
 import org.junit.Test;
 import org.mockito.InOrder;
+import org.mockito.Mockito;
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
@@ -118,6 +120,50 @@ public void testInfiniteRetry() {
         inOrder.verify(observer, times(1)).onCompleted();
         inOrder.verifyNoMoreInteractions();
     }
+    
+    /**
+     * Checks in a simple and synchronous way that retry resubscribes
+     * after error. This test fails against 0.16.1-0.17.4, hangs on 0.17.5 and
+     * passes in 0.17.6 thanks to fix for issue #1027.
+     */
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testRetrySubscribesAgainAfterError() {
+
+        // record emitted values with this action
+        Action1<Integer> record = mock(Action1.class);
+        InOrder inOrder = inOrder(record);
+
+        // always throw an exception with this action
+        Action1<Integer> throwException = mock(Action1.class);
+        doThrow(new RuntimeException()).when(throwException).call(Mockito.anyInt());
+        
+        // create a retrying observable based on a PublishSubject
+        PublishSubject<Integer> subject = PublishSubject.create();
+        subject
+        // record item
+        .doOnNext(record)
+        // throw a RuntimeException
+                .doOnNext(throwException)
+                // retry on error
+                .retry()
+                // subscribe and ignore
+                .subscribe();
+
+        inOrder.verifyNoMoreInteractions();
+
+        subject.onNext(1);
+        inOrder.verify(record).call(1);
+
+        subject.onNext(2);
+        inOrder.verify(record).call(2);
+
+        subject.onNext(3);
+        inOrder.verify(record).call(3);
+
+        inOrder.verifyNoMoreInteractions();
+    }
+
 
     public static class FuncWithErrors implements Observable.OnSubscribe<String> {
 
@@ -356,4 +402,5 @@ public void testTimeoutWithRetry() {
 
         assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
     }
+    
 }

From dea5af5c50ddbeb16adc0c8d7bee7efde9946a67 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 22 Apr 2014 20:57:02 -0700
Subject: [PATCH 255/422] Simplify Subscription Chain

---
 .../src/main/java/rx/operators/OperatorAll.java       | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAll.java b/rxjava-core/src/main/java/rx/operators/OperatorAll.java
index 7b1124836f..6539296fe7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorAll.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAll.java
@@ -15,14 +15,8 @@
  */
 package rx.operators;
 
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observable.Operator;
-import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Func1;
 
 /**
@@ -40,8 +34,9 @@ public OperatorAll(Func1<? super T, Boolean> predicate) {
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super Boolean> child) {
-        Subscriber s = new Subscriber<T>() {
+        return new Subscriber<T>(child) {
             boolean done;
+
             @Override
             public void onNext(T t) {
                 boolean result = predicate.call(t);
@@ -67,7 +62,5 @@ public void onCompleted() {
                 }
             }
         };
-        child.add(s);
-        return s;
     }
 }

From 50cef72953db9067cdcc57c201d52446fb649d69 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 22 Apr 2014 21:07:23 -0700
Subject: [PATCH 256/422] OperationAnyTest -> OperatorAnyTest

Match new naming convention.
---
 .../operators/{OperationAnyTest.java => OperatorAnyTest.java}   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename rxjava-core/src/test/java/rx/operators/{OperationAnyTest.java => OperatorAnyTest.java} (99%)

diff --git a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAnyTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorAnyTest.java
index b664949fff..94c0f76824 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationAnyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAnyTest.java
@@ -27,7 +27,7 @@
 import rx.functions.Func1;
 import rx.functions.Functions;
 
-public class OperationAnyTest {
+public class OperatorAnyTest {
 
     @Test
     public void testAnyWithTwoItems() {

From 07542e1e17bb9bc52df9d69b2eeae88f04a2093d Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 22 Apr 2014 21:08:16 -0700
Subject: [PATCH 257/422] Simplify Subscription Chain

---
 rxjava-core/src/main/java/rx/operators/OperatorAny.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorAny.java b/rxjava-core/src/main/java/rx/operators/OperatorAny.java
index 4dee1e2c8d..ff46549a2f 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorAny.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorAny.java
@@ -36,7 +36,7 @@ public OperatorAny(Func1<? super T, Boolean> predicate, boolean returnOnEmpty) {
 
     @Override
     public Subscriber<? super T> call(final Subscriber<? super Boolean> child) {
-        Subscriber<T> s = new Subscriber<T>() {
+        return new Subscriber<T>(child) {
             boolean hasElements;
             boolean done;
             @Override
@@ -70,7 +70,5 @@ public void onCompleted() {
             }
             
         };
-        child.add(s);
-        return s;
     }
 }

From 598afbb62b315caea218abc4615c17f2c12a3319 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 22 Apr 2014 21:32:37 -0700
Subject: [PATCH 258/422] Scheduler.Inner -> Scheduler.Worker

As per decision at https://github.com/Netflix/RxJava/issues/997#issuecomment-40998613
---
 .../scala/rx/lang/scala/JavaConversions.scala |  4 +--
 .../main/scala/rx/lang/scala/Scheduler.scala  | 16 +++++-----
 .../schedulers/HandlerThreadScheduler.java    |  4 +--
 .../subscriptions/AndroidSubscriptions.java   |  4 +--
 .../HandlerThreadSchedulerTest.java           |  6 ++--
 .../src/main/java/rx/util/async/Async.java    | 32 +++++++++----------
 .../rx/util/async/operators/Functionals.java  |  8 ++---
 .../java/rx/quasar/NewFiberScheduler.java     |  4 +--
 .../java/rx/schedulers/SwingScheduler.java    |  4 +--
 .../rx/subscriptions/SwingSubscriptions.java  |  4 +--
 .../rx/swing/sources/SwingTestHelper.java     |  4 +--
 .../rx/schedulers/SwingSchedulerTest.java     |  8 ++---
 rxjava-core/src/main/java/rx/Scheduler.java   | 12 ++++---
 .../java/rx/operators/ChunkedOperation.java   | 14 ++++----
 .../java/rx/operators/OperationDebounce.java  |  4 +--
 .../java/rx/operators/OperationDelay.java     |  4 +--
 .../java/rx/operators/OperationInterval.java  |  4 +--
 .../main/java/rx/operators/OperationSkip.java |  4 +--
 .../java/rx/operators/OperationTakeTimed.java |  4 +--
 .../java/rx/operators/OperationTimer.java     |  6 ++--
 .../java/rx/operators/OperatorObserveOn.java  |  4 +--
 .../java/rx/operators/OperatorRepeat.java     |  4 +--
 .../main/java/rx/operators/OperatorRetry.java |  2 +-
 .../rx/operators/OperatorSubscribeOn.java     |  4 +--
 .../java/rx/operators/OperatorTimeout.java    |  4 +--
 .../rx/operators/OperatorTimeoutBase.java     | 10 +++---
 .../OperatorTimeoutWithSelector.java          |  4 +--
 .../rx/operators/OperatorUnsubscribeOn.java   |  2 +-
 .../rx/schedulers/EventLoopsScheduler.java    |  4 +--
 .../rx/schedulers/ImmediateScheduler.java     |  4 +--
 .../rx/schedulers/NewThreadScheduler.java     |  4 +--
 .../java/rx/schedulers/SleepingAction.java    |  4 +--
 .../java/rx/schedulers/TestScheduler.java     |  8 ++---
 .../rx/schedulers/TrampolineScheduler.java    |  4 +--
 .../main/java/rx/subjects/TestSubject.java    |  4 +--
 .../schedulers/TestRecursionMemoryUsage.java  |  4 +--
 rxjava-core/src/test/java/rx/EventStream.java |  4 +--
 .../rx/operators/OperationBufferTest.java     |  4 +--
 .../rx/operators/OperationDebounceTest.java   |  4 +--
 .../rx/operators/OperationSampleTest.java     |  4 +--
 .../rx/operators/OperationSwitchTest.java     |  4 +--
 .../operators/OperationThrottleFirstTest.java |  4 +--
 .../rx/operators/OperationWindowTest.java     |  4 +--
 .../java/rx/operators/OperatorAmbTest.java    |  4 +--
 .../java/rx/operators/OperatorMergeTest.java  |  8 ++---
 .../rx/operators/OperatorSubscribeOnTest.java | 10 +++---
 .../operators/OperatorUnsubscribeOnTest.java  |  6 ++--
 .../AbstractSchedulerConcurrencyTests.java    | 14 ++++----
 .../rx/schedulers/AbstractSchedulerTests.java | 14 ++++----
 .../schedulers/ComputationSchedulerTests.java |  2 +-
 .../java/rx/schedulers/TestSchedulerTest.java |  4 +--
 .../src/test/java/rx/test/OperatorTester.java |  4 +--
 52 files changed, 158 insertions(+), 156 deletions(-)

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 9ebd7744d7..c1d03667b4 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
@@ -39,8 +39,8 @@ object JavaConversions {
   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 scalaWorkerToJavaWorker(s: Worker): rx.Scheduler.Worker = s.asJavaWorker
+  implicit def javaWorkerToScalaWorker(s: rx.Scheduler.Worker): Worker = Worker(s)
 
 
   implicit def toJavaObserver[T](s: Observer[T]): rx.Observer[_ >: T] = s.asJavaObserver
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 c88ca3c875..6d5a24474f 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
@@ -42,22 +42,22 @@ trait Scheduler {
    */
   def now: Long = this.asJavaScheduler.now()
 
-  def createInner: Inner = this.asJavaScheduler.createInner()
+  def createWorker: Worker = this.asJavaScheduler.createWorker()
 
 }
 
-object Inner {
-  def apply(inner: rx.Scheduler.Inner): Inner = new Inner { private[scala] val asJavaInner = inner }
+object Worker {
+  def apply(worker: rx.Scheduler.Worker): Worker = new Worker { private[scala] val asJavaWorker = worker }
 }
 
-trait Inner extends Subscription {
-  private [scala] val asJavaInner: rx.Scheduler.Inner
+trait Worker extends Subscription {
+  private [scala] val asJavaWorker: rx.Scheduler.Worker
 
   /**
    * Schedules a cancelable action to be executed in delayTime.
    */
   def schedule(action: Unit => Unit, delayTime: Duration): Subscription =
-    this.asJavaInner.schedule(
+    this.asJavaWorker.schedule(
       new Action0 {
         override def call(): Unit = action()
       },
@@ -67,7 +67,7 @@ trait Inner extends Subscription {
   /**
    * Schedules a cancelable action to be executed immediately.
    */
-  def schedule(action: Unit => Unit): Subscription = this.asJavaInner.schedule(
+  def schedule(action: Unit => Unit): Subscription = this.asJavaWorker.schedule(
     new Action0 {
       override def call(): Unit = action()
     }
@@ -76,7 +76,7 @@ trait Inner extends Subscription {
   /**
    * @return the scheduler's notion of current absolute time in milliseconds.
    */
-  def now: Long = this.asJavaInner.now()
+  def now: Long = this.asJavaWorker.now()
 }
 
 
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 316480a5c2..0e786207c1 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
@@ -43,11 +43,11 @@ public HandlerThreadScheduler(Handler handler) {
     }
 
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new InnerHandlerThreadScheduler(handler);
     }
     
-    private static class InnerHandlerThreadScheduler extends Inner {
+    private static class InnerHandlerThreadScheduler extends Worker {
 
         private final Handler handler;
         private BooleanSubscription innerSubscription = new BooleanSubscription();
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
index 7d5b622c64..3e0fc95b9b 100644
--- 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
@@ -15,7 +15,7 @@
  */
 package rx.android.subscriptions;
 
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscription;
 import rx.android.schedulers.AndroidSchedulers;
 import rx.functions.Action0;
@@ -42,7 +42,7 @@ public void call() {
                 if (Looper.getMainLooper() == Looper.myLooper()) {
                     unsubscribe.call();
                 } else {
-                    final Inner inner = AndroidSchedulers.mainThread().createInner();
+                    final Worker inner = AndroidSchedulers.mainThread().createWorker();
                     inner.schedule(new Action0() {
                         @Override
                         public void call() {
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 14299340ca..8969e47a9e 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,7 +29,7 @@
 import org.robolectric.annotation.Config;
 
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import android.os.Handler;
@@ -45,7 +45,7 @@ public void shouldScheduleImmediateActionOnHandlerThread() {
         final Action0 action = mock(Action0.class);
 
         Scheduler scheduler = new HandlerThreadScheduler(handler);
-        Inner inner = scheduler.createInner();
+        Worker inner = scheduler.createWorker();
         inner.schedule(action);
 
         // verify that we post to the given Handler
@@ -64,7 +64,7 @@ public void shouldScheduleDelayedActionOnHandlerThread() {
         final Action0 action = mock(Action0.class);
 
         Scheduler scheduler = new HandlerThreadScheduler(handler);
-        Inner inner = scheduler.createInner();
+        Worker inner = scheduler.createWorker();
         inner.schedule(action, 1L, TimeUnit.SECONDS);
 
         // verify that we post to the given Handler
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 acd4a86eee..159bf97bd5 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
@@ -22,7 +22,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -599,7 +599,7 @@ public static <R> Func0<Observable<R>> toAsync(final Func0<? extends R> func, fi
             @Override
             public Observable<R> call() {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -659,7 +659,7 @@ public static <T1, R> Func1<T1, Observable<R>> toAsync(final Func1<? super T1, ?
             @Override
             public Observable<R> call(final T1 t1) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -721,7 +721,7 @@ public static <T1, T2, R> Func2<T1, T2, Observable<R>> toAsync(final Func2<? sup
             @Override
             public Observable<R> call(final T1 t1, final T2 t2) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -785,7 +785,7 @@ public static <T1, T2, T3, R> Func3<T1, T2, T3, Observable<R>> toAsync(final Fun
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -851,7 +851,7 @@ public static <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, Observable<R>> toAsync(f
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -919,7 +919,7 @@ public static <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, Observable<R>> t
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -989,7 +989,7 @@ public static <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, Observab
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1061,7 +1061,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1135,7 +1135,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7, final T8 t8) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1211,7 +1211,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func9<T1, T2, T3, T4, T5,
             @Override
             public Observable<R> call(final T1 t1, final T2 t2, final T3 t3, final T4 t4, final T5 t5, final T6 t6, final T7 t7, final T8 t8, final T9 t9) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1267,7 +1267,7 @@ public static <R> FuncN<Observable<R>> toAsync(final FuncN<? extends R> func, fi
             @Override
             public Observable<R> call(final Object... args) {
                 final AsyncSubject<R> subject = AsyncSubject.create();
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -1535,7 +1535,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action1<? super T> onNext,
             Scheduler scheduler) {
         FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext);
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
@@ -1563,7 +1563,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action1<? super Throwable> onError,
             Scheduler scheduler) {
         FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError);
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
@@ -1593,7 +1593,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action0 onCompleted,
             Scheduler scheduler) {
         FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
     }
@@ -1800,7 +1800,7 @@ public void call(Subscriber<? super U> t1) {
             }
         }, csub);
         
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
         csub.set(inner);
         
         inner.schedule(new Action0() {
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 b3c460ca2f..3dc96d0477 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
@@ -16,7 +16,7 @@
 
 package rx.util.async.operators;
 
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.functions.Action0;
 import rx.functions.Action1;
 
@@ -66,7 +66,7 @@ public void call() {
      * @param run the Runnable to run when the Action0 is called
      * @return the Action0 wrapping the Runnable
      */
-    public static Action0 fromRunnable(Runnable run, Inner inner) {
+    public static Action0 fromRunnable(Runnable run, Worker inner) {
         if (run == null) {
             throw new NullPointerException("run");
         }
@@ -75,9 +75,9 @@ public static Action0 fromRunnable(Runnable run, Inner inner) {
     /** An Action1 which wraps and calls a Runnable. */
     private static final class ActionWrappingRunnable implements Action0 {
         final Runnable run;
-        final Inner inner;
+        final Worker inner;
 
-        public ActionWrappingRunnable(Runnable run, Inner inner) {
+        public ActionWrappingRunnable(Runnable run, Worker inner) {
             this.run = run;
             this.inner = inner;
         }
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
index 8726f97feb..7893a447df 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
@@ -54,12 +54,12 @@ private NewFiberScheduler() {
     }
     
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new EventLoopScheduler();
     }
 
 
-    private class EventLoopScheduler extends Scheduler.Inner implements Subscription {
+    private class EventLoopScheduler extends Scheduler.Worker implements Subscription {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
 
         private EventLoopScheduler() {
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 a7d4fff65d..e8d5529c8c 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
@@ -44,11 +44,11 @@ public static SwingScheduler getInstance() {
     }
 
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new InnerSwingScheduler();
     }
 
-    private static class InnerSwingScheduler extends Inner {
+    private static class InnerSwingScheduler extends Worker {
 
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
 
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
index 7f8d08b040..1099bbc240 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
@@ -17,7 +17,7 @@
 
 import javax.swing.SwingUtilities;
 
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.schedulers.SwingScheduler;
@@ -41,7 +41,7 @@ public void call() {
                 if (SwingUtilities.isEventDispatchThread()) {
                     unsubscribe.call();
                 } else {
-                    final Inner inner = SwingScheduler.getInstance().createInner();
+                    final Worker inner = SwingScheduler.getInstance().createWorker();
                     inner.schedule(new Action0() {
                         @Override
                         public void call() {
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
index 5a15b28c7b..1a34d026ae 100644
--- 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
@@ -18,7 +18,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.functions.Action0;
 import rx.schedulers.SwingScheduler;
 
@@ -35,7 +35,7 @@ public static SwingTestHelper create() {
     }
 
     public SwingTestHelper runInEventDispatchThread(final Action0 action) {
-        Inner inner = SwingScheduler.getInstance().createInner();
+        Worker inner = SwingScheduler.getInstance().createWorker();
         inner.schedule(new Action0() {
 
             @Override
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 9ba0dff645..36f57b1d1f 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
@@ -33,7 +33,7 @@
 import org.junit.rules.ExpectedException;
 import org.mockito.InOrder;
 
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.functions.Action0;
 
 /**
@@ -48,7 +48,7 @@ public final class SwingSchedulerTest {
     @Test
     public void testInvalidDelayValues() {
         final SwingScheduler scheduler = new SwingScheduler();
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
         final Action0 action = mock(Action0.class);
 
         exception.expect(IllegalArgumentException.class);
@@ -67,7 +67,7 @@ public void testInvalidDelayValues() {
     @Test
     public void testPeriodicScheduling() throws Exception {
         final SwingScheduler scheduler = new SwingScheduler();
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
 
         final CountDownLatch latch = new CountDownLatch(4);
 
@@ -98,7 +98,7 @@ public void call() {
     @Test
     public void testNestedActions() throws Exception {
         final SwingScheduler scheduler = new SwingScheduler();
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
 
         final Action0 firstStepStart = mock(Action0.class);
         final Action0 firstStepEnd = mock(Action0.class);
diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 4f72f389e4..1d45006649 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -42,20 +42,22 @@
 public abstract class Scheduler {
 
     /**
-     * Retrieve or create a new {@link Scheduler.Inner} that represents serial execution of actions.
+     * Retrieve or create a new {@link Scheduler.Worker} that represents serial execution of actions.
      * <p>
-     * When work is completed it should be unsubscribed. Work on a {@link Scheduler.Inner} is guaranteed to be sequential.
+     * When work is completed it should be unsubscribed using {@link Scheduler.Worker#unsubscribe()}.
+     * <p>
+     * Work on a {@link Scheduler.Worker} is guaranteed to be sequential.
      * 
      * @return Inner representing a serial queue of actions to be executed
      */
-    public abstract Inner createInner();
+    public abstract Worker createWorker();
 
     /**
      * Sequential Scheduler for executing actions on a single thread or event loop.
      * <p>
-     * Unsubscribing the {@Inner} unschedules all outstanding work and allows resources cleanup.
+     * Unsubscribing the {@link Worker} unschedules all outstanding work and allows resources cleanup.
      */
-    public abstract static class Inner implements Subscription {
+    public abstract static class Worker implements Subscription {
 
         /**
          * Schedules an Action for execution.
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
index 6548b65d65..e8c5c80f15 100644
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
@@ -27,7 +27,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -155,7 +155,7 @@ protected static class TimeAndSizeBasedChunks<T, C> extends Chunks<T, C> impleme
 
         private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
 
-        private final Scheduler.Inner scheduler;
+        private final Scheduler.Worker scheduler;
         private final long maxTime;
         private final TimeUnit unit;
         private final int maxSize;
@@ -166,7 +166,7 @@ public TimeAndSizeBasedChunks(Observer<? super C> observer, Func0<? extends Chun
             this.maxSize = maxSize;
             this.maxTime = maxTime;
             this.unit = unit;
-            this.scheduler = scheduler.createInner();
+            this.scheduler = scheduler.createWorker();
         }
 
         @Override
@@ -240,7 +240,7 @@ protected static class TimeBasedChunks<T, C> extends OverlappingChunks<T, C> imp
 
         private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
 
-        private final Scheduler.Inner scheduler;
+        private final Scheduler.Worker scheduler;
         private final long time;
         private final TimeUnit unit;
         private volatile boolean unsubscribed = false;
@@ -249,7 +249,7 @@ public TimeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>
             super(observer, chunkMaker);
             this.time = time;
             this.unit = unit;
-            this.scheduler = scheduler.createInner();
+            this.scheduler = scheduler.createWorker();
         }
 
         @Override
@@ -608,7 +608,7 @@ protected static class TimeBasedChunkCreator<T, C> implements ChunkCreator {
         private final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription();
 
         public TimeBasedChunkCreator(final NonOverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            Inner inner = scheduler.createInner();
+            Worker inner = scheduler.createWorker();
             this.subscription.set(inner);
             inner.schedulePeriodically(new Action0() {
                 @Override
@@ -619,7 +619,7 @@ public void call() {
         }
 
         public TimeBasedChunkCreator(final OverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            Inner inner = scheduler.createInner();
+            Worker inner = scheduler.createWorker();
             this.subscription.set(inner);
             inner.schedulePeriodically(new Action0() {
                 @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
index 1d1913f4e0..6b112cc7f9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
@@ -104,7 +104,7 @@ private static class DebounceObserver<T> extends Subscriber<T> {
         private final Observer<? super T> observer;
         private final long timeout;
         private final TimeUnit unit;
-        private final Scheduler.Inner scheduler;
+        private final Scheduler.Worker scheduler;
 
         private final AtomicReference<Subscription> lastScheduledNotification = new AtomicReference<Subscription>();
 
@@ -114,7 +114,7 @@ public DebounceObserver(Observer<? super T> observer, long timeout, TimeUnit uni
             this.observer = new SerializedObserver<T>(observer);
             this.timeout = timeout;
             this.unit = unit;
-            this.scheduler = scheduler.createInner();
+            this.scheduler = scheduler.createWorker();
         }
 
         @Override
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
index bd9d7e9400..79d03b2264 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
@@ -61,13 +61,13 @@ public static <T> OnSubscribeFunc<T> delaySubscription(Observable<? extends T> s
     /** Subscribe function which schedules the actual subscription to source on a scheduler at a later time. */
     private static final class DelaySubscribeFunc<T> implements OnSubscribeFunc<T> {
         final Observable<? extends T> source;
-        final Scheduler.Inner scheduler;
+        final Scheduler.Worker scheduler;
         final long time;
         final TimeUnit unit;
 
         public DelaySubscribeFunc(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
             this.source = source;
-            this.scheduler = scheduler.createInner();
+            this.scheduler = scheduler.createWorker();
             this.time = time;
             this.unit = unit;
         }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
index 2adbb3480f..ef036984b6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationInterval.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
@@ -20,7 +20,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.schedulers.Schedulers;
@@ -66,7 +66,7 @@ private Interval(long period, TimeUnit unit, Scheduler scheduler) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> observer) {
-            Inner inner = scheduler.createInner();
+            Worker inner = scheduler.createWorker();
             inner.schedulePeriodically(new Action0() {
                 @Override
                 public void call() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
index 4a2684d873..f52b14374d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
@@ -22,7 +22,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -60,7 +60,7 @@ public SkipTimed(Observable<? extends T> source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
-            Inner inner = scheduler.createInner();
+            Worker inner = scheduler.createWorker();
             CompositeSubscription csub = new CompositeSubscription(inner);
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
             csub.add(so);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
index a8f203089d..dd51c9e9e7 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
@@ -22,7 +22,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -191,7 +191,7 @@ public TakeTimed(Observable<? extends T> source, long time, TimeUnit unit, Sched
 
         @Override
         public Subscription onSubscribe(Observer<? super T> t1) {
-            Inner inner = scheduler.createInner();
+            Worker inner = scheduler.createWorker();
             CompositeSubscription csub = new CompositeSubscription(inner);
             final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
             csub.add(so);
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
index 663ba359eb..e950cb07a8 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
@@ -20,7 +20,7 @@
 import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscription;
 import rx.functions.Action0;
 
@@ -50,7 +50,7 @@ public TimerOnce(long dueTime, TimeUnit unit, Scheduler scheduler) {
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> t1) {
-            return scheduler.createInner().schedule(new Action0() {
+            return scheduler.createWorker().schedule(new Action0() {
                 @Override
                 public void call() {
                     t1.onNext(0L);
@@ -79,7 +79,7 @@ public TimerPeriodically(long initialDelay, long period, TimeUnit unit, Schedule
 
         @Override
         public Subscription onSubscribe(final Observer<? super Long> t1) {
-            Inner inner = scheduler.createInner();
+            Worker inner = scheduler.createWorker();
             inner.schedulePeriodically(new Action0() {
                 long count;
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 1424c3719f..9412ef8324 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -58,7 +58,7 @@ public Subscriber<? super T> call(Subscriber<? super T> child) {
     private static class ObserveOnSubscriber<T> extends Subscriber<T> {
         private final NotificationLite<T> on = NotificationLite.instance();
         final Subscriber<? super T> observer;
-        private final Scheduler.Inner recursiveScheduler;
+        private final Scheduler.Worker recursiveScheduler;
 
         private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
         final AtomicLong counter = new AtomicLong(0);
@@ -66,7 +66,7 @@ private static class ObserveOnSubscriber<T> extends Subscriber<T> {
         public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> subscriber) {
             super(subscriber);
             this.observer = subscriber;
-            this.recursiveScheduler = scheduler.createInner();
+            this.recursiveScheduler = scheduler.createWorker();
             subscriber.add(recursiveScheduler);
         }
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
index 5e335117d8..9ca9f75b9e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRepeat.java
@@ -19,7 +19,7 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.functions.Action0;
 import rx.observers.Subscribers;
@@ -71,7 +71,7 @@ public void onError(Throwable e) {
             @Override
             public void onNext(final Observable<T> t) {
                 // will only be invoked once since we're nested
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 // cleanup on unsubscribe
                 add(inner);
                 inner.schedule(new Action0() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
index bcd0c0965c..0422688b32 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRetry.java
@@ -59,7 +59,7 @@ public OperatorRetry() {
 
     @Override
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> child) {
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         child.add(inner);
         
         final SerialSubscription serialSubscription = new SerialSubscription();
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
index bd095d196a..a59671e6a2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSubscribeOn.java
@@ -18,7 +18,7 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.functions.Action0;
 
@@ -37,7 +37,7 @@ public OperatorSubscribeOn(Scheduler scheduler) {
 
     @Override
     public Subscriber<? super Observable<T>> call(final Subscriber<? super T> subscriber) {
-        final Inner inner = scheduler.createInner();
+        final Worker inner = scheduler.createWorker();
         subscriber.add(inner);
         return new Subscriber<Observable<T>>(subscriber) {
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
index 0048810bd9..cbb587e38d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeout.java
@@ -35,7 +35,7 @@ public OperatorTimeout(final long timeout, final TimeUnit timeUnit, Observable<?
         super(new FirstTimeoutStub<T>() {
 
             @Override
-            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, Scheduler.Inner inner) {
+            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, Scheduler.Worker inner) {
                 return inner.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -46,7 +46,7 @@ public void call() {
         }, new TimeoutStub<T>() {
 
             @Override
-            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, T value, Scheduler.Inner inner) {
+            public Subscription call(final TimeoutSubscriber<T> timeoutSubscriber, final Long seqId, T value, Scheduler.Worker inner) {
                 return inner.schedule(new Action0() {
                     @Override
                     public void call() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
index b78217b09f..10aa4ffd67 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutBase.java
@@ -37,7 +37,7 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
      * @param <T>
      */
     /* package-private */static interface FirstTimeoutStub<T> extends
-            Func3<TimeoutSubscriber<T>, Long, Scheduler.Inner, Subscription> {
+            Func3<TimeoutSubscriber<T>, Long, Scheduler.Worker, Subscription> {
     }
 
     /**
@@ -46,7 +46,7 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
      * @param <T>
      */
     /* package-private */static interface TimeoutStub<T> extends
-            Func4<TimeoutSubscriber<T>, Long, T, Scheduler.Inner, Subscription> {
+            Func4<TimeoutSubscriber<T>, Long, T, Scheduler.Worker, Subscription> {
     }
 
     private final FirstTimeoutStub<T> firstTimeoutStub;
@@ -63,7 +63,7 @@ class OperatorTimeoutBase<T> implements Operator<T, T> {
 
     @Override
     public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
-        Scheduler.Inner inner = scheduler.createInner();
+        Scheduler.Worker inner = scheduler.createWorker();
         subscriber.add(inner);
         final SerialSubscription serial = new SerialSubscription();
         subscriber.add(serial);
@@ -90,13 +90,13 @@ public Subscriber<? super T> call(Subscriber<? super T> subscriber) {
         private final TimeoutStub<T> timeoutStub;
 
         private final Observable<? extends T> other;
-        private final Scheduler.Inner inner;
+        private final Scheduler.Worker inner;
 
         private TimeoutSubscriber(
                 SerializedSubscriber<T> serializedSubscriber,
                 TimeoutStub<T> timeoutStub, SerialSubscription serial,
                 Observable<? extends T> other,
-                Scheduler.Inner inner) {
+                Scheduler.Worker inner) {
             super(serializedSubscriber);
             this.serializedSubscriber = serializedSubscriber;
             this.timeoutStub = timeoutStub;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
index cefbed566d..08be2be005 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeoutWithSelector.java
@@ -43,7 +43,7 @@ public OperatorTimeoutWithSelector(
             @Override
             public Subscription call(
                     final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId, Scheduler.Inner inner) {
+                    final Long seqId, Scheduler.Worker inner) {
                 if (firstTimeoutSelector != null) {
                     Observable<U> o = null;
                     try {
@@ -80,7 +80,7 @@ public void onNext(U t) {
             @Override
             public Subscription call(
                     final TimeoutSubscriber<T> timeoutSubscriber,
-                    final Long seqId, T value, Scheduler.Inner inner) {
+                    final Long seqId, T value, Scheduler.Worker inner) {
                 Observable<V> o = null;
                 try {
                     o = timeoutSelector.call(value);
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
index f7ddd8da99..82018b65c6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorUnsubscribeOn.java
@@ -41,7 +41,7 @@ public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
 
             @Override
             public void call() {
-                final Scheduler.Inner inner = scheduler.createInner();
+                final Scheduler.Worker inner = scheduler.createWorker();
                 inner.schedule(new Action0() {
 
                     @Override
diff --git a/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
index a5e3899368..ef41d86432 100644
--- a/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
@@ -48,11 +48,11 @@ public EventLoopScheduler getEventLoop() {
     }
 
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new EventLoop();
     }
 
-    private static class EventLoop extends Scheduler.Inner {
+    private static class EventLoop extends Scheduler.Worker {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
         private final EventLoopScheduler pooledEventLoop;
         private final OnActionComplete onComplete;
diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
index e74296fe81..cbc3a57d4e 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
@@ -37,11 +37,11 @@ public final class ImmediateScheduler extends Scheduler {
     }
 
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new InnerImmediateScheduler();
     }
 
-    private class InnerImmediateScheduler extends Scheduler.Inner implements Subscription {
+    private class InnerImmediateScheduler extends Scheduler.Worker 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 cebbdba64a..acbe6c81cc 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -55,11 +55,11 @@ private NewThreadScheduler() {
     }
 
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new EventLoopScheduler(THREAD_FACTORY);
     }
 
-    /* package */static class EventLoopScheduler extends Scheduler.Inner implements Subscription {
+    /* package */static class EventLoopScheduler extends Scheduler.Worker implements Subscription {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
         private final ExecutorService executor;
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
index 3748b053ce..016df2d87e 100644
--- a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
+++ b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
@@ -20,10 +20,10 @@
 
 /* package */class SleepingAction implements Action0 {
     private final Action0 underlying;
-    private final Scheduler.Inner innerScheduler;
+    private final Scheduler.Worker innerScheduler;
     private final long execTime;
 
-    public SleepingAction(Action0 underlying, Scheduler.Inner scheduler, long execTime) {
+    public SleepingAction(Action0 underlying, Scheduler.Worker scheduler, long execTime) {
         this.underlying = underlying;
         this.innerScheduler = scheduler;
         this.execTime = execTime;
diff --git a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
index 524f29fcd8..97ab4afdad 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TestScheduler.java
@@ -34,10 +34,10 @@ private static class TimedAction {
 
         private final long time;
         private final Action0 action;
-        private final Inner scheduler;
+        private final Worker scheduler;
         private final long count = counter++; // for differentiating tasks at same time
 
-        private TimedAction(Inner scheduler, long time, Action0 action) {
+        private TimedAction(Worker scheduler, long time, Action0 action) {
             this.time = time;
             this.action = action;
             this.scheduler = scheduler;
@@ -99,11 +99,11 @@ private void triggerActions(long targetTimeInNanos) {
     }
 
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new InnerTestScheduler();
     }
 
-    private final class InnerTestScheduler extends Inner {
+    private final class InnerTestScheduler extends Worker {
 
         private BooleanSubscription s = new BooleanSubscription();
 
diff --git a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
index af4cea9801..ea7f101600 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
@@ -36,7 +36,7 @@ public class TrampolineScheduler extends Scheduler {
     }
 
     @Override
-    public Inner createInner() {
+    public Worker createWorker() {
         return new InnerCurrentThreadScheduler();
     }
 
@@ -47,7 +47,7 @@ public Inner createInner() {
 
     private final AtomicInteger counter = new AtomicInteger(0);
 
-    private class InnerCurrentThreadScheduler extends Scheduler.Inner implements Subscription {
+    private class InnerCurrentThreadScheduler extends Scheduler.Worker implements Subscription {
 
         private final BooleanSubscription innerSubscription = new BooleanSubscription();
 
diff --git a/rxjava-core/src/main/java/rx/subjects/TestSubject.java b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
index ef5fc99370..7b9fb69e32 100644
--- a/rxjava-core/src/main/java/rx/subjects/TestSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
@@ -90,13 +90,13 @@ public void call(SubjectObserver<? super T> o) {
 
     private final SubjectSubscriptionManager<T> subscriptionManager;
     private final AtomicReference<Notification<T>> lastNotification;
-    private final Scheduler.Inner innerScheduler;
+    private final Scheduler.Worker innerScheduler;
 
     protected TestSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, AtomicReference<Notification<T>> lastNotification, TestScheduler scheduler) {
         super(onSubscribe);
         this.subscriptionManager = subscriptionManager;
         this.lastNotification = lastNotification;
-        this.innerScheduler = scheduler.createInner();
+        this.innerScheduler = scheduler.createWorker();
     }
 
     @Override
diff --git a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
index 6335dc2109..7fc70cdd9d 100644
--- a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
@@ -18,7 +18,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.functions.Action0;
 import rx.schedulers.Schedulers;
@@ -42,7 +42,7 @@ protected static void testScheduler(final Scheduler scheduler) {
 
             @Override
             public void call(final Subscriber<? super Long> o) {
-                final Inner inner = scheduler.createInner();
+                final Worker inner = scheduler.createWorker();
                 o.add(inner);
                 inner.schedule(new Action0() {
 
diff --git a/rxjava-core/src/test/java/rx/EventStream.java b/rxjava-core/src/test/java/rx/EventStream.java
index a300fc977c..7354ae82ca 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.OnSubscribe;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.functions.Action0;
 import rx.schedulers.Schedulers;
 
@@ -34,7 +34,7 @@ public static Observable<Event> getEventStream(final String type, final int numI
 
             @Override
             public void call(final Subscriber<? super Event> subscriber) {
-                Inner inner = Schedulers.newThread().createInner();
+                Worker inner = Schedulers.newThread().createWorker();
                 subscriber.add(inner);
                 // run on a background thread inside the OnSubscribeFunc so unsubscribe works
                 inner.schedule(new Action0() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index 695379b840..aa1c525e99 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -50,14 +50,14 @@ public class OperationBufferTest {
 
     private Observer<List<String>> observer;
     private TestScheduler scheduler;
-    private Scheduler.Inner innerScheduler;
+    private Scheduler.Worker innerScheduler;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         observer = Mockito.mock(Observer.class);
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.createInner();
+        innerScheduler = scheduler.createWorker();
     }
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
index ab6ff62c31..7cf989a02a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
@@ -43,14 +43,14 @@ public class OperationDebounceTest {
 
     private TestScheduler scheduler;
     private Observer<String> observer;
-    private Scheduler.Inner innerScheduler;
+    private Scheduler.Worker innerScheduler;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
         observer = mock(Observer.class);
-        innerScheduler = scheduler.createInner();
+        innerScheduler = scheduler.createWorker();
     }
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
index 39dae6778d..7e4a39b2cd 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
@@ -39,7 +39,7 @@
 
 public class OperationSampleTest {
     private TestScheduler scheduler;
-    private Scheduler.Inner innerScheduler;
+    private Scheduler.Worker innerScheduler;
     private Observer<Long> observer;
     private Observer<Object> observer2;
 
@@ -48,7 +48,7 @@ public class OperationSampleTest {
     // due to mocking
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.createInner();
+        innerScheduler = scheduler.createWorker();
         observer = mock(Observer.class);
         observer2 = mock(Observer.class);
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
index 8ee61765ed..a0d6fede6b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
@@ -40,14 +40,14 @@
 public class OperationSwitchTest {
 
     private TestScheduler scheduler;
-    private Scheduler.Inner innerScheduler;
+    private Scheduler.Worker innerScheduler;
     private Observer<String> observer;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.createInner();
+        innerScheduler = scheduler.createWorker();
         observer = mock(Observer.class);
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
index 73833e4b40..244e9a6878 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
@@ -37,14 +37,14 @@
 public class OperationThrottleFirstTest {
 
     private TestScheduler scheduler;
-    private Scheduler.Inner innerScheduler;
+    private Scheduler.Worker innerScheduler;
     private Observer<String> observer;
 
     @Before
     @SuppressWarnings("unchecked")
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.createInner();
+        innerScheduler = scheduler.createWorker();
         observer = mock(Observer.class);
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
index 480b02fdf7..38376a06c9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
@@ -46,12 +46,12 @@
 public class OperationWindowTest {
 
     private TestScheduler scheduler;
-    private Scheduler.Inner innerScheduler;
+    private Scheduler.Worker innerScheduler;
 
     @Before
     public void before() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.createInner();
+        innerScheduler = scheduler.createWorker();
     }
 
     private static <T> List<List<T>> toLists(Observable<Observable<T>> observables) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
index fae9a5d4a6..95ff378b70 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAmbTest.java
@@ -39,12 +39,12 @@
 public class OperatorAmbTest {
 
     private TestScheduler scheduler;
-    private Scheduler.Inner innerScheduler;
+    private Scheduler.Worker innerScheduler;
 
     @Before
     public void setUp() {
         scheduler = new TestScheduler();
-        innerScheduler = scheduler.createInner();
+        innerScheduler = scheduler.createWorker();
     }
 
     private Observable<String> createObservable(final String[] values,
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index 63cefade79..a4d7583d40 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -42,7 +42,7 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -485,7 +485,7 @@ public void testConcurrency() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Inner inner = Schedulers.newThread().createInner();
+                Worker inner = Schedulers.newThread().createWorker();
                 s.add(inner);
                 inner.schedule(new Action0() {
 
@@ -521,7 +521,7 @@ public void testConcurrencyWithSleeping() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Inner inner = Schedulers.newThread().createInner();
+                Worker inner = Schedulers.newThread().createWorker();
                 s.add(inner);
                 inner.schedule(new Action0() {
 
@@ -562,7 +562,7 @@ public void testConcurrencyWithBrokenOnCompleteContract() {
 
             @Override
             public void call(final Subscriber<? super Integer> s) {
-                Inner inner = Schedulers.newThread().createInner();
+                Worker inner = Schedulers.newThread().createWorker();
                 s.add(inner);
                 inner.schedule(new Action0() {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index 1e1977917e..db27182581 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -94,15 +94,15 @@ public SlowScheduler(Scheduler actual, long delay, TimeUnit unit) {
         }
 
         @Override
-        public Inner createInner() {
-            return new SlowInner(actual.createInner());
+        public Worker createWorker() {
+            return new SlowInner(actual.createWorker());
         }
 
-        private class SlowInner extends Inner {
+        private class SlowInner extends Worker {
 
-            private final Scheduler.Inner actualInner;
+            private final Scheduler.Worker actualInner;
 
-            private SlowInner(Inner actual) {
+            private SlowInner(Worker actual) {
                 this.actualInner = actual;
             }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
index 5cb0edb2e4..99281a6841 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
@@ -138,13 +138,13 @@ public Thread getThread() throws InterruptedException {
 
     public static class UIEventLoopScheduler extends Scheduler {
 
-        private final Scheduler.Inner eventLoop;
+        private final Scheduler.Worker eventLoop;
         private final Subscription s;
         private volatile Thread t;
 
         public UIEventLoopScheduler() {
 
-            eventLoop = Schedulers.newThread().createInner();
+            eventLoop = Schedulers.newThread().createWorker();
             s = eventLoop;
 
             /*
@@ -168,7 +168,7 @@ public void call() {
         }
         
         @Override
-        public Inner createInner() {
+        public Worker createWorker() {
             return eventLoop;
         }
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 1eeaa31ac8..332b9c257b 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -30,7 +30,7 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Scheduler;
-import rx.Scheduler.Inner;
+import rx.Scheduler.Worker;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
@@ -100,7 +100,7 @@ public void testUnsubscribeRecursiveScheduleFromOutside() throws InterruptedExce
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        final Inner inner = getScheduler().createInner();
+        final Worker inner = getScheduler().createWorker();
 
         inner.schedule(new Action0() {
 
@@ -145,7 +145,7 @@ public void call() {
     public void testUnsubscribeRecursiveScheduleFromInside() throws InterruptedException {
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        final Inner inner = getScheduler().createInner();
+        final Worker inner = getScheduler().createWorker();
         inner.schedule(new Action0() {
 
             @Override
@@ -179,7 +179,7 @@ public void testUnsubscribeRecursiveScheduleWithDelay() throws InterruptedExcept
         final CountDownLatch latch = new CountDownLatch(1);
         final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
         final AtomicInteger counter = new AtomicInteger();
-        final Inner inner = getScheduler().createInner();
+        final Worker inner = getScheduler().createWorker();
         inner.schedule(new Action0() {
 
             @Override
@@ -220,7 +220,7 @@ public void call() {
     @Test
     public void recursionFromOuterActionAndUnsubscribeInside() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        final Inner inner = getScheduler().createInner();
+        final Worker inner = getScheduler().createWorker();
         inner.schedule(new Action0() {
 
             int i = 0;
@@ -245,7 +245,7 @@ public void call() {
     @Test
     public void testRecursion() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
-        final Inner inner = getScheduler().createInner();
+        final Worker inner = getScheduler().createWorker();
         inner.schedule(new Action0() {
 
             private long i = 0;
@@ -276,7 +276,7 @@ public void testRecursionAndOuterUnsubscribe() throws InterruptedException {
         Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(final Subscriber<? super Integer> observer) {
-                final Inner inner = getScheduler().createInner();
+                final Worker inner = getScheduler().createWorker();
                 inner.schedule(new Action0() {
                     @Override
                     public void call() {
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 04a3c569f9..a3ff320ad4 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -61,7 +61,7 @@ public abstract class AbstractSchedulerTests {
     @Test
     public void testNestedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         final CountDownLatch latch = new CountDownLatch(1);
 
         final Action0 firstStepStart = mock(Action0.class);
@@ -153,7 +153,7 @@ public String call(String s) {
     @Test
     public final void testSequenceOfActions() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         
         final CountDownLatch latch = new CountDownLatch(2);
         final Action0 first = mock(Action0.class);
@@ -196,7 +196,7 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
     @Test
     public void testSequenceOfDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         
         final CountDownLatch latch = new CountDownLatch(1);
         final Action0 first = mock(Action0.class);
@@ -228,7 +228,7 @@ public void call() {
     @Test
     public void testMixOfDelayedAndNonDelayedActions() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         
         final CountDownLatch latch = new CountDownLatch(1);
         final Action0 first = mock(Action0.class);
@@ -265,7 +265,7 @@ public void call() {
     @Test
     public final void testRecursiveExecution() throws InterruptedException {
         final Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         final AtomicInteger i = new AtomicInteger();
         final CountDownLatch latch = new CountDownLatch(1);
         inner.schedule(new Action0() {
@@ -287,7 +287,7 @@ public void call() {
     @Test
     public final void testRecursiveExecutionWithDelayTime() throws InterruptedException {
         Scheduler scheduler = getScheduler();
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         final AtomicInteger i = new AtomicInteger();
         final CountDownLatch latch = new CountDownLatch(1);
 
@@ -316,7 +316,7 @@ public final void testRecursiveSchedulerInObservable() {
         Observable<Integer> obs = Observable.create(new OnSubscribe<Integer>() {
             @Override
             public void call(final Subscriber<? super Integer> observer) {
-                final Scheduler.Inner inner = getScheduler().createInner();
+                final Scheduler.Worker inner = getScheduler().createWorker();
                 observer.add(inner);
                 inner.schedule(new Action0() {
                     int i = 0;
diff --git a/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index ef8644950b..7c6a90bf56 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -45,7 +45,7 @@ public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() {
         final CountDownLatch latch = new CountDownLatch(1);
         final HashMap<String, Integer> map = new HashMap<String, Integer>();
 
-        final Scheduler.Inner inner = Schedulers.computation().createInner();
+        final Scheduler.Worker inner = Schedulers.computation().createWorker();
 
         inner.schedule(new Action0() {
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
index 846340a88a..81ba34ab62 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TestSchedulerTest.java
@@ -42,7 +42,7 @@ public final void testPeriodicScheduling() {
         final Func1<Long, Void> calledOp = mock(Func1.class);
 
         final TestScheduler scheduler = new TestScheduler();
-        final Scheduler.Inner inner = scheduler.createInner();
+        final Scheduler.Worker inner = scheduler.createWorker();
         
         inner.schedulePeriodically(new Action0() {
             @Override
@@ -80,7 +80,7 @@ public void call() {
     @Test
     public final void testImmediateUnsubscribes() {
         TestScheduler s = new TestScheduler();
-        final Scheduler.Inner inner = s.createInner();
+        final Scheduler.Worker inner = s.createWorker();
         final AtomicInteger counter = new AtomicInteger(0);
         
         inner.schedule(new Action0() {
diff --git a/rxjava-core/src/test/java/rx/test/OperatorTester.java b/rxjava-core/src/test/java/rx/test/OperatorTester.java
index 3069e5e5ec..218519286b 100644
--- a/rxjava-core/src/test/java/rx/test/OperatorTester.java
+++ b/rxjava-core/src/test/java/rx/test/OperatorTester.java
@@ -52,8 +52,8 @@ public ForwardingScheduler(Scheduler underlying) {
         }
 
         @Override
-        public Inner createInner() {
-            return underlying.createInner();
+        public Worker createWorker() {
+            return underlying.createWorker();
         }
 
     }

From 27c64f40074b8edbd987706ad5a33524622f1331 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 23 Apr 2014 04:56:08 +0000
Subject: [PATCH 259/422] [Gradle Release Plugin] - pre tag commit:  '0.18.0'.

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

diff --git a/gradle.properties b/gradle.properties
index cff13a233e..2804593a38 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.0-SNAPSHOT
+version=0.18.0

From b634c2b1cde0a55c67bab6945f27c9ea8d635a26 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 23 Apr 2014 04:56:12 +0000
Subject: [PATCH 260/422] [Gradle Release Plugin] - new version commit: 
 '0.18.1-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index 2804593a38..b059c1d77c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.0
+version=0.18.1-SNAPSHOT

From 4e77f8a54c199531426c7d3b32fecdd163836606 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Tue, 22 Apr 2014 22:15:30 -0700
Subject: [PATCH 261/422] 0.18.0

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

diff --git a/CHANGES.md b/CHANGES.md
index 68a0474a2b..523f7b2130 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,68 @@
 # RxJava Releases #
 
+### Version 0.18.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.0%22)) ###
+
+This release takes us a step closer to [1.0](https://github.com/Netflix/RxJava/issues/1001) by completing some of the remaining work on the roadmap.
+
+##### Scheduler
+
+The first is simplifying the [Scheduler API](https://github.com/Netflix/RxJava/issues/997). 
+
+The Scheduler API is now simplified to this:
+
+```java
+class Scheduler {
+    public abstract Worker createWorker(); 
+    public int parallelism();
+    public long now();
+
+    public abstract static class Worker implements Subscription {
+        public abstract Subscription schedule(Action0 action, long delayTime, TimeUnit unit);
+        public abstract Subscription schedule(Action0 action);
+        public Subscription schedulePeriodically(Action0 action, long initialDelay, long period, TimeUnit unit);
+        public long now();
+    }
+}
+```
+
+This is a breaking change if you have a custom `Scheduler` implementation or use a `Scheduler` directly. If you only ever pass in a `Scheduler` via the `Schedulers` factory methods, this change does not affect you.
+
+Additionally, the `ExecutionScheduler` was removed because a general threadpool does not meet the requirements of sequential execution for an `Observable`. It was replaced with `rx.schedulers.EventLoopScheduler` which is the new default for `Schedulers.computation()`. It is a pool of event loops.
+
+##### rx.joins
+
+The `rx.joins` package and associated `when`, `and` and `then` operators were moved out of rxjava-core into a new module rxjava-joins. This is done as the rx.joins API was not yet matured and is not going to happen before 1.0. It was determined low priority and not worth blocking a 1.0 release. If the API matures inside the separate module to the point where it makes sense to bring it back into the core it can be done in the 1.x series.
+
+##### Deprecation Cleanup
+
+This releases removes many of the classes and methods that have been deprecated in previous releases. Most of the removed functionality was migrated in previous releases to contrib modules such as rxjava-math, rxjava-async and rxjava-computation-expressions.
+
+A handful of deprecated items still remain but can not yet be removed until all internal operators are finished migrating to using the `lift`/`Subscriber` design changes done in 0.17.0.
+
+
+The full list of changes in 0.18.0:
+
+* [Pull 1047] (https://github.com/Netflix/RxJava/pull/1047) Scheduler Simplification
+* [Pull 1072] (https://github.com/Netflix/RxJava/pull/1072) Scheduler.Inner -> Scheduler.Worker
+* [Pull 1053] (https://github.com/Netflix/RxJava/pull/1053) Deprecation Cleanup
+* [Pull 1052] (https://github.com/Netflix/RxJava/pull/1052) Scheduler Cleanup
+* [Pull 1048] (https://github.com/Netflix/RxJava/pull/1048) Remove ExecutorScheduler - New ComputationScheduler
+* [Pull 1049] (https://github.com/Netflix/RxJava/pull/1049) Move rx.joins to rxjava-joins module
+* [Pull 1068] (https://github.com/Netflix/RxJava/pull/1068) add synchronous test of resubscribe after error
+* [Pull 1066] (https://github.com/Netflix/RxJava/pull/1066) CompositeSubscription fix
+* [Pull 1071] (https://github.com/Netflix/RxJava/pull/1071) Manual Merge of AsObservable
+* [Pull 1063] (https://github.com/Netflix/RxJava/pull/1063) Fix bugs in equals and hashCode of Timestamped
+* [Pull 1070] (https://github.com/Netflix/RxJava/pull/1070) OperationAny -> OperatorAny
+* [Pull 1069] (https://github.com/Netflix/RxJava/pull/1069) OperationAll -> OperatorAll
+* [Pull 1058] (https://github.com/Netflix/RxJava/pull/1058) Typo in javadoc
+* [Pull 1056] (https://github.com/Netflix/RxJava/pull/1056) Add drop(skip) and dropRight(skipLast) to rxscala
+* [Pull 1057] (https://github.com/Netflix/RxJava/pull/1057) Fix: Retry in Scala adaptor is ambiguous
+* [Pull 1055] (https://github.com/Netflix/RxJava/pull/1055) Fix: Missing Quasar instrumentation on Observable$2.call
+* [Pull 1050] (https://github.com/Netflix/RxJava/pull/1050) Reimplement the 'SkipLast' operator 
+* [Pull 967] (https://github.com/Netflix/RxJava/pull/967) Reimplement the 'single' operator
+
+
+
 ### Version 0.17.6 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.17.6%22)) ###
 
 * [Pull 1031] (https://github.com/Netflix/RxJava/pull/1031) Fix NPE in SubjectSubscriptionManager

From 6231f7f93bdeab2448a1da80785c7590867a3990 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 23 Apr 2014 11:23:35 +0200
Subject: [PATCH 262/422] OperatorBuffer

---
 rxjava-core/src/main/java/rx/Observable.java  |  29 +-
 .../java/rx/operators/OperationBuffer.java    | 566 ------------------
 .../OperatorBufferWithSingleObservable.java   | 190 ++++++
 .../rx/operators/OperatorBufferWithSize.java  | 141 +++++
 .../OperatorBufferWithStartEndObservable.java | 215 +++++++
 .../rx/operators/OperatorBufferWithTime.java  | 302 ++++++++++
 .../rx/operators/OperationBufferTest.java     | 296 ++++++++-
 7 files changed, 1143 insertions(+), 596 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationBuffer.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorBufferWithSingleObservable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorBufferWithSize.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorBufferWithTime.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..9598e5cdef 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -48,7 +48,6 @@
 import rx.observers.SafeSubscriber;
 import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
-import rx.operators.OperationBuffer;
 import rx.operators.OperationCombineLatest;
 import rx.operators.OperationConcat;
 import rx.operators.OperationDebounce;
@@ -93,6 +92,10 @@
 import rx.operators.OperatorAmb;
 import rx.operators.OperatorAny;
 import rx.operators.OperatorAsObservable;
+import rx.operators.OperatorBufferWithSingleObservable;
+import rx.operators.OperatorBufferWithSize;
+import rx.operators.OperatorBufferWithStartEndObservable;
+import rx.operators.OperatorBufferWithTime;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
 import rx.operators.OperatorDoOnEach;
@@ -2973,7 +2976,7 @@ public final Observable<T> asObservable() {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final <TClosing> Observable<List<T>> buffer(Func0<? extends Observable<? extends TClosing>> bufferClosingSelector) {
-        return create(OperationBuffer.buffer(this, bufferClosingSelector));
+        return lift(new OperatorBufferWithSingleObservable<T, TClosing>(bufferClosingSelector, 16));
     }
 
     /**
@@ -2990,7 +2993,7 @@ public final <TClosing> Observable<List<T>> buffer(Func0<? extends Observable<?
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(int count) {
-        return create(OperationBuffer.buffer(this, count));
+        return lift(new OperatorBufferWithSize<T>(count, count));
     }
 
     /**
@@ -3011,7 +3014,7 @@ public final Observable<List<T>> buffer(int count) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(int count, int skip) {
-        return create(OperationBuffer.buffer(this, count, skip));
+        return lift(new OperatorBufferWithSize<T>(count, skip));
     }
 
     /**
@@ -3034,7 +3037,7 @@ public final Observable<List<T>> buffer(int count, int skip) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit) {
-        return create(OperationBuffer.buffer(this, timespan, timeshift, unit));
+        return lift(new OperatorBufferWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, Schedulers.computation()));
     }
 
     /**
@@ -3058,7 +3061,7 @@ public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationBuffer.buffer(this, timespan, timeshift, unit, scheduler));
+        return lift(new OperatorBufferWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, scheduler));
     }
 
     /**
@@ -3079,7 +3082,7 @@ public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(long timespan, TimeUnit unit) {
-        return create(OperationBuffer.buffer(this, timespan, unit));
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, Schedulers.computation()));
     }
 
     /**
@@ -3104,7 +3107,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count) {
-        return create(OperationBuffer.buffer(this, timespan, unit, count));
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, count, Schedulers.computation()));
     }
 
     /**
@@ -3132,7 +3135,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count)
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
-        return create(OperationBuffer.buffer(this, timespan, unit, count, scheduler));
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, count, scheduler));
     }
 
     /**
@@ -3156,7 +3159,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count,
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationBuffer.buffer(this, timespan, unit, scheduler));
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, scheduler));
     }
 
     /**
@@ -3176,7 +3179,7 @@ public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final <TOpening, TClosing> Observable<List<T>> buffer(Observable<? extends TOpening> bufferOpenings, Func1<? super TOpening, ? extends Observable<? extends TClosing>> bufferClosingSelector) {
-        return create(OperationBuffer.buffer(this, bufferOpenings, bufferClosingSelector));
+        return lift(new OperatorBufferWithStartEndObservable<T, TOpening, TClosing>(bufferOpenings, bufferClosingSelector));
     }
 
     /**
@@ -3198,7 +3201,7 @@ public final <TOpening, TClosing> Observable<List<T>> buffer(Observable<? extend
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
      */
     public final <B> Observable<List<T>> buffer(Observable<B> boundary) {
-        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary));
+        return lift(new OperatorBufferWithSingleObservable<T, B>(boundary, 16));
     }
 
     /**
@@ -3222,7 +3225,7 @@ public final <B> Observable<List<T>> buffer(Observable<B> boundary) {
      * @see #buffer(rx.Observable, int)
      */
     public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialCapacity) {
-        return create(OperationBuffer.bufferWithBoundaryObservable(this, boundary, initialCapacity));
+        return lift(new OperatorBufferWithSingleObservable<T, B>(boundary, initialCapacity));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java b/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
deleted file mode 100644
index 9ce6774d60..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationBuffer.java
+++ /dev/null
@@ -1,566 +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.List;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func0;
-import rx.functions.Func1;
-import rx.schedulers.Schedulers;
-import rx.subscriptions.CompositeSubscription;
-
-public final class OperationBuffer extends ChunkedOperation {
-
-    private static <T> Func0<Buffer<T>> bufferMaker() {
-        return new Func0<Buffer<T>>() {
-            @Override
-            public Buffer<T> call() {
-                return new Buffer<T>();
-            }
-        };
-    }
-
-    /**
-     * 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 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 event is
-     * propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param bufferClosingSelector
-     *            a {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine
-     *            when a buffer is emitted and replaced by simply producing an object.
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T, TClosing> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Func0<? extends Observable<? extends TClosing>> bufferClosingSelector) {
-        return new OnSubscribeFunc<List<T>>() {
-
-            @Override
-            public Subscription onSubscribe(Observer<? super List<T>> observer) {
-                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, OperationBuffer.<T> bufferMaker());
-                ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, List<T>, TClosing>(buffers, bufferClosingSelector);
-                return new CompositeSubscription(
-                        new ChunkToSubscription(creator),
-                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(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 there are no chunks active.
-     * <p>
-     * Chunks can be created by pushing a {@link rx.util.TOpening} value to the "bufferOpenings"
-     * {@link Observable}. This creates a new buffer which will then start recording values which are produced
-     * by the "source" {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an
-     * {@link Observable} which can produce values. When it does so it will close this (and only this) newly
-     * created buffer. When the source {@link Observable} completes or produces an error, all chunks are
-     * emitted, and the event is propagated to all subscribed {@link Observer}s.
-     * </p><p>
-     * Note that when using this operation <strong>multiple overlapping chunks</strong> could be active at any
-     * one point.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param bufferOpenings
-     *            an {@link Observable} which when it produces a {@link rx.util.TOpening} value will create a
-     *            new buffer which instantly starts recording the "source" {@link Observable}
-     * @param bufferClosingSelector
-     *            a {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine
-     *            when a buffer is emitted and replaced by simply producing an object.
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T, TOpening, TClosing> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final Observable<? extends TOpening> bufferOpenings, final Func1<? super TOpening, ? extends Observable<? extends TClosing>> bufferClosingSelector) {
-        return new OnSubscribeFunc<List<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                OverlappingChunks<T, List<T>> buffers = new OverlappingChunks<T, List<T>>(observer, OperationBuffer.<T> bufferMaker());
-                ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, List<T>, TOpening, TClosing>(buffers, bufferOpenings, bufferClosingSelector);
-                return new CompositeSubscription(
-                        new ChunkToSubscription(creator),
-                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(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 a buffer until the buffer contains
-     * a specified number of elements. The buffer is then emitted, and a new buffer is created to replace it.
-     * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param count
-     *            the number of elements a buffer should have before being emitted and replaced
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, int count) {
-        return buffer(source, count, count);
-    }
-
-    /**
-     * 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 all active chunks until the buffer
-     * contains a specified number of elements. The buffer is then emitted. Chunks are created after a certain
-     * amount of values have been received. When the source {@link Observable} completes or produces an error,
-     * the currently active chunks are emitted, and the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
-     * chunks</strong> depending on the input parameters.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param count
-     *            the number of elements a buffer should have before being emitted
-     * @param skip
-     *            the interval with which chunks have to be created. Note that when {@code skip == count} that
-     *            this is the same as calling {@link OperationBuffer#buffer(Observable, int)}. If
-     *            {@code skip < count}, this buffer operation will produce overlapping chunks and if
-     *            {@code skip > count} non-overlapping chunks will be created and some values will not be pushed
-     *            into a buffer at all!
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final int count, final int skip) {
-        return new OnSubscribeFunc<List<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                Chunks<T, List<T>> chunks = new SizeBasedChunks<T, List<T>>(observer, OperationBuffer.<T> bufferMaker(), count);
-                ChunkCreator creator = new SkippingChunkCreator<T, List<T>>(chunks, skip);
-                return new CompositeSubscription(
-                        new ChunkToSubscription(creator),
-                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(chunks, 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 a buffer. Periodically the buffer
-     * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param timespan
-     *            the amount of time all chunks must be actively collect values before being emitted
-     * @param unit
-     *            the {@link TimeUnit} defining the unit of time for the timespan
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit) {
-        return buffer(source, timespan, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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. Periodically the buffer
-     * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param timespan
-     *            the amount of time all chunks must be actively collect values before being emitted
-     * @param unit
-     *            the {@link TimeUnit} defining the unit of time for the timespan
-     * @param scheduler
-     *            the {@link Scheduler} to use for timing chunks
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<List<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                NonOverlappingChunks<T, List<T>> buffers = new NonOverlappingChunks<T, List<T>>(observer, OperationBuffer.<T> bufferMaker());
-                ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timespan, unit, scheduler);
-                return new CompositeSubscription(
-                        new ChunkToSubscription(creator),
-                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(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 a buffer. Periodically the buffer
-     * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * Additionally the buffer is automatically emitted once it reaches a specified number of elements.
-     * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param timespan
-     *            the amount of time all chunks must be actively collect values before being emitted
-     * @param unit
-     *            the {@link TimeUnit} defining the unit of time for the timespan
-     * @param count
-     *            the maximum size of the buffer. Once a buffer reaches this size, it is emitted
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, TimeUnit unit, int count) {
-        return buffer(source, timespan, unit, count, Schedulers.computation());
-    }
-
-    /**
-     * 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. Periodically the buffer
-     * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * Additionally the buffer is automatically emitted once it reaches a specified number of elements.
-     * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
-     * exactly one buffer actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param timespan
-     *            the amount of time all chunks must be actively collect values before being emitted
-     * @param unit
-     *            the {@link TimeUnit} defining the unit of time for the timespan
-     * @param count
-     *            the maximum size of the buffer. Once a buffer reaches this size, it is emitted
-     * @param scheduler
-     *            the {@link Scheduler} to use for timing chunks
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
-        return new OnSubscribeFunc<List<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                TimeAndSizeBasedChunks<T, List<T>> chunks = new TimeAndSizeBasedChunks<T, List<T>>(observer, OperationBuffer.<T> bufferMaker(), count, timespan, unit, scheduler);
-                ChunkCreator creator = new SingleChunkCreator<T, List<T>>(chunks);
-                return new CompositeSubscription(
-                        chunks,
-                        new ChunkToSubscription(creator),
-                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(chunks, 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 a buffer. Periodically the buffer
-     * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
-     * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
-     * on the input parameters.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param timespan
-     *            the amount of time all chunks must be actively collect values before being emitted
-     * @param timeshift
-     *            the amount of time between creating chunks
-     * @param unit
-     *            the {@link TimeUnit} defining the unit of time for the timespan
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(Observable<T> source, long timespan, long timeshift, TimeUnit unit) {
-        return buffer(source, timespan, timeshift, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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. Periodically the buffer
-     * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
-     * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
-     * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
-     * the event is propagated to all subscribed {@link Observer}s.
-     * <p>
-     * Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
-     * on the input parameters.
-     * </p>
-     * 
-     * @param source
-     *            the {@link Observable} which produces values
-     * @param timespan
-     *            the amount of time all chunks must be actively collect values before being emitted
-     * @param timeshift
-     *            the amount of time between creating chunks
-     * @param unit
-     *            the {@link TimeUnit} defining the unit of time for the timespan
-     * @param scheduler
-     *            the {@link Scheduler} to use for timing chunks
-     * @return
-     *         the {@link Func1} object representing the specified buffer operation
-     */
-    public static <T> OnSubscribeFunc<List<T>> buffer(final Observable<T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<List<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super List<T>> observer) {
-                TimeBasedChunks<T, List<T>> buffers = new TimeBasedChunks<T, List<T>>(observer, OperationBuffer.<T> bufferMaker(), timespan, unit, scheduler);
-                ChunkCreator creator = new TimeBasedChunkCreator<T, List<T>>(buffers, timeshift, unit, scheduler);
-                return new CompositeSubscription(
-                        buffers,
-                        new ChunkToSubscription(creator),
-                        source.unsafeSubscribe(new ChunkObserver<T, List<T>>(buffers, observer, creator)));
-            }
-        };
-    }
-
-    /**
-     * This class represents a single buffer: A sequence of recorded values.
-     * 
-     * @param <T>
-     *            the type of objects which this {@link Buffer} can hold
-     */
-    protected static class Buffer<T> extends Chunk<T, List<T>> {
-        /**
-         * @return
-         *         The mutable underlying {@link List} which contains all the
-         *         recorded values in this {@link Buffer} object.
-         */
-        @Override
-        public List<T> 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();
-            }
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return done.get();
-        }
-    }
-
-    /**
-     * Create a buffer operator with the given observable sequence as the buffer boundary.
-     *
-     * @param source
-     * @param boundary
-     * @return
-     */
-    public static <T, B> OnSubscribeFunc<List<T>> bufferWithBoundaryObservable(Observable<? extends T> source, Observable<B> boundary) {
-        return new BufferWithObservableBoundary<T, B>(source, boundary, 16);
-    }
-
-    /**
-     * Create a buffer operator with the given observable sequence as the buffer boundary and
-     * with the given initial capacity for buffers.
-     *
-     * @param source
-     * @param boundary
-     * @param initialCapacity
-     * @return
-     */
-    public static <T, B> OnSubscribeFunc<List<T>> bufferWithBoundaryObservable(Observable<? extends T> source, Observable<B> boundary, int initialCapacity) {
-        if (initialCapacity <= 0) {
-            throw new IllegalArgumentException("initialCapacity > 0 required");
-        }
-        return new BufferWithObservableBoundary<T, B>(source, boundary, initialCapacity);
-    }
-
-    /**
-     * Buffer until an element is emitted from a helper observable.
-     * 
-     * @param <T>
-     *            the buffered value type
-     */
-    private static final class BufferWithObservableBoundary<T, B> implements OnSubscribeFunc<List<T>> {
-        final Observable<? extends T> source;
-        final Observable<B> boundary;
-        final int initialCapacity;
-
-        public BufferWithObservableBoundary(Observable<? extends T> source, Observable<B> boundary, int initialCapacity) {
-            this.source = source;
-            this.boundary = boundary;
-            this.initialCapacity = initialCapacity;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super List<T>> t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            SourceObserver<T> so = new SourceObserver<T>(t1, initialCapacity, csub);
-            csub.add(source.unsafeSubscribe(so));
-            csub.add(boundary.unsafeSubscribe(new BoundaryObserver<B>(so)));
-
-            return csub;
-        }
-
-        /**
-         * Observes the source.
-         */
-        private static final class SourceObserver<T> extends Subscriber<T> {
-            final Observer<? super List<T>> observer;
-            /** The buffer, if null, that indicates a terminal state. */
-            List<T> buffer;
-            final int initialCapacity;
-            final Object guard;
-            final Subscription cancel;
-
-            public SourceObserver(Observer<? super List<T>> observer, int initialCapacity, Subscription cancel) {
-                this.observer = observer;
-                this.initialCapacity = initialCapacity;
-                this.guard = new Object();
-                this.cancel = cancel;
-                buffer = new ArrayList<T>(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<T> buf;
-                synchronized (guard) {
-                    if (buffer == null) {
-                        return;
-                    }
-                    buf = buffer;
-                    buffer = new ArrayList<T>(initialCapacity);
-                }
-                observer.onNext(buf);
-            }
-
-            void emitAndComplete() {
-                List<T> buf;
-                synchronized (guard) {
-                    if (buffer == null) {
-                        return;
-                    }
-                    buf = buffer;
-                    buffer = null;
-                }
-                observer.onNext(buf);
-                observer.onCompleted();
-            }
-        }
-
-        /**
-         * Observes the boundary.
-         */
-        private static final class BoundaryObserver<T> extends Subscriber<T> {
-            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/main/java/rx/operators/OperatorBufferWithSingleObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSingleObservable.java
new file mode 100644
index 0000000000..e6efffb383
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSingleObservable.java
@@ -0,0 +1,190 @@
+/**
+ * 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.List;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Subscriber;
+import rx.functions.Func0;
+import rx.observers.SerializedSubscriber;
+import rx.observers.Subscribers;
+
+/**
+ * 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 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 event is
+ * propagated to all subscribed {@link Observer}s.
+ * <p>
+ * Note that this operation only produces <strong>non-overlapping chunks</strong>. At all times there is
+ * exactly one buffer actively storing values.
+ * </p>
+ * 
+ * @param <T> the buffered value type
+ */
+
+public final class OperatorBufferWithSingleObservable<T, TClosing> implements Operator<List<T>, T> {
+    final Func0<? extends Observable<? extends TClosing>> bufferClosingSelector;
+    final int initialCapacity;
+    /**
+     * @param bufferClosingSelector
+     *            a {@link Func0} object which produces {@link Observable}s. These {@link Observable}s determine
+     *            when a buffer is emitted and replaced by simply producing an object.
+     * @param initialCapacity the initial capacity of each buffer
+     */
+    public OperatorBufferWithSingleObservable(Func0<? extends Observable<? extends TClosing>> bufferClosingSelector,
+            int initialCapacity) {
+        this.bufferClosingSelector = bufferClosingSelector;
+        this.initialCapacity = initialCapacity;
+    }
+    /**
+     * @param bufferClosing
+     *            An {@link Observable} to determine
+     *            when a buffer is emitted and replaced by simply producing an object.
+     * @param initialCapacity the initial capacity of each buffer
+     */
+    public OperatorBufferWithSingleObservable(final Observable<? extends TClosing> bufferClosing,
+            int initialCapacity) {
+        this.bufferClosingSelector = new Func0<Observable<? extends TClosing>>() {
+            @Override
+            public Observable<? extends TClosing> call() {
+                return bufferClosing;
+            }
+        };
+        this.initialCapacity = initialCapacity;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
+        Observable<? extends TClosing> closing;
+        try {
+            closing = bufferClosingSelector.call();
+        } catch (Throwable t) {
+            child.onError(t);
+            return Subscribers.empty();
+        }
+        final BufferingSubscriber<T> bsub = new BufferingSubscriber<T>(new SerializedSubscriber<List<T>>(child));
+
+        Subscriber<TClosing> closingSubscriber = new Subscriber<TClosing>() {
+
+            @Override
+            public void onNext(TClosing t) {
+                bsub.emit();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                bsub.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                bsub.onCompleted();
+            }
+        };
+
+        child.add(closingSubscriber);
+        child.add(bsub);
+        
+        closing.unsafeSubscribe(closingSubscriber);
+        
+        return bsub;
+    }
+    
+    final class BufferingSubscriber<T> extends Subscriber<T> {
+        final Subscriber<? super List<T>> child;
+        /** Guarded by this. */
+        List<T> chunk;
+        /** Guarded by this. */
+        boolean done;
+        public BufferingSubscriber(Subscriber<? super List<T>> child) {
+            this.child = child;
+            this.chunk = new ArrayList<T>(initialCapacity);
+        }
+        @Override
+        public void onNext(T t) {
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                chunk.add(t);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                chunk = null;
+            }
+            child.onError(e);
+            unsubscribe();
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                List<T> toEmit;
+                synchronized (this) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    toEmit = chunk;
+                    chunk = null;
+                }
+                child.onNext(toEmit);
+            } catch (Throwable t) {
+                child.onError(t);
+                return;
+            }
+            child.onCompleted();
+            unsubscribe();
+        }
+        
+        void emit() {
+            List<T> toEmit;
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                toEmit = chunk;
+                chunk = new ArrayList<T>(initialCapacity);
+            }
+            try {
+                child.onNext(toEmit);
+            } catch (Throwable t) {
+                unsubscribe();
+                synchronized (this) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                }
+                child.onError(t);
+            }
+        }
+    }
+    
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSize.java b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSize.java
new file mode 100644
index 0000000000..7334d958f7
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSize.java
@@ -0,0 +1,141 @@
+/**
+ * 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.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Subscriber;
+
+/**
+ * This operation takes
+ * values from the specified {@link Observable} source and stores them in all active chunks until the buffer
+ * contains a specified number of elements. The buffer is then emitted. Chunks are created after a certain
+ * amount of values have been received. When the source {@link Observable} completes or produces an error,
+ * the currently active chunks are emitted, and the event is propagated to all subscribed {@link Subscriber}s.
+ * <p>
+ * Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
+ * chunks</strong> depending on the input parameters.
+ * </p>
+
+* @param <T> the buffered value type
+ */
+public final class OperatorBufferWithSize<T> implements Operator<List<T>, T> {
+    final int count;
+    final int skip;
+
+    /**
+     * @param count
+     *            the number of elements a buffer should have before being emitted
+     * @param skip
+     *            the interval with which chunks have to be created. Note that when {@code skip == count} 
+     *            the operator will produce non-overlapping chunks. If
+     *            {@code skip < count}, this buffer operation will produce overlapping chunks and if
+     *            {@code skip > count} non-overlapping chunks will be created and some values will not be pushed
+     *            into a buffer at all!
+     */
+    public OperatorBufferWithSize(int count, int skip) {
+        this.count = count;
+        this.skip = skip;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
+        if (count == skip) {
+            return new Subscriber<T>(child) {
+                List<T> buffer;
+                @Override
+                public void onNext(T t) {
+                    if (buffer == null) {
+                        buffer = new ArrayList<T>(count);
+                    }
+                    buffer.add(t);
+                    if (buffer.size() == count) {
+                        List<T> oldBuffer = buffer;
+                        buffer = null;
+                        child.onNext(oldBuffer);
+                    }
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    buffer = null;
+                    child.onError(e);
+                }
+
+                @Override
+                public void onCompleted() {
+                    List<T> oldBuffer = buffer;
+                    buffer = null;
+                    if (oldBuffer != null) {
+                        try {
+                            child.onNext(oldBuffer);
+                        } catch (Throwable t) {
+                            onError(t);
+                            return;
+                        }
+                    }
+                    child.onCompleted();
+                }
+            };
+        }
+        return new Subscriber<T>(child) {
+            final List<List<T>> chunks = new LinkedList<List<T>>();
+            int index;
+            @Override
+            public void onNext(T t) {
+                if (index++ % skip == 0) {
+                    chunks.add(new ArrayList<T>(count));
+                }
+                
+                Iterator<List<T>> it = chunks.iterator();
+                while (it.hasNext()) {
+                    List<T> chunk = it.next();
+                    chunk.add(t);
+                    if (chunk.size() == count) {
+                        it.remove();
+                        child.onNext(chunk);
+                    }
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                chunks.clear();
+                child.onError(e);
+            }
+            @Override
+            public void onCompleted() {
+                try {
+                    for (List<T> chunk : chunks) {
+                        try {
+                            child.onNext(chunk);
+                        } catch (Throwable t) {
+                            onError(t);
+                            return;
+                        }
+                    }
+                    child.onCompleted();
+                } finally {
+                    chunks.clear();
+                }
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java
new file mode 100644
index 0000000000..931238e580
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java
@@ -0,0 +1,215 @@
+/**
+ * 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.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Subscriber;
+import rx.functions.Func1;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * This operation takes
+ * values from the specified {@link Observable} source and stores them in the currently active chunks.
+ * Initially there are no chunks active.
+ * <p>
+ * Chunks can be created by pushing a {@link rx.util.TOpening} value to the "bufferOpenings"
+ * {@link Observable}. This creates a new buffer which will then start recording values which are produced
+ * by the "source" {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an
+ * {@link Observable} which can produce values. When it does so it will close this (and only this) newly
+ * created buffer. When the source {@link Observable} completes or produces an error, all chunks are
+ * emitted, and the event is propagated to all subscribed {@link Observer}s.
+ * </p><p>
+ * Note that when using this operation <strong>multiple overlapping chunks</strong> could be active at any
+ * one point.
+ * </p>
+ * 
+ * @param <T> the buffered value type
+ */
+
+public final class OperatorBufferWithStartEndObservable<T, TOpening, TClosing> implements Operator<List<T>, T> {
+    final Observable<? extends TOpening> bufferOpening;
+    final Func1<? super TOpening, ? extends Observable<? extends TClosing>> bufferClosing;
+
+    /**
+     * @param bufferOpenings
+     *            an {@link Observable} which when it produces a {@link rx.util.TOpening} value will create a
+     *            new buffer which instantly starts recording the "source" {@link Observable}
+     * @param bufferClosingSelector
+     *            a {@link Func1} object which produces {@link Observable}s. These {@link Observable}s determine
+     *            when a buffer is emitted and replaced by simply producing an object.
+     */
+    public OperatorBufferWithStartEndObservable(Observable<? extends TOpening> bufferOpenings, Func1<? super TOpening, ? extends Observable<? extends TClosing>> bufferClosingSelector) {
+        this.bufferOpening = bufferOpenings;
+        this.bufferClosing = bufferClosingSelector;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
+        
+        final BufferingSubscriber bsub = new BufferingSubscriber(new SerializedSubscriber<List<T>>(child));
+        
+        Subscriber<TOpening> openSubscriber = new Subscriber<TOpening>() {
+
+            @Override
+            public void onNext(TOpening t) {
+                bsub.startBuffer(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                bsub.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                bsub.onCompleted();
+            }
+            
+        };
+        child.add(openSubscriber);
+        child.add(bsub);
+        
+        bufferOpening.unsafeSubscribe(openSubscriber);
+        
+        return bsub;
+    }
+    final class BufferingSubscriber extends Subscriber<T> {
+        final Subscriber<? super List<T>> child;
+        /** Guarded by this. */
+        final List<List<T>> chunks;
+        /** Guarded by this. */
+        boolean done;
+        final CompositeSubscription closingSubscriptions;
+        public BufferingSubscriber(Subscriber<? super List<T>> child) {
+            this.child = child;
+            this.chunks = new LinkedList<List<T>>();
+            this.closingSubscriptions = new CompositeSubscription();
+            add(this.closingSubscriptions);
+        }
+
+        @Override
+        public void onNext(T t) {
+            synchronized (this) {
+                for (List<T> chunk : chunks) {
+                    chunk.add(t);
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                chunks.clear();
+            }
+            child.onError(e);
+            unsubscribe();
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                List<List<T>> toEmit;
+                synchronized (this) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    toEmit = new LinkedList<List<T>>(chunks);
+                    chunks.clear();
+                }
+                for (List<T> chunk : toEmit) {
+                    child.onNext(chunk);
+                }
+            } catch (Throwable t) {
+                child.onError(t);
+                return;
+            }
+            child.onCompleted();
+            unsubscribe();
+        }
+        void startBuffer(TOpening v) {
+            final List<T> chunk = new ArrayList<T>();
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                chunks.add(chunk);
+            }
+            Observable<? extends TClosing> cobs;
+            try {
+                cobs = bufferClosing.call(v);
+            } catch (Throwable t) {
+                onError(t);
+                return;
+            }
+            Subscriber<TClosing> closeSubscriber = new Subscriber<TClosing>() {
+
+                @Override
+                public void onNext(TClosing t) {
+                    closingSubscriptions.remove(this);
+                    endBuffer(chunk);
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    BufferingSubscriber.this.onError(e);
+                }
+
+                @Override
+                public void onCompleted() {
+                    closingSubscriptions.remove(this);
+                    endBuffer(chunk);
+                }
+                
+            };
+            closingSubscriptions.add(closeSubscriber);
+            
+            cobs.unsafeSubscribe(closeSubscriber);
+        }
+        void endBuffer(List<T> toEnd) {
+            boolean canEnd = false;
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                Iterator<List<T>> it = chunks.iterator();
+                while (it.hasNext()) {
+                    List<T> chunk = it.next();
+                    if (chunk == toEnd) {
+                        canEnd = true;
+                        it.remove();
+                        break;
+                    }
+                }
+            }
+            if (canEnd) {
+                child.onNext(toEnd);
+            }
+        }
+        
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithTime.java b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithTime.java
new file mode 100644
index 0000000000..98a3efd654
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithTime.java
@@ -0,0 +1,302 @@
+/**
+ * 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.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observers.SerializedSubscriber;
+
+/**
+ * This operation takes
+ * values from the specified {@link Observable} source and stores them in a buffer. Periodically the buffer
+ * is emitted and replaced with a new buffer. How often this is done depends on the specified timespan.
+ * The creation of chunks is also periodical. How often this is done depends on the specified timeshift.
+ * When the source {@link Observable} completes or produces an error, the current buffer is emitted, and
+ * the event is propagated to all subscribed {@link Subscriber}s.
+ * <p>
+ * Note that this operation can produce <strong>non-connected, or overlapping chunks</strong> depending
+ * on the input parameters.
+ * </p>
+ * 
+ * @param <T> the buffered value type
+ */
+public final class OperatorBufferWithTime<T> implements Operator<List<T>, T> {
+    final long timespan;
+    final long timeshift;
+    final TimeUnit unit;
+    final int count;
+    final Scheduler scheduler;
+
+    /**
+     * @param timespan
+     *            the amount of time all chunks must be actively collect values before being emitted
+     * @param timeshift
+     *            the amount of time between creating chunks
+     * @param unit
+     *            the {@link TimeUnit} defining the unit of time for the timespan
+     * @param count
+     *            the maximum size of the buffer. Once a buffer reaches this size, it is emitted
+     * @param scheduler
+     *            the {@link Scheduler} to use for timing chunks
+     */
+    public OperatorBufferWithTime(long timespan, long timeshift, TimeUnit unit, int count, Scheduler scheduler) {
+        this.timespan = timespan;
+        this.timeshift = timeshift;
+        this.unit = unit;
+        this.count = count;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
+        final Worker inner = scheduler.createWorker();
+        child.add(inner);
+        
+        if (timespan == timeshift) {
+            ExactSubscriber bsub = new ExactSubscriber(new SerializedSubscriber<List<T>>(child), inner);
+            bsub.scheduleExact();
+            return bsub;
+        }
+        
+        InexactSubscriber bsub = new InexactSubscriber(new SerializedSubscriber<List<T>>(child), inner);
+        bsub.startNewChunk();
+        bsub.scheduleChunk();
+        return bsub;
+    }
+    /** Subscriber when the buffer chunking time and lenght differ. */
+    final class InexactSubscriber extends Subscriber<T> {
+        final Subscriber<? super List<T>> child;
+        final Worker inner;
+        /** Guarded by this. */
+        final List<List<T>> chunks;
+        /** Guarded by this. */
+        boolean done;
+        public InexactSubscriber(Subscriber<? super List<T>> child, Worker inner) {
+            super(child);
+            this.child = child;
+            this.inner = inner;
+            this.chunks = new LinkedList<List<T>>();
+        }
+
+        @Override
+        public void onNext(T t) {
+            List<List<T>> sizeReached = null;
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                Iterator<List<T>> it = chunks.iterator();
+                while (it.hasNext()) {
+                    List<T> chunk = it.next();
+                    chunk.add(t);
+                    if (chunk.size() == count) {
+                        it.remove();
+                        if (sizeReached == null) {
+                            sizeReached = new LinkedList<List<T>>();
+                        }
+                        sizeReached.add(chunk);
+                    }
+                }
+            }
+            if (sizeReached != null) {
+                for (List<T> chunk : sizeReached) {
+                    child.onNext(chunk);
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                chunks.clear();
+            }
+            child.onError(e);
+            unsubscribe();
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                List<List<T>> sizeReached;
+                synchronized (this) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    sizeReached = new LinkedList<List<T>>(chunks);
+                    chunks.clear();
+                }
+                for (List<T> chunk : sizeReached) {
+                    child.onNext(chunk);
+                }
+            } catch (Throwable t) {
+                child.onError(t);
+                return;
+            }
+            child.onCompleted();
+            unsubscribe();
+        }
+        void scheduleChunk() {
+            inner.schedulePeriodically(new Action0() {
+                @Override
+                public void call() {
+                    startNewChunk();
+                }
+            }, timeshift, timeshift, unit);
+        }
+        void startNewChunk() {
+            final List<T> chunk = new ArrayList<T>();
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                chunks.add(chunk);
+            }
+            inner.schedule(new Action0() {
+                @Override
+                public void call() {
+                    emitChunk(chunk);
+                }
+            }, timespan, unit);
+        }
+        void emitChunk(List<T> chunkToEmit) {
+            boolean emit = false;
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                Iterator<List<T>> it = chunks.iterator();
+                while (it.hasNext()) {
+                    List<T> chunk = it.next();
+                    if (chunk == chunkToEmit) {
+                        it.remove();
+                        emit = true;
+                        break;
+                    }
+                }
+            }
+            if (emit) {
+                try {
+                    child.onNext(chunkToEmit);
+                } catch (Throwable t) {
+                    onError(t);
+                }
+            }
+        }
+    }
+    /** Subscriber when exact timed chunking is required. */
+    final class ExactSubscriber extends Subscriber<T> {
+        final Subscriber<? super List<T>> child;
+        final Worker inner;
+        /** Guarded by this. */
+        List<T> chunk;
+        /** Guarded by this. */
+        boolean done;
+        public ExactSubscriber(Subscriber<? super List<T>> child, Worker inner) {
+            super(child);
+            this.child = child;
+            this.inner = inner;
+            this.chunk = new ArrayList<T>();
+        }
+
+        @Override
+        public void onNext(T t) {
+            List<T> toEmit = null;
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                chunk.add(t);
+                if (chunk.size() == count) {
+                    toEmit = chunk;
+                    chunk = new ArrayList<T>();
+                }
+            }
+            if (toEmit != null) {
+                child.onNext(toEmit);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                chunk = null;
+            }
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            try {
+                inner.unsubscribe();
+                List<T> toEmit;
+                synchronized (this) {
+                    if (done) {
+                        return;
+                    }
+                    done = true;
+                    toEmit = chunk;
+                    chunk = null;
+                }
+                child.onNext(toEmit);
+            } catch (Throwable t) {
+                child.onError(t);
+                return;
+            }
+            child.onCompleted();
+        }
+        void scheduleExact() {
+            inner.schedulePeriodically(new Action0() {
+                @Override
+                public void call() {
+                    emit();
+                }
+            }, timespan, timespan, unit);
+        }
+        void emit() {
+            List<T> toEmit;
+            synchronized (this) {
+                if (done) {
+                    return;
+                }
+                toEmit = chunk;
+                chunk = new ArrayList<T>();
+            }
+            try {
+                child.onNext(toEmit);
+            } catch (Throwable t) {
+                onError(t);
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
index aa1c525e99..39cb174b0a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
@@ -17,11 +17,7 @@
 
 import static org.junit.Assert.assertFalse;
 import static org.mockito.Matchers.any;
-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.OperationBuffer.buffer;
+import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -70,7 +66,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, 3, 3));
+        Observable<List<String>> buffered = source.buffer(3, 3);
         buffered.subscribe(observer);
 
         Mockito.verify(observer, Mockito.never()).onNext(Mockito.anyListOf(String.class));
@@ -92,7 +88,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, 3, 1));
+        Observable<List<String>> buffered = source.buffer(3, 1);
         buffered.subscribe(observer);
 
         InOrder inOrder = Mockito.inOrder(observer);
@@ -119,7 +115,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, 3, 3));
+        Observable<List<String>> buffered = source.buffer(3, 3);
         buffered.subscribe(observer);
 
         InOrder inOrder = Mockito.inOrder(observer);
@@ -145,7 +141,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, 2, 3));
+        Observable<List<String>> buffered = source.buffer(2, 3);
         buffered.subscribe(observer);
 
         InOrder inOrder = Mockito.inOrder(observer);
@@ -171,7 +167,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, 100, TimeUnit.MILLISECONDS, 2, scheduler));
+        Observable<List<String>> buffered = source.buffer(100, TimeUnit.MILLISECONDS, 2, scheduler);
         buffered.subscribe(observer);
 
         InOrder inOrder = Mockito.inOrder(observer);
@@ -193,9 +189,14 @@ public void testTimed() {
         Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
             @Override
             public Subscription onSubscribe(Observer<? super String> observer) {
-                push(observer, "one", 98);
-                push(observer, "two", 99);
-                push(observer, "three", 100);
+                push(observer, "one", 97);
+                push(observer, "two", 98);
+                /**
+                 * Changed from 100. Because scheduling the cut to 100ms happens before this
+                 * Observable even runs due how lift works, pushing at 100ms would execute after the
+                 * buffer cut.
+                 */
+                push(observer, "three", 99);
                 push(observer, "four", 101);
                 push(observer, "five", 102);
                 complete(observer, 150);
@@ -203,7 +204,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, 100, TimeUnit.MILLISECONDS, scheduler));
+        Observable<List<String>> buffered = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
         buffered.subscribe(observer);
 
         InOrder inOrder = Mockito.inOrder(observer);
@@ -256,7 +257,7 @@ public Subscription onSubscribe(Observer<? super Object> observer) {
             }
         };
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, openings, closer));
+        Observable<List<String>> buffered = source.buffer(openings, closer);
         buffered.subscribe(observer);
 
         InOrder inOrder = Mockito.inOrder(observer);
@@ -290,14 +291,16 @@ public Observable<Object> call() {
                     @Override
                     public Subscription onSubscribe(Observer<? super Object> observer) {
                         push(observer, new Object(), 100);
-                        complete(observer, 101);
+                        push(observer, new Object(), 200);
+                        push(observer, new Object(), 300);
+                        complete(observer, 301);
                         return Subscriptions.empty();
                     }
                 });
             }
         };
 
-        Observable<List<String>> buffered = Observable.create(buffer(source, closer));
+        Observable<List<String>> buffered = source.buffer(closer);
         buffered.subscribe(observer);
 
         InOrder inOrder = Mockito.inOrder(observer);
@@ -522,4 +525,263 @@ public void bufferWithBOBoundaryThrows() {
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
     }
+    @Test(timeout = 2000)
+    public void bufferWithSizeTake1() {
+        Observable<Integer> source = Observable.from(1).repeat();
+        
+        Observable<List<Integer>> result = source.buffer(2).take(1);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 1));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test(timeout = 2000)
+    public void bufferWithSizeSkipTake1() {
+        Observable<Integer> source = Observable.from(1).repeat();
+        
+        Observable<List<Integer>> result = source.buffer(2, 3).take(1);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 1));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test(timeout = 2000)
+    public void bufferWithTimeTake1() {
+        Observable<Long> source = Observable.timer(40, 40, TimeUnit.MILLISECONDS, scheduler);
+        
+        Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler).take(1);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
+        
+        verify(o).onNext(Arrays.asList(0L, 1L));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test(timeout = 2000)
+    public void bufferWithTimeSkipTake2() {
+        Observable<Long> source = Observable.timer(40, 40, TimeUnit.MILLISECONDS, scheduler);
+        
+        Observable<List<Long>> result = source.buffer(100, 60, TimeUnit.MILLISECONDS, scheduler).take(2);
+        
+        Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+        
+        scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
+        
+        inOrder.verify(o).onNext(Arrays.asList(0L, 1L));
+        inOrder.verify(o).onNext(Arrays.asList(1L, 2L));
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test(timeout = 2000)
+    public void bufferWithBoundaryTake2() {
+        Observable<Long> boundary = Observable.timer(60, 60, TimeUnit.MILLISECONDS, scheduler);
+        Observable<Long> source = Observable.timer(40, 40, TimeUnit.MILLISECONDS, scheduler);
+        
+        Observable<List<Long>> result = source.buffer(boundary).take(2);
+        
+        Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+        
+        scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
+        
+        inOrder.verify(o).onNext(Arrays.asList(0L));
+        inOrder.verify(o).onNext(Arrays.asList(1L));
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    
+    @Test(timeout = 2000)
+    public void bufferWithStartEndBoundaryTake2() {
+        Observable<Long> start = Observable.timer(61, 61, TimeUnit.MILLISECONDS, scheduler);
+        Func1<Long, Observable<Long>> end = new Func1<Long, Observable<Long>>() {
+            @Override
+            public Observable<Long> call(Long t1) {
+                return Observable.timer(100, 100, TimeUnit.MILLISECONDS, scheduler);
+            }
+        };
+        
+        Observable<Long> source = Observable.timer(40, 40, TimeUnit.MILLISECONDS, scheduler);
+        
+        Observable<List<Long>> result = source.buffer(start, end).take(2);
+        
+        Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+        
+        scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
+        
+        inOrder.verify(o).onNext(Arrays.asList(1L, 2L, 3L));
+        inOrder.verify(o).onNext(Arrays.asList(3L, 4L));
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void bufferWithSizeThrows() {
+        PublishSubject<Integer> source = PublishSubject.create();
+        
+        Observable<List<Integer>> result = source.buffer(2);
+        
+        Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onNext(3);
+        source.onError(new OperationReduceTest.CustomException());
+        
+        inOrder.verify(o).onNext(Arrays.asList(1, 2));
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(Arrays.asList(3));
+        verify(o, never()).onCompleted();
+                
+    }
+    
+    @Test
+    public void bufferWithTimeThrows() {
+        PublishSubject<Integer> source = PublishSubject.create();
+        
+        Observable<List<Integer>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
+        
+        Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        source.onNext(2);
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        source.onNext(3);
+        source.onError(new OperationReduceTest.CustomException());
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        
+        inOrder.verify(o).onNext(Arrays.asList(1, 2));
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(o, never()).onNext(Arrays.asList(3));
+        verify(o, never()).onCompleted();
+                
+    }
+    @Test
+    public void bufferWithTimeAndSize() {
+        Observable<Long> source = Observable.timer(30, 30, TimeUnit.MILLISECONDS, scheduler);
+        
+        Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, 2, scheduler).take(3);
+        
+        Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+        
+        scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
+        
+        inOrder.verify(o).onNext(Arrays.asList(0L, 1L));
+        inOrder.verify(o).onNext(Arrays.asList(2L));
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void bufferWithStartEndStartThrows() {
+        PublishSubject<Integer> start = PublishSubject.create();
+        
+        Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer t1) {
+                return Observable.never();
+            }
+        };
+
+        PublishSubject<Integer> source = PublishSubject.create();
+
+        Observable<List<Integer>> result = source.buffer(start, end);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        start.onNext(1);
+        source.onNext(1);
+        source.onNext(2);
+        start.onError(new OperationReduceTest.CustomException());
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+    @Test
+    public void bufferWithStartEndEndFunctionThrows() {
+        PublishSubject<Integer> start = PublishSubject.create();
+        
+        Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer t1) {
+                throw new OperationReduceTest.CustomException();
+            }
+        };
+
+        PublishSubject<Integer> source = PublishSubject.create();
+
+        Observable<List<Integer>> result = source.buffer(start, end);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        start.onNext(1);
+        source.onNext(1);
+        source.onNext(2);
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
+    @Test
+    public void bufferWithStartEndEndThrows() {
+        PublishSubject<Integer> start = PublishSubject.create();
+        
+        Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Integer t1) {
+                return Observable.error(new OperationReduceTest.CustomException());
+            }
+        };
+
+        PublishSubject<Integer> source = PublishSubject.create();
+
+        Observable<List<Integer>> result = source.buffer(start, end);
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        start.onNext(1);
+        source.onNext(1);
+        source.onNext(2);
+        
+        verify(o, never()).onNext(any());
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
 }

From a8c1e3c8ee14b612bfc086ee9cad2c78151837af Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 23 Apr 2014 15:06:47 +0200
Subject: [PATCH 263/422] OperatorConcat

---
 rxjava-core/src/main/java/rx/Observable.java  |  20 +-
 .../java/rx/operators/OperationConcat.java    | 175 ------------------
 .../java/rx/operators/OperatorConcat.java     | 119 ++++++++++++
 .../rx/operators/OperationConcatTest.java     |  95 ++++++++--
 4 files changed, 206 insertions(+), 203 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationConcat.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorConcat.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..36617e6abe 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -50,7 +50,6 @@
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationBuffer;
 import rx.operators.OperationCombineLatest;
-import rx.operators.OperationConcat;
 import rx.operators.OperationDebounce;
 import rx.operators.OperationDefaultIfEmpty;
 import rx.operators.OperationDefer;
@@ -95,6 +94,7 @@
 import rx.operators.OperatorAsObservable;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorConcat;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
@@ -740,7 +740,7 @@ public final static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combin
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
     public final static <T> Observable<T> concat(Observable<? extends Observable<? extends T>> observables) {
-        return create(OperationConcat.concat(observables));
+        return observables.lift(new OperatorConcat<T>());
     }
 
     /**
@@ -761,7 +761,7 @@ public final static <T> Observable<T> concat(Observable<? extends Observable<? e
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2) {
-        return create(OperationConcat.concat(t1, t2));
+        return concat(from(t1, t2));
     }
 
     /**
@@ -784,7 +784,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
-        return create(OperationConcat.concat(t1, t2, t3));
+        return concat(from(t1, t2, t3));
     }
 
     /**
@@ -809,7 +809,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
-        return create(OperationConcat.concat(t1, t2, t3, t4));
+        return concat(from(t1, t2, t3, t4));
     }
 
     /**
@@ -836,7 +836,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
-        return create(OperationConcat.concat(t1, t2, t3, t4, t5));
+        return concat(from(t1, t2, t3, t4, t5));
     }
 
     /**
@@ -865,7 +865,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
-        return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6));
+        return concat(from(t1, t2, t3, t4, t5, t6));
     }
 
     /**
@@ -896,7 +896,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
-        return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6, t7));
+        return concat(from(t1, t2, t3, t4, t5, t6, t7));
     }
 
     /**
@@ -929,7 +929,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
-        return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6, t7, t8));
+        return concat(from(t1, t2, t3, t4, t5, t6, t7, t8));
     }
 
     /**
@@ -964,7 +964,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
-        return create(OperationConcat.concat(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+        return concat(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationConcat.java b/rxjava-core/src/main/java/rx/operators/OperationConcat.java
deleted file mode 100644
index 8c39379a3e..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationConcat.java
+++ /dev/null
@@ -1,175 +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.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.observers.Subscribers;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Returns an Observable that emits the items emitted by two or more Observables, one after the
- * other.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/concat.png">
- */
-public final class OperationConcat {
-
-    /**
-     * Combine the observable sequences from the list of Observables into one
-     * observable sequence without any transformation. If either the outer
-     * observable or an inner observable calls onError, we will call onError.
-     * <p/>
-     * 
-     * @param sequences
-     *            An observable sequence of elements to project.
-     * @return An observable sequence whose elements are the result of combining the output from the list of Observables.
-     */
-    public static <T> OnSubscribeFunc<T> concat(final Observable<? extends T>... sequences) {
-        return concat(Observable.from(sequences));
-    }
-
-    public static <T> OnSubscribeFunc<T> concat(final Iterable<? extends Observable<? extends T>> sequences) {
-        return concat(Observable.from(sequences));
-    }
-
-    public static <T> OnSubscribeFunc<T> concat(final Observable<? extends Observable<? extends T>> sequences) {
-        return new OnSubscribeFunc<T>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super T> t1) {
-                return new Concat<T>(sequences).onSubscribe(t1);
-            }
-        };
-    }
-
-    private static class Concat<T> implements OnSubscribeFunc<T> {
-        private Observable<? extends Observable<? extends T>> sequences;
-        private SafeObservableSubscription innerSubscription = null;
-
-        public Concat(Observable<? extends Observable<? extends T>> sequences) {
-            this.sequences = sequences;
-        }
-
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final AtomicBoolean completedOrErred = new AtomicBoolean(false);
-            final AtomicBoolean allSequencesReceived = new AtomicBoolean(false);
-            final Queue<Observable<? extends T>> nextSequences = new ConcurrentLinkedQueue<Observable<? extends T>>();
-            final SafeObservableSubscription outerSubscription = new SafeObservableSubscription();
-
-            final Observer<T> reusableObserver = new Observer<T>() {
-                @Override
-                public void onNext(T item) {
-                    observer.onNext(item);
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    if (completedOrErred.compareAndSet(false, true)) {
-                        outerSubscription.unsubscribe();
-                        observer.onError(e);
-                    }
-                }
-
-                @Override
-                public void onCompleted() {
-                    synchronized (nextSequences) {
-                        if (nextSequences.isEmpty()) {
-                            // No new sequences available at the moment
-                            innerSubscription = null;
-                            if (allSequencesReceived.get()) {
-                                // No new sequences are coming, we are finished
-                                if (completedOrErred.compareAndSet(false, true)) {
-                                    observer.onCompleted();
-                                }
-                            }
-                        } else {
-                            // Continue on to the next sequence
-                            innerSubscription = new SafeObservableSubscription();
-                            innerSubscription.wrap(nextSequences.poll().unsafeSubscribe(Subscribers.from(this)));
-                        }
-                    }
-                }
-            };
-
-            outerSubscription.wrap(sequences.unsafeSubscribe(new Subscriber<Observable<? extends T>>() {
-                @Override
-                public void onNext(Observable<? extends T> nextSequence) {
-                    synchronized (nextSequences) {
-                        if (innerSubscription == null) {
-                            // We are currently not subscribed to any sequence
-                            innerSubscription = new SafeObservableSubscription();
-                            innerSubscription.wrap(nextSequence.unsafeSubscribe(Subscribers.from(reusableObserver)));
-                        } else {
-                            // Put this sequence at the end of the queue
-                            nextSequences.add(nextSequence);
-                        }
-                    }
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    if (completedOrErred.compareAndSet(false, true)) {
-                        Subscription q;
-                        synchronized (nextSequences) {
-                            q = innerSubscription;
-                        }
-                        if (q != null) {
-                            q.unsubscribe();
-                        }
-                        observer.onError(e);
-                    }
-                }
-
-                @Override
-                public void onCompleted() {
-                    allSequencesReceived.set(true);
-                    Subscription q;
-                    synchronized (nextSequences) {
-                        q = innerSubscription;
-                    }
-                    if (q == null) {
-                        // We are not subscribed to any sequence, and none are coming anymore
-                        if (completedOrErred.compareAndSet(false, true)) {
-                            observer.onCompleted();
-                        }
-                    }
-                }
-            }));
-
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    Subscription q;
-                    synchronized (nextSequences) {
-                        q = innerSubscription;
-                    }
-                    if (q != null) {
-                        q.unsubscribe();
-                    }
-                    outerSubscription.unsubscribe();
-                }
-            });
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorConcat.java b/rxjava-core/src/main/java/rx/operators/OperatorConcat.java
new file mode 100644
index 0000000000..7b6a21eafe
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorConcat.java
@@ -0,0 +1,119 @@
+ /**
+  * 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.AtomicInteger;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.SerialSubscription;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Returns an Observable that emits the items emitted by two or more Observables, one after the
+ * other.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/concat.png">
+ */
+public final class OperatorConcat<T> implements Operator<T, Observable<? extends T>> {
+    final NotificationLite<Observable<? extends T>> nl = NotificationLite.instance();
+    @Override
+    public Subscriber<? super Observable<? extends T>> call(final Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final SerialSubscription current = new SerialSubscription();
+        child.add(current);
+        return new ConcatSubscriber(s, current);
+    }
+    
+    final class ConcatSubscriber extends Subscriber<Observable<? extends T>> {
+        
+        private final Subscriber<T> s;
+        private final SerialSubscription current;
+        final ConcurrentLinkedQueue<Object> queue;
+        final AtomicInteger wip;
+        
+        public ConcatSubscriber(Subscriber<T> s, SerialSubscription current) {
+            super(s);
+            this.s = s;
+            this.current = current;
+            this.queue = new ConcurrentLinkedQueue<Object>();
+            this.wip = new AtomicInteger();
+            add(Subscriptions.create(new Action0() {
+                @Override
+                public void call() {
+                    queue.clear();
+                }
+            }));
+        }
+        
+        @Override
+        public void onNext(Observable<? extends T> t) {
+            queue.add(nl.next(t));
+            if (wip.getAndIncrement() == 0) {
+                subscribeNext();
+            }
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            s.onError(e);
+            unsubscribe();
+        }
+        
+        @Override
+        public void onCompleted() {
+            queue.add(nl.completed());
+            if (wip.getAndIncrement() == 0) {
+                subscribeNext();
+            }
+        }
+        
+        void subscribeNext() {
+            Object o = queue.poll();
+            if (nl.isCompleted(o)) {
+                s.onCompleted();
+            } else 
+            if (o != null) {
+                Observable<? extends T> obs = nl.getValue(o);
+                Subscriber<T> sourceSub = new Subscriber<T>() {
+
+                    @Override
+                    public void onNext(T t) {
+                        s.onNext(t);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        ConcatSubscriber.this.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        if (wip.decrementAndGet() > 0) {
+                            subscribeNext();
+                        }
+                    }
+
+                };
+                current.set(sourceSub);
+                obs.unsafeSubscribe(sourceSub);
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
index 557b0b5aff..2a56cea355 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
@@ -23,7 +23,6 @@
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationConcat.concat;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -36,7 +35,9 @@
 import org.mockito.InOrder;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.BooleanSubscription;
@@ -56,7 +57,7 @@ public void testConcat() {
         final Observable<String> even = Observable.from(e);
 
         @SuppressWarnings("unchecked")
-        Observable<String> concat = Observable.create(concat(odds, even));
+        Observable<String> concat = Observable.concat(odds, even);
         concat.subscribe(observer);
 
         verify(observer, times(7)).onNext(anyString());
@@ -75,7 +76,7 @@ public void testConcatWithList() {
         final List<Observable<String>> list = new ArrayList<Observable<String>>();
         list.add(odds);
         list.add(even);
-        Observable<String> concat = Observable.create(concat(list));
+        Observable<String> concat = Observable.concat(Observable.from(list));
         concat.subscribe(observer);
 
         verify(observer, times(7)).onNext(anyString());
@@ -105,7 +106,7 @@ public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
             }
 
         });
-        Observable<String> concat = Observable.create(concat(observableOfObservables));
+        Observable<String> concat = Observable.concat(observableOfObservables);
 
         concat.subscribe(observer);
 
@@ -203,7 +204,7 @@ public void run() {
             }
         });
 
-        Observable.create(concat(observableOfObservables)).subscribe(observer);
+        Observable.concat(observableOfObservables).subscribe(observer);
 
         // wait for parent to start
         parentHasStarted.await();
@@ -263,9 +264,8 @@ public void testBlockedObservableOfObservables() {
         final CountDownLatch callOnce = new CountDownLatch(1);
         final CountDownLatch okToContinue = new CountDownLatch(1);
         TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(callOnce, okToContinue, odds, even);
-        Observable.OnSubscribeFunc<String> concatF = concat(Observable.create(observableOfObservables));
-        Observable<String> concat = Observable.create(concatF);
-        concat.subscribe(observer);
+        Observable<String> concatF = Observable.concat(Observable.create(observableOfObservables));
+        concatF.subscribe(observer);
         try {
             //Block main thread to allow observables to serve up o1.
             callOnce.await();
@@ -303,11 +303,9 @@ public void testConcatConcurrentWithInfinity() {
         Observer<String> observer = mock(Observer.class);
         @SuppressWarnings("unchecked")
         TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(Observable.create(w1), Observable.create(w2));
-        Observable.OnSubscribeFunc<String> concatF = concat(Observable.create(observableOfObservables));
-
-        Observable<String> concat = Observable.create(concatF);
+        Observable<String> concatF = Observable.concat(Observable.create(observableOfObservables));
 
-        concat.take(50).subscribe(observer);
+        concatF.take(50).subscribe(observer);
 
         //Wait for the thread to start up.
         try {
@@ -351,7 +349,7 @@ public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
             }
 
         });
-        Observable<String> concat = Observable.create(concat(observableOfObservables));
+        Observable<String> concat = Observable.concat(observableOfObservables);
         concat.subscribe(observer);
 
         verify(observer, times(0)).onCompleted();
@@ -391,7 +389,7 @@ public void testConcatUnsubscribe() {
         @SuppressWarnings("unchecked")
         final Observer<String> observer = mock(Observer.class);
         @SuppressWarnings("unchecked")
-        final Observable<String> concat = Observable.create(concat(Observable.create(w1), Observable.create(w2)));
+        final Observable<String> concat = Observable.concat(Observable.create(w1), Observable.create(w2));
 
         try {
             // Subscribe
@@ -434,11 +432,9 @@ public void testConcatUnsubscribeConcurrent() {
         Observer<String> observer = mock(Observer.class);
         @SuppressWarnings("unchecked")
         TestObservable<Observable<String>> observableOfObservables = new TestObservable<Observable<String>>(Observable.create(w1), Observable.create(w2));
-        Observable.OnSubscribeFunc<String> concatF = concat(Observable.create(observableOfObservables));
-
-        Observable<String> concat = Observable.create(concatF);
+        Observable<String> concatF = Observable.concat(Observable.create(observableOfObservables));
 
-        Subscription s1 = concat.subscribe(observer);
+        Subscription s1 = concatF.subscribe(observer);
 
         try {
             //Block main thread to allow observable "w1" to complete and observable "w2" to call onNext exactly once.
@@ -593,4 +589,67 @@ public void testMultipleObservers() {
         verify(o1, never()).onError(any(Throwable.class));
         verify(o2, never()).onError(any(Throwable.class));
     }
+    
+    @Test
+    public void concatVeryLongObservableOfObservables() {
+        final int n = 10000;
+        Observable<Observable<Integer>> source = Observable.create(new OnSubscribe<Observable<Integer>>() {
+            @Override
+            public void call(Subscriber<? super Observable<Integer>> s) {
+                for (int i = 0; i < n; i++) {
+                    if (s.isUnsubscribed()) {
+                        return;
+                    }
+                    s.onNext(Observable.from(i));
+                }
+                s.onCompleted();
+            }
+        });
+        
+        Observable<List<Integer>> result = Observable.concat(source).toList();
+        
+        Observer<List<Integer>> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+
+        List<Integer> list = new ArrayList<Integer>(n);
+        for (int i = 0; i < n; i++) {
+            list.add(i);
+        }
+        inOrder.verify(o).onNext(list);
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void concatVeryLongObservableOfObservablesTakeHalf() {
+        final int n = 10000;
+        Observable<Observable<Integer>> source = Observable.create(new OnSubscribe<Observable<Integer>>() {
+            @Override
+            public void call(Subscriber<? super Observable<Integer>> s) {
+                for (int i = 0; i < n; i++) {
+                    if (s.isUnsubscribed()) {
+                        return;
+                    }
+                    s.onNext(Observable.from(i));
+                }
+                s.onCompleted();
+            }
+        });
+        
+        Observable<List<Integer>> result = Observable.concat(source).take(n / 2).toList();
+        
+        Observer<List<Integer>> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+
+        List<Integer> list = new ArrayList<Integer>(n);
+        for (int i = 0; i < n / 2; i++) {
+            list.add(i);
+        }
+        inOrder.verify(o).onNext(list);
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
 }

From b50a6647f923f9826dcabe2d3243098cc7207f34 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 23 Apr 2014 17:00:27 +0200
Subject: [PATCH 264/422] Rename concat test

---
 .../{OperationConcatTest.java => OperatorConcatTest.java}       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename rxjava-core/src/test/java/rx/operators/{OperationConcatTest.java => OperatorConcatTest.java} (99%)

diff --git a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorConcatTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorConcatTest.java
index 2a56cea355..122610bbac 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationConcatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorConcatTest.java
@@ -43,7 +43,7 @@
 import rx.subscriptions.BooleanSubscription;
 import rx.subscriptions.Subscriptions;
 
-public class OperationConcatTest {
+public class OperatorConcatTest {
 
     @Test
     public void testConcat() {

From 817fb3ad57ece39e3e9493f8bc1c0fc22757b297 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 11:50:38 +0200
Subject: [PATCH 265/422] OperatorCombineLatest

---
 rxjava-core/src/main/java/rx/Observable.java  |  50 +-
 .../rx/operators/OperationCombineLatest.java  | 318 -------
 .../rx/operators/OperatorCombineLatest.java   | 242 ++++++
 .../operators/OperationCombineLatestTest.java | 480 -----------
 .../operators/OperatorCombineLatestTest.java  | 779 ++++++++++++++++++
 5 files changed, 1054 insertions(+), 815 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorCombineLatestTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..3420ad8390 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.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationBuffer;
-import rx.operators.OperationCombineLatest;
 import rx.operators.OperationConcat;
 import rx.operators.OperationDebounce;
 import rx.operators.OperationDefaultIfEmpty;
@@ -95,6 +94,7 @@
 import rx.operators.OperatorAsObservable;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorCombineLatest;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
@@ -513,8 +513,8 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, combineFunction));
+    public static final <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2), Functions.fromFunc(combineFunction));
     }
 
     /**
@@ -536,8 +536,8 @@ public final static <T1, T2, R> Observable<R> combineLatest(Observable<? extends
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, combineFunction));
+    public static final <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3), Functions.fromFunc(combineFunction));
     }
 
     /**
@@ -561,9 +561,9 @@ public final static <T1, T2, T3, R> Observable<R> combineLatest(Observable<? ext
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4,
+    public static final <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4,
             Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, combineFunction));
+        return combineLatest(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(combineFunction));
     }
 
     /**
@@ -589,9 +589,9 @@ public final static <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<?
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5,
+    public static final <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5,
             Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, combineFunction));
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(combineFunction));
     }
 
     /**
@@ -619,9 +619,9 @@ public final static <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observab
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
+    public static final <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
             Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, combineFunction));
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(combineFunction));
     }
 
     /**
@@ -651,9 +651,9 @@ public final static <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Obse
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
+    public static final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
             Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, combineFunction));
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(combineFunction));
     }
 
     /**
@@ -685,9 +685,9 @@ public final static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+    public static final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
             Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, combineFunction));
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(combineFunction));
     }
 
     /**
@@ -721,10 +721,26 @@ public final static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLat
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
-    public final static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+    public static final <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
             Observable<? extends T9> o9,
             Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> combineFunction) {
-        return create(OperationCombineLatest.combineLatest(o1, o2, o3, o4, o5, o6, o7, o8, o9, combineFunction));
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8, o9), Functions.fromFunc(combineFunction));
+    }
+    /**
+     * 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.
+     * @param <T> the common base type of source values
+     * @param <R> the result type
+     * @param sources the list of observable sources
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    public static final <T, R> Observable<R> combineLatest(List<? extends Observable<? extends T>> sources, FuncN<? extends R> combineFunction) {
+        return create(new OperatorCombineLatest<T, R>(sources, combineFunction));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
deleted file mode 100644
index 5296b31ff9..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationCombineLatest.java
+++ /dev/null
@@ -1,318 +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.BitSet;
-import java.util.List;
-import java.util.concurrent.locks.Lock;
-import java.util.concurrent.locks.ReentrantLock;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-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.observers.Subscribers;
-import rx.subscriptions.CompositeSubscription;
-
-/**
- * Returns an Observable that combines the emissions of multiple source observables. Once each
- * source Observable has emitted at least one item, combineLatest emits an item whenever any of
- * the source Observables emits an item, by combining the latest emissions from each source
- * Observable with a specified function.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/combineLatest.png">
- */
-public class OperationCombineLatest {
-
-    /**
-     * Combines the two given observables, emitting an event containing an aggregation of the latest values of each of the source observables
-     * each time an event is received from one of the source observables, where the aggregation is defined by the given function.
-     * 
-     * @param w0
-     *            The first source observable.
-     * @param w1
-     *            The second source observable.
-     * @param combineLatestFunction
-     *            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 <T0, T1, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<T1> w1, Func2<? super T0, ? super T1, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1), Functions.fromFunc(combineLatestFunction));
-    }
-
-    /**
-     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2,
-            Func3<? super T0, ? super T1, ? super T2, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1, w2), Functions.fromFunc(combineLatestFunction));
-    }
-
-    /**
-     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3,
-            Func4<? super T0, ? super T1, ? super T2, ? super T3, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1, w2, w3), Functions.fromFunc(combineLatestFunction));
-    }
-
-    /**
-     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, T4, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4,
-            Func5<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1, w2, w3, w4), Functions.fromFunc(combineLatestFunction));
-    }
-
-    /**
-     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, T4, T5, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5,
-            Func6<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1, w2, w3, w4, w5), Functions.fromFunc(combineLatestFunction));
-    }
-
-    /**
-     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, T4, T5, T6, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5, Observable<? extends T6> w6,
-            Func7<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1, w2, w3, w4, w5, w6), Functions.fromFunc(combineLatestFunction));
-    }
-
-    /**
-     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, T4, T5, T6, T7, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5, Observable<? extends T6> w6, Observable<? extends T7> w7,
-            Func8<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1, w2, w3, w4, w5, w6, w7), Functions.fromFunc(combineLatestFunction));
-    }
-
-    /**
-     * @see #combineLatest(Observable w0, Observable w1, Func2 combineLatestFunction)
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, R> OnSubscribeFunc<R> combineLatest(Observable<? extends T0> w0, Observable<? extends T1> w1, Observable<? extends T2> w2, Observable<? extends T3> w3, Observable<? extends T4> w4, Observable<? extends T5> w5, Observable<? extends T6> w6, Observable<? extends T7> w7,
-            Observable<? extends T8> w8,
-            Func9<? super T0, ? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineLatestFunction) {
-        return new CombineLatest<Object, R>(Arrays.asList(w0, w1, w2, w3, w4, w5, w6, w7, w8), Functions.fromFunc(combineLatestFunction));
-    }
-
-    static final class CombineLatest<T, R> implements OnSubscribeFunc<R> {
-        final List<Observable<? extends T>> sources;
-        final FuncN<? extends R> combiner;
-
-        public CombineLatest(Iterable<? extends Observable<? extends T>> sources, FuncN<? extends R> combiner) {
-            this.sources = new ArrayList<Observable<? extends T>>();
-            this.combiner = combiner;
-            for (Observable<? extends T> source : sources) {
-                this.sources.add(source);
-            }
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super R> t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            Collector collector = new Collector(t1, csub, sources.size());
-
-            int index = 0;
-            List<SourceObserver> observers = new ArrayList<SourceObserver>(sources.size() + 1);
-            for (Observable<? extends T> source : sources) {
-                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.
-         */
-        final class Collector {
-            final Observer<? super R> 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<? super R> 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();
-            }
-
-            public void next(int index, T value) {
-                Throwable err = null;
-                lock.lock();
-                try {
-                    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();
-                        unsub = true;
-                    }
-                } finally {
-                    lock.unlock();
-                }
-                if (unsub) {
-                    observer.onError(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();
-                try {
-                    if (!completed.get(index)) {
-                        completed.set(index);
-                        completedCount++;
-                    }
-                    if ((!hasValue.get(index) || completedCount == values.length)
-                            && !isTerminated()) {
-                        terminate();
-                        unsub = true;
-                    }
-                } finally {
-                    lock.unlock();
-                }
-                if (unsub) {
-                    // no need to hold a lock at this point
-                    observer.onCompleted();
-                    cancel.unsubscribe();
-                }
-            }
-        }
-
-        /**
-         * Observes a specific source and communicates with the collector.
-         */
-        final class SourceObserver extends Subscriber<T> {
-            final SafeObservableSubscription self;
-            final Collector collector;
-            final int index;
-            Observable<? extends T> source;
-
-            public SourceObserver(Collector collector,
-                    SafeObservableSubscription self, int index,
-                    Observable<? extends T> source) {
-                this.self = self;
-                this.collector = collector;
-                this.index = index;
-                this.source = source;
-            }
-
-            @Override
-            public void onNext(T args) {
-                collector.next(index, args);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                collector.error(index, e);
-            }
-
-            @Override
-            public void onCompleted() {
-                collector.completed(index);
-                self.unsubscribe();
-            }
-
-            /** Connect to the source. */
-            void connect() {
-                self.wrap(source.unsafeSubscribe(Subscribers.from(this)));
-                source = null;
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java
new file mode 100644
index 0000000000..5492a813a6
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java
@@ -0,0 +1,242 @@
+/**
+ * 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.BitSet;
+import java.util.LinkedList;
+import java.util.List;
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+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.observers.SerializedSubscriber;
+
+/**
+ * Returns an Observable that combines the emissions of multiple source observables. Once each
+ * source Observable has emitted at least one item, combineLatest emits an item whenever any of
+ * the source Observables emits an item, by combining the latest emissions from each source
+ * Observable with a specified function.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/combineLatest.png">
+ * 
+ * @param <T> the common basetype of the source values
+ * @param <R> the result type of the combinator function
+ */
+public final class OperatorCombineLatest<T, R> implements OnSubscribe<R> {
+    final List<? extends Observable<? extends T>> sources;
+    final FuncN<? extends R> combinator;
+
+    public OperatorCombineLatest(List<? extends Observable<? extends T>> sources, FuncN<? extends R> combinator) {
+        this.sources = sources;
+        this.combinator = combinator;
+    }
+
+    @Override
+    public void call(final Subscriber<? super R> child) {
+        if (sources.isEmpty()) {
+            child.onCompleted();
+            return;
+        } else
+        if (sources.size() == 1) {
+            sources.get(0).unsafeSubscribe(new Subscriber<T>(child) {
+                @Override
+                public void onNext(T t) {
+                    child.onNext(combinator.call(t));
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    child.onError(e);
+                }
+
+                @Override
+                public void onCompleted() {
+                    child.onCompleted();
+                }
+            });
+            return;
+        }
+        
+        SerializedSubscriber<R> s = new SerializedSubscriber<R>(child);
+        List<SourceSubscriber> sourceSubscribers = new ArrayList<SourceSubscriber>(sources.size());
+        Collector collector = new Collector(s, sources.size());
+        
+        for (int i = 0; i < sources.size(); i++) {
+            SourceSubscriber sourceSub = new SourceSubscriber(i, collector);
+            child.add(sourceSub);
+            sourceSubscribers.add(sourceSub);
+        }
+        
+        for (int i = 0; i < sources.size(); i++) {
+            if (!child.isUnsubscribed()) {
+                sources.get(i).unsafeSubscribe(sourceSubscribers.get(i));
+            }
+        }        
+    }
+    /** Combines values from each source subscriber. */
+    final class Collector {
+        final Subscriber<R> s;
+        /** Guarded by this. */
+        Object[] collectedValues;
+        /** Guarded by this. */
+        final BitSet haveValues;
+        /** Guarded by this. */
+        int haveValuesCount;
+        /** Guarded by this. */
+        final BitSet completion;
+        /** Guarded by this. */
+        int completionCount;
+        /** Guarded by this. */
+        boolean emitting;
+        /** Guarded by this. */
+        List<Object[]> queue;
+        public Collector(Subscriber<R> s, int size) {
+            this.s = s;
+            int n = size;
+            this.collectedValues = new Object[n];
+            this.haveValues = new BitSet(n);
+            this.completion = new BitSet(n);
+        }
+        void next(int index, T value) {
+            Object[] localValues;
+            List<Object[]> localQueue;
+            
+            synchronized (this) {
+                if (!haveValues.get(index)) {
+                    haveValues.set(index);
+                    haveValuesCount++;
+                }
+                collectedValues[index] = value;
+                if (haveValuesCount != collectedValues.length) {
+                    return;
+                }
+                localValues = collectedValues.clone();
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new LinkedList<Object[]>();
+                    }
+                    queue.add(localValues);
+                    return;
+                }
+                localQueue = queue;
+                queue = null;
+                emitting = true;
+            }
+            boolean once = true;
+            boolean skipFinal = false;
+            /** 
+             * This logic, similar to SerializedSubscriber, ensures that the
+             * emission order is consistent with the order the synchronized above
+             * was won.
+             */
+            try {
+                do {
+                    try {
+                        if (localQueue != null) {
+                            for (Object[] o : localQueue) {
+                                s.onNext(combinator.call(o));
+                            }
+                        }
+                        if (once) {
+                            once = false;
+                            s.onNext(combinator.call(localValues));
+                        }
+                    } catch (Throwable e) {
+                        error(e);
+                        return;
+                    }
+
+                    synchronized (this) {
+                        localQueue = queue;
+                        queue = null;
+                        if (localQueue == null) {
+                            skipFinal = true;
+                            emitting = false;
+                            return;
+                        }
+                    }
+                } while (!s.isUnsubscribed());
+            } finally {
+                if (!skipFinal) {
+                    synchronized (this) {
+                        emitting = false;
+                    }
+                }
+            }
+            
+        }
+        void error(Throwable e) {
+            s.onError(e);
+            s.unsubscribe();
+        }
+        void complete(int index, boolean hadValue) {
+            if (!hadValue) {
+                s.onCompleted();
+                s.unsubscribe();
+                return;
+            }
+            boolean done = false;
+            synchronized (this) {
+                if (!completion.get(index)) {
+                    completion.set(index);
+                    completionCount++;
+                    done = completionCount == collectedValues.length;
+                }
+            }
+            if (done) {
+                s.onCompleted();
+            }
+        }
+    }
+    /** Subscibed to a source. */
+    final class SourceSubscriber extends Subscriber<T> {
+        final int index;
+        final Collector collector;
+        private boolean hasValue;
+        public SourceSubscriber(int index, Collector collector) {
+            this.index = index;
+            this.collector = collector;
+        }
+        @Override
+        public void onNext(T t) {
+            hasValue = true;
+            collector.next(index, t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            collector.error(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            collector.complete(index, hasValue);
+        }
+        
+        
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
deleted file mode 100644
index a6fe434526..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationCombineLatestTest.java
+++ /dev/null
@@ -1,480 +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.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.OperationCombineLatest.combineLatest;
-
-import java.util.Arrays;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-import org.mockito.Matchers;
-
-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;
-
-public class OperationCombineLatestTest {
-
-    @Test
-    public void testCombineLatestWithFunctionThatThrowsAnException() {
-        @SuppressWarnings("unchecked")
-        // mock calls don't do generics
-        Observer<String> w = mock(Observer.class);
-
-        TestObservable w1 = new TestObservable();
-        TestObservable w2 = new TestObservable();
-
-        Observable<String> combined = Observable.create(combineLatest(Observable.create(w1), Observable.create(w2), new Func2<String, String, String>() {
-            @Override
-            public String call(String v1, String v2) {
-                throw new RuntimeException("I don't work.");
-            }
-        }));
-        combined.subscribe(w);
-
-        w1.observer.onNext("first value of w1");
-        w2.observer.onNext("first value of w2");
-
-        verify(w, never()).onNext(anyString());
-        verify(w, never()).onCompleted();
-        verify(w, times(1)).onError(Matchers.<RuntimeException> any());
-    }
-
-    @Test
-    public void testCombineLatestDifferentLengthObservableSequences1() {
-        @SuppressWarnings("unchecked")
-        // mock calls don't do generics
-        Observer<String> w = mock(Observer.class);
-
-        TestObservable w1 = new TestObservable();
-        TestObservable w2 = new TestObservable();
-        TestObservable w3 = new TestObservable();
-
-        Observable<String> combineLatestW = Observable.create(combineLatest(Observable.create(w1), Observable.create(w2), Observable.create(w3), getConcat3StringsCombineLatestFunction()));
-        combineLatestW.subscribe(w);
-
-        /* simulate sending data */
-        // once for w1
-        w1.observer.onNext("1a");
-        w2.observer.onNext("2a");
-        w3.observer.onNext("3a");
-        w1.observer.onCompleted();
-        // twice for w2
-        w2.observer.onNext("2b");
-        w2.observer.onCompleted();
-        // 4 times for w3
-        w3.observer.onNext("3b");
-        w3.observer.onNext("3c");
-        w3.observer.onNext("3d");
-        w3.observer.onCompleted();
-
-        /* we should have been called 4 times on the Observer */
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w).onNext("1a2a3a");
-        inOrder.verify(w).onNext("1a2b3a");
-        inOrder.verify(w).onNext("1a2b3b");
-        inOrder.verify(w).onNext("1a2b3c");
-        inOrder.verify(w).onNext("1a2b3d");
-        inOrder.verify(w, never()).onNext(anyString());
-        inOrder.verify(w, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testCombineLatestDifferentLengthObservableSequences2() {
-        @SuppressWarnings("unchecked")
-        Observer<String> w = mock(Observer.class);
-
-        TestObservable w1 = new TestObservable();
-        TestObservable w2 = new TestObservable();
-        TestObservable w3 = new TestObservable();
-
-        Observable<String> combineLatestW = Observable.create(combineLatest(Observable.create(w1), Observable.create(w2), Observable.create(w3), getConcat3StringsCombineLatestFunction()));
-        combineLatestW.subscribe(w);
-
-        /* simulate sending data */
-        // 4 times for w1
-        w1.observer.onNext("1a");
-        w1.observer.onNext("1b");
-        w1.observer.onNext("1c");
-        w1.observer.onNext("1d");
-        w1.observer.onCompleted();
-        // twice for w2
-        w2.observer.onNext("2a");
-        w2.observer.onNext("2b");
-        w2.observer.onCompleted();
-        // 1 times for w3
-        w3.observer.onNext("3a");
-        w3.observer.onCompleted();
-
-        /* we should have been called 1 time only on the Observer since we only combine the "latest" we don't go back and loop through others once completed */
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w, times(1)).onNext("1d2b3a");
-        inOrder.verify(w, never()).onNext(anyString());
-
-        inOrder.verify(w, times(1)).onCompleted();
-
-    }
-
-    @Test
-    public void testCombineLatestWithInterleavingSequences() {
-        @SuppressWarnings("unchecked")
-        Observer<String> w = mock(Observer.class);
-
-        TestObservable w1 = new TestObservable();
-        TestObservable w2 = new TestObservable();
-        TestObservable w3 = new TestObservable();
-
-        Observable<String> combineLatestW = Observable.create(combineLatest(Observable.create(w1), Observable.create(w2), Observable.create(w3), getConcat3StringsCombineLatestFunction()));
-        combineLatestW.subscribe(w);
-
-        /* simulate sending data */
-        w1.observer.onNext("1a");
-        w2.observer.onNext("2a");
-        w2.observer.onNext("2b");
-        w3.observer.onNext("3a");
-
-        w1.observer.onNext("1b");
-        w2.observer.onNext("2c");
-        w2.observer.onNext("2d");
-        w3.observer.onNext("3b");
-
-        w1.observer.onCompleted();
-        w2.observer.onCompleted();
-        w3.observer.onCompleted();
-
-        /* we should have been called 5 times on the Observer */
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w).onNext("1a2b3a");
-        inOrder.verify(w).onNext("1b2b3a");
-        inOrder.verify(w).onNext("1b2c3a");
-        inOrder.verify(w).onNext("1b2d3a");
-        inOrder.verify(w).onNext("1b2d3b");
-
-        inOrder.verify(w, never()).onNext(anyString());
-        inOrder.verify(w, times(1)).onCompleted();
-    }
-
-    @SuppressWarnings("unchecked")
-    /* mock calls don't do generics */
-    @Test
-    public void testCombineLatest2Types() {
-        Func2<String, Integer, String> combineLatestFunction = getConcatStringIntegerCombineLatestFunction();
-
-        /* define a Observer to receive aggregated events */
-        Observer<String> observer = mock(Observer.class);
-
-        Observable<String> w = Observable.create(combineLatest(Observable.from("one", "two"), Observable.from(2, 3, 4), combineLatestFunction));
-        w.subscribe(observer);
-
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-        verify(observer, times(1)).onNext("two2");
-        verify(observer, times(1)).onNext("two3");
-        verify(observer, times(1)).onNext("two4");
-    }
-
-    @SuppressWarnings("unchecked")
-    /* mock calls don't do generics */
-    @Test
-    public void testCombineLatest3TypesA() {
-        Func3<String, Integer, int[], String> combineLatestFunction = getConcatStringIntegerIntArrayCombineLatestFunction();
-
-        /* define a Observer to receive aggregated events */
-        Observer<String> observer = mock(Observer.class);
-
-        Observable<String> w = Observable.create(combineLatest(Observable.from("one", "two"), Observable.from(2), Observable.from(new int[] { 4, 5, 6 }), combineLatestFunction));
-        w.subscribe(observer);
-
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-        verify(observer, times(1)).onNext("two2[4, 5, 6]");
-    }
-
-    @SuppressWarnings("unchecked")
-    /* mock calls don't do generics */
-    @Test
-    public void testCombineLatest3TypesB() {
-        Func3<String, Integer, int[], String> combineLatestFunction = getConcatStringIntegerIntArrayCombineLatestFunction();
-
-        /* define a Observer to receive aggregated events */
-        Observer<String> observer = mock(Observer.class);
-
-        Observable<String> w = Observable.create(combineLatest(Observable.from("one"), Observable.from(2), Observable.from(new int[] { 4, 5, 6 }, new int[] { 7, 8 }), combineLatestFunction));
-        w.subscribe(observer);
-
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-        verify(observer, times(1)).onNext("one2[4, 5, 6]");
-        verify(observer, times(1)).onNext("one2[7, 8]");
-    }
-
-    private Func3<String, String, String, String> getConcat3StringsCombineLatestFunction() {
-        Func3<String, String, String, String> combineLatestFunction = new Func3<String, String, String, String>() {
-
-            @Override
-            public String call(String a1, String a2, String a3) {
-                if (a1 == null) {
-                    a1 = "";
-                }
-                if (a2 == null) {
-                    a2 = "";
-                }
-                if (a3 == null) {
-                    a3 = "";
-                }
-                return a1 + a2 + a3;
-            }
-
-        };
-        return combineLatestFunction;
-    }
-
-    private FuncN<String> getConcatCombineLatestFunction() {
-        FuncN<String> combineLatestFunction = new FuncN<String>() {
-
-            @Override
-            public String call(Object... args) {
-                String returnValue = "";
-                for (Object o : args) {
-                    if (o != null) {
-                        returnValue += getStringValue(o);
-                    }
-                }
-                System.out.println("returning: " + returnValue);
-                return returnValue;
-            }
-
-        };
-        return combineLatestFunction;
-    }
-
-    private Func2<String, Integer, String> getConcatStringIntegerCombineLatestFunction() {
-        Func2<String, Integer, String> combineLatestFunction = new Func2<String, Integer, String>() {
-
-            @Override
-            public String call(String s, Integer i) {
-                return getStringValue(s) + getStringValue(i);
-            }
-
-        };
-        return combineLatestFunction;
-    }
-
-    private Func3<String, Integer, int[], String> getConcatStringIntegerIntArrayCombineLatestFunction() {
-        Func3<String, Integer, int[], String> combineLatestFunction = new Func3<String, Integer, int[], String>() {
-
-            @Override
-            public String call(String s, Integer i, int[] iArray) {
-                return getStringValue(s) + getStringValue(i) + getStringValue(iArray);
-            }
-
-        };
-        return combineLatestFunction;
-    }
-
-    private static String getStringValue(Object o) {
-        if (o == null) {
-            return "";
-        } else {
-            if (o instanceof int[]) {
-                return Arrays.toString((int[]) o);
-            } else {
-                return String.valueOf(o);
-            }
-        }
-    }
-
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
-
-        Observer<? super String> observer;
-
-        @Override
-        public Subscription onSubscribe(Observer<? super String> observer) {
-            // just store the variable where it can be accessed so we can manually trigger it
-            this.observer = observer;
-            return Subscriptions.empty();
-        }
-
-    }
-
-    Func2<Integer, Integer, Integer> or = new Func2<Integer, Integer, Integer>() {
-        @Override
-        public Integer call(Integer t1, Integer t2) {
-            return t1 | t2;
-        }
-    };
-
-    @Test
-    public void combineSimple() {
-        PublishSubject<Integer> a = PublishSubject.create();
-        PublishSubject<Integer> b = PublishSubject.create();
-
-        Observable<Integer> source = Observable.combineLatest(a, b, or);
-
-        Observer<Object> 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<Integer> a = PublishSubject.create();
-        PublishSubject<Integer> b = PublishSubject.create();
-
-        Observable<Integer> source = Observable.combineLatest(a, b, or);
-
-        Observer<Object> observer1 = mock(Observer.class);
-        Observer<Object> 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<Integer> a = PublishSubject.create();
-        PublishSubject<Integer> b = PublishSubject.create();
-
-        Observable<Integer> source = Observable.combineLatest(a, b, or);
-
-        Observer<Object> 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<Integer> a = PublishSubject.create();
-        PublishSubject<Integer> b = PublishSubject.create();
-
-        Observable<Integer> source = Observable.combineLatest(a, b, or);
-
-        Observer<Object> 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/OperatorCombineLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperatorCombineLatestTest.java
new file mode 100644
index 0000000000..05995ca1c9
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorCombineLatestTest.java
@@ -0,0 +1,779 @@
+/**
+ * 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.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 java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+import org.mockito.Matchers;
+
+import rx.Observable;
+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.subjects.PublishSubject;
+import rx.schedulers.Schedulers;
+
+public class OperatorCombineLatestTest {
+
+    @Test
+    public void testCombineLatestWithFunctionThatThrowsAnException() {
+        @SuppressWarnings("unchecked")
+        // mock calls don't do generics
+        Observer<String> w = mock(Observer.class);
+
+        PublishSubject<String> w1 = PublishSubject.create();
+        PublishSubject<String> w2 = PublishSubject.create();
+
+        Observable<String> combined = Observable.combineLatest(w1, w2, new Func2<String, String, String>() {
+            @Override
+            public String call(String v1, String v2) {
+                throw new RuntimeException("I don't work.");
+            }
+        });
+        combined.subscribe(w);
+
+        w1.onNext("first value of w1");
+        w2.onNext("first value of w2");
+
+        verify(w, never()).onNext(anyString());
+        verify(w, never()).onCompleted();
+        verify(w, times(1)).onError(Matchers.<RuntimeException> any());
+    }
+
+    @Test
+    public void testCombineLatestDifferentLengthObservableSequences1() {
+        @SuppressWarnings("unchecked")
+        // mock calls don't do generics
+        Observer<String> w = mock(Observer.class);
+
+        PublishSubject<String> w1 = PublishSubject.create();
+        PublishSubject<String> w2 = PublishSubject.create();
+        PublishSubject<String> w3 = PublishSubject.create();
+
+        Observable<String> combineLatestW = Observable.combineLatest(w1, w2, w3, getConcat3StringsCombineLatestFunction());
+        combineLatestW.subscribe(w);
+
+        /* simulate sending data */
+        // once for w1
+        w1.onNext("1a");
+        w2.onNext("2a");
+        w3.onNext("3a");
+        w1.onCompleted();
+        // twice for w2
+        w2.onNext("2b");
+        w2.onCompleted();
+        // 4 times for w3
+        w3.onNext("3b");
+        w3.onNext("3c");
+        w3.onNext("3d");
+        w3.onCompleted();
+
+        /* we should have been called 4 times on the Observer */
+        InOrder inOrder = inOrder(w);
+        inOrder.verify(w).onNext("1a2a3a");
+        inOrder.verify(w).onNext("1a2b3a");
+        inOrder.verify(w).onNext("1a2b3b");
+        inOrder.verify(w).onNext("1a2b3c");
+        inOrder.verify(w).onNext("1a2b3d");
+        inOrder.verify(w, never()).onNext(anyString());
+        inOrder.verify(w, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testCombineLatestDifferentLengthObservableSequences2() {
+        @SuppressWarnings("unchecked")
+        Observer<String> w = mock(Observer.class);
+
+        PublishSubject<String> w1 = PublishSubject.create();
+        PublishSubject<String> w2 = PublishSubject.create();
+        PublishSubject<String> w3 = PublishSubject.create();
+
+        Observable<String> combineLatestW = Observable.combineLatest(w1, w2, w3, getConcat3StringsCombineLatestFunction());
+        combineLatestW.subscribe(w);
+
+        /* simulate sending data */
+        // 4 times for w1
+        w1.onNext("1a");
+        w1.onNext("1b");
+        w1.onNext("1c");
+        w1.onNext("1d");
+        w1.onCompleted();
+        // twice for w2
+        w2.onNext("2a");
+        w2.onNext("2b");
+        w2.onCompleted();
+        // 1 times for w3
+        w3.onNext("3a");
+        w3.onCompleted();
+
+        /* we should have been called 1 time only on the Observer since we only combine the "latest" we don't go back and loop through others once completed */
+        InOrder inOrder = inOrder(w);
+        inOrder.verify(w, times(1)).onNext("1d2b3a");
+        inOrder.verify(w, never()).onNext(anyString());
+
+        inOrder.verify(w, times(1)).onCompleted();
+
+    }
+
+    @Test
+    public void testCombineLatestWithInterleavingSequences() {
+        @SuppressWarnings("unchecked")
+        Observer<String> w = mock(Observer.class);
+
+        PublishSubject<String> w1 = PublishSubject.create();
+        PublishSubject<String> w2 = PublishSubject.create();
+        PublishSubject<String> w3 = PublishSubject.create();
+
+        Observable<String> combineLatestW = Observable.combineLatest(w1, w2, w3, getConcat3StringsCombineLatestFunction());
+        combineLatestW.subscribe(w);
+
+        /* simulate sending data */
+        w1.onNext("1a");
+        w2.onNext("2a");
+        w2.onNext("2b");
+        w3.onNext("3a");
+
+        w1.onNext("1b");
+        w2.onNext("2c");
+        w2.onNext("2d");
+        w3.onNext("3b");
+
+        w1.onCompleted();
+        w2.onCompleted();
+        w3.onCompleted();
+
+        /* we should have been called 5 times on the Observer */
+        InOrder inOrder = inOrder(w);
+        inOrder.verify(w).onNext("1a2b3a");
+        inOrder.verify(w).onNext("1b2b3a");
+        inOrder.verify(w).onNext("1b2c3a");
+        inOrder.verify(w).onNext("1b2d3a");
+        inOrder.verify(w).onNext("1b2d3b");
+
+        inOrder.verify(w, never()).onNext(anyString());
+        inOrder.verify(w, times(1)).onCompleted();
+    }
+
+    @SuppressWarnings("unchecked")
+    /* mock calls don't do generics */
+    @Test
+    public void testCombineLatest2Types() {
+        Func2<String, Integer, String> combineLatestFunction = getConcatStringIntegerCombineLatestFunction();
+
+        /* define a Observer to receive aggregated events */
+        Observer<String> observer = mock(Observer.class);
+
+        Observable<String> w = Observable.combineLatest(Observable.from("one", "two"), Observable.from(2, 3, 4), combineLatestFunction);
+        w.subscribe(observer);
+
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        verify(observer, times(1)).onNext("two2");
+        verify(observer, times(1)).onNext("two3");
+        verify(observer, times(1)).onNext("two4");
+    }
+
+    @SuppressWarnings("unchecked")
+    /* mock calls don't do generics */
+    @Test
+    public void testCombineLatest3TypesA() {
+        Func3<String, Integer, int[], String> combineLatestFunction = getConcatStringIntegerIntArrayCombineLatestFunction();
+
+        /* define a Observer to receive aggregated events */
+        Observer<String> observer = mock(Observer.class);
+
+        Observable<String> w = Observable.combineLatest(Observable.from("one", "two"), Observable.from(2), Observable.from(new int[] { 4, 5, 6 }), combineLatestFunction);
+        w.subscribe(observer);
+
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        verify(observer, times(1)).onNext("two2[4, 5, 6]");
+    }
+
+    @SuppressWarnings("unchecked")
+    /* mock calls don't do generics */
+    @Test
+    public void testCombineLatest3TypesB() {
+        Func3<String, Integer, int[], String> combineLatestFunction = getConcatStringIntegerIntArrayCombineLatestFunction();
+
+        /* define a Observer to receive aggregated events */
+        Observer<String> observer = mock(Observer.class);
+
+        Observable<String> w = Observable.combineLatest(Observable.from("one"), Observable.from(2), Observable.from(new int[] { 4, 5, 6 }, new int[] { 7, 8 }), combineLatestFunction);
+        w.subscribe(observer);
+
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+        verify(observer, times(1)).onNext("one2[4, 5, 6]");
+        verify(observer, times(1)).onNext("one2[7, 8]");
+    }
+
+    private Func3<String, String, String, String> getConcat3StringsCombineLatestFunction() {
+        Func3<String, String, String, String> combineLatestFunction = new Func3<String, String, String, String>() {
+
+            @Override
+            public String call(String a1, String a2, String a3) {
+                if (a1 == null) {
+                    a1 = "";
+                }
+                if (a2 == null) {
+                    a2 = "";
+                }
+                if (a3 == null) {
+                    a3 = "";
+                }
+                return a1 + a2 + a3;
+            }
+
+        };
+        return combineLatestFunction;
+    }
+
+    private FuncN<String> getConcatCombineLatestFunction() {
+        FuncN<String> combineLatestFunction = new FuncN<String>() {
+
+            @Override
+            public String call(Object... args) {
+                String returnValue = "";
+                for (Object o : args) {
+                    if (o != null) {
+                        returnValue += getStringValue(o);
+                    }
+                }
+                System.out.println("returning: " + returnValue);
+                return returnValue;
+            }
+
+        };
+        return combineLatestFunction;
+    }
+
+    private Func2<String, Integer, String> getConcatStringIntegerCombineLatestFunction() {
+        Func2<String, Integer, String> combineLatestFunction = new Func2<String, Integer, String>() {
+
+            @Override
+            public String call(String s, Integer i) {
+                return getStringValue(s) + getStringValue(i);
+            }
+
+        };
+        return combineLatestFunction;
+    }
+
+    private Func3<String, Integer, int[], String> getConcatStringIntegerIntArrayCombineLatestFunction() {
+        Func3<String, Integer, int[], String> combineLatestFunction = new Func3<String, Integer, int[], String>() {
+
+            @Override
+            public String call(String s, Integer i, int[] iArray) {
+                return getStringValue(s) + getStringValue(i) + getStringValue(iArray);
+            }
+
+        };
+        return combineLatestFunction;
+    }
+
+    private static String getStringValue(Object o) {
+        if (o == null) {
+            return "";
+        } else {
+            if (o instanceof int[]) {
+                return Arrays.toString((int[]) o);
+            } else {
+                return String.valueOf(o);
+            }
+        }
+    }
+
+    Func2<Integer, Integer, Integer> or = new Func2<Integer, Integer, Integer>() {
+        @Override
+        public Integer call(Integer t1, Integer t2) {
+            return t1 | t2;
+        }
+    };
+
+    @Test
+    public void combineSimple() {
+        PublishSubject<Integer> a = PublishSubject.create();
+        PublishSubject<Integer> b = PublishSubject.create();
+
+        Observable<Integer> source = Observable.combineLatest(a, b, or);
+
+        Observer<Object> observer = mock(Observer.class);
+        InOrder inOrder = inOrder(observer);
+
+        source.subscribe(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<Integer> a = PublishSubject.create();
+        PublishSubject<Integer> b = PublishSubject.create();
+
+        Observable<Integer> source = Observable.combineLatest(a, b, or);
+
+        Observer<Object> observer1 = mock(Observer.class);
+        Observer<Object> observer2 = mock(Observer.class);
+
+        InOrder inOrder1 = inOrder(observer1);
+        InOrder inOrder2 = inOrder(observer2);
+
+        source.subscribe(observer1);
+        source.subscribe(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<Integer> a = PublishSubject.create();
+        PublishSubject<Integer> b = PublishSubject.create();
+
+        Observable<Integer> source = Observable.combineLatest(a, b, or);
+
+        Observer<Object> observer = mock(Observer.class);
+        InOrder inOrder = inOrder(observer);
+
+        source.subscribe(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<Integer> a = PublishSubject.create();
+        PublishSubject<Integer> b = PublishSubject.create();
+
+        Observable<Integer> source = Observable.combineLatest(a, b, or);
+
+        Observer<Object> observer = mock(Observer.class);
+        InOrder inOrder = inOrder(observer);
+
+        source.subscribe(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));
+    }
+    
+    public void test0Sources() {
+        
+    }
+    @Test
+    public void test1ToNSources() {
+        int n = 30;
+        FuncN<List<Object>> func = new FuncN<List<Object>>() {
+
+            @Override
+            public List<Object> call(Object... args) {
+                return Arrays.asList(args);
+            }
+        };
+        for (int i = 1; i <= n; i++) {
+            System.out.println("test1ToNSources: " + i + " sources");
+            List<Observable<Integer>> sources = new ArrayList<Observable<Integer>>();
+            List<Object> values = new ArrayList<Object>();
+            for (int j = 0; j < i; j++) {
+                sources.add(Observable.just(j));
+                values.add(j);
+            }
+            
+            Observable<List<Object>> result = Observable.combineLatest(sources, func);
+            
+            Observer<List<Object>> o = mock(Observer.class);
+            
+            result.subscribe(o);
+            
+            verify(o).onNext(values);
+            verify(o).onCompleted();
+            verify(o, never()).onError(any(Throwable.class));
+        }
+    }
+    @Test(timeout = 5000)
+    public void test1ToNSourcesScheduled() throws InterruptedException {
+        int n = 10;
+        FuncN<List<Object>> func = new FuncN<List<Object>>() {
+
+            @Override
+            public List<Object> call(Object... args) {
+                return Arrays.asList(args);
+            }
+        };
+        for (int i = 1; i <= n; i++) {
+            System.out.println("test1ToNSourcesScheduled: " + i + " sources");
+            List<Observable<Integer>> sources = new ArrayList<Observable<Integer>>();
+            List<Object> values = new ArrayList<Object>();
+            for (int j = 0; j < i; j++) {
+                sources.add(Observable.just(j, Schedulers.io()));
+                values.add(j);
+            }
+            
+            Observable<List<Object>> result = Observable.combineLatest(sources, func);
+            
+            final Observer<List<Object>> o = mock(Observer.class);
+            
+            final CountDownLatch cdl = new CountDownLatch(1);
+            
+            Subscriber<List<Object>> s = new Subscriber<List<Object>>() {
+
+                @Override
+                public void onNext(List<Object> t) {
+                    o.onNext(t);
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    o.onError(e);
+                    cdl.countDown();
+                }
+
+                @Override
+                public void onCompleted() {
+                    o.onCompleted();
+                    cdl.countDown();
+                }
+            };
+            
+            result.subscribe(s);
+            
+            cdl.await();
+            
+            verify(o).onNext(values);
+            verify(o).onCompleted();
+            verify(o, never()).onError(any(Throwable.class));
+        }
+    }
+    @Test
+    public void test2SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, new Func2<Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2) {
+                return Arrays.asList(t1, t2);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void test3SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        Observable<Integer> s3 = Observable.just(3);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, 
+                new Func3<Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2, Integer t3) {
+                return Arrays.asList(t1, t2, t3);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2, 3));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void test4SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        Observable<Integer> s3 = Observable.just(3);
+        Observable<Integer> s4 = Observable.just(4);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, 
+                new Func4<Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4) {
+                return Arrays.asList(t1, t2, t3, t4);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2, 3, 4));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void test5SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        Observable<Integer> s3 = Observable.just(3);
+        Observable<Integer> s4 = Observable.just(4);
+        Observable<Integer> s5 = Observable.just(5);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, 
+                new Func5<Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) {
+                return Arrays.asList(t1, t2, t3, t4, t5);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void test6SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        Observable<Integer> s3 = Observable.just(3);
+        Observable<Integer> s4 = Observable.just(4);
+        Observable<Integer> s5 = Observable.just(5);
+        Observable<Integer> s6 = Observable.just(6);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6,
+                new Func6<Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6) {
+                return Arrays.asList(t1, t2, t3, t4, t5, t6);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void test7SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        Observable<Integer> s3 = Observable.just(3);
+        Observable<Integer> s4 = Observable.just(4);
+        Observable<Integer> s5 = Observable.just(5);
+        Observable<Integer> s6 = Observable.just(6);
+        Observable<Integer> s7 = Observable.just(7);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6, s7,
+                new Func7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7) {
+                return Arrays.asList(t1, t2, t3, t4, t5, t6, t7);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void test8SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        Observable<Integer> s3 = Observable.just(3);
+        Observable<Integer> s4 = Observable.just(4);
+        Observable<Integer> s5 = Observable.just(5);
+        Observable<Integer> s6 = Observable.just(6);
+        Observable<Integer> s7 = Observable.just(7);
+        Observable<Integer> s8 = Observable.just(8);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8,
+                new Func8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8) {
+                return Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void test9SourcesOverload() {
+        Observable<Integer> s1 = Observable.just(1);
+        Observable<Integer> s2 = Observable.just(2);
+        Observable<Integer> s3 = Observable.just(3);
+        Observable<Integer> s4 = Observable.just(4);
+        Observable<Integer> s5 = Observable.just(5);
+        Observable<Integer> s6 = Observable.just(6);
+        Observable<Integer> s7 = Observable.just(7);
+        Observable<Integer> s8 = Observable.just(8);
+        Observable<Integer> s9 = Observable.just(9);
+        
+        Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8, s9,
+                new Func9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
+            @Override
+            public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8, Integer t9) {
+                return Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+            }
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9));
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testZeroSources() {
+        Observable<Object> result = Observable.combineLatest(Arrays.<Observable<Object>>asList(), new FuncN<Object>() {
+
+            @Override
+            public Object call(Object... args) {
+                return args;
+            }
+            
+        });
+        
+        Observer<Object> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onCompleted();
+        verify(o, never()).onNext(any());
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+}

From e404661b8ed1daee916dec0d451b2abd4cec7fe5 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 12:56:47 +0200
Subject: [PATCH 266/422] OperatorDefaultIfEmpty

---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 .../rx/operators/OperationDefaultIfEmpty.java | 94 -------------------
 .../rx/operators/OperatorDefaultIfEmpty.java  | 64 +++++++++++++
 .../OperationDefaultIfEmptyTest.java          | 63 -------------
 .../operators/OperatorDefaultIfEmptyTest.java | 83 ++++++++++++++++
 5 files changed, 149 insertions(+), 159 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDefaultIfEmpty.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..0a27de8b7a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -52,7 +52,6 @@
 import rx.operators.OperationCombineLatest;
 import rx.operators.OperationConcat;
 import rx.operators.OperationDebounce;
-import rx.operators.OperationDefaultIfEmpty;
 import rx.operators.OperationDefer;
 import rx.operators.OperationDelay;
 import rx.operators.OperationDematerialize;
@@ -95,6 +94,7 @@
 import rx.operators.OperatorAsObservable;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorDefaultIfEmpty;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
@@ -3450,7 +3450,7 @@ public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler sched
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229624.aspx">MSDN: Observable.DefaultIfEmpty</a>
      */
     public final Observable<T> defaultIfEmpty(T defaultValue) {
-        return create(OperationDefaultIfEmpty.defaultIfEmpty(this, defaultValue));
+        return lift(new OperatorDefaultIfEmpty<T>(defaultValue));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java b/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
deleted file mode 100644
index 6f08f831f2..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationDefaultIfEmpty.java
+++ /dev/null
@@ -1,94 +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.Subscriber;
-import rx.Subscription;
-
-/**
- * Returns the elements of the specified sequence or the specified default value
- * in a singleton sequence if the sequence is empty.
- */
-public class OperationDefaultIfEmpty {
-
-    /**
-     * Returns the elements of the specified sequence or the specified default
-     * value in a singleton sequence if the sequence is empty.
-     * 
-     * @param source
-     *            The sequence to return the specified value for if it is empty.
-     * @param defaultValue
-     *            The value to return if the sequence is empty.
-     * @return An observable sequence that contains the specified default value
-     *         if the source is empty; otherwise, the elements of the source
-     *         itself.
-     */
-    public static <T> OnSubscribeFunc<T> defaultIfEmpty(
-            Observable<? extends T> source, T defaultValue) {
-        return new DefaultIfEmpty<T>(source, defaultValue);
-    }
-
-    private static class DefaultIfEmpty<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<? extends T> source;
-        private final T defaultValue;
-
-        private DefaultIfEmpty(Observable<? extends T> source, T defaultValue) {
-            this.source = source;
-            this.defaultValue = defaultValue;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-            return subscription.wrap(source.unsafeSubscribe(new Subscriber<T>() {
-
-                private volatile boolean hasEmitted = false;
-
-                @Override
-                public void onNext(T value) {
-                    try {
-                        hasEmitted = true;
-                        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();
-                    }
-                }
-
-                @Override
-                public void onError(Throwable ex) {
-                    observer.onError(ex);
-                }
-
-                @Override
-                public void onCompleted() {
-                    if (hasEmitted) {
-                        observer.onCompleted();
-                    } else {
-                        observer.onNext(defaultValue);
-                        observer.onCompleted();
-                    }
-                }
-            }));
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDefaultIfEmpty.java b/rxjava-core/src/main/java/rx/operators/OperatorDefaultIfEmpty.java
new file mode 100644
index 0000000000..4bb5fd1d0b
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDefaultIfEmpty.java
@@ -0,0 +1,64 @@
+/**
+ * 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;
+
+/**
+ * Returns the elements of the specified sequence or the specified default value
+ * in a singleton sequence if the sequence is empty.
+ * @param <T> the value type
+ */
+public class OperatorDefaultIfEmpty<T> implements Operator<T, T> {
+    final T defaultValue;
+
+    public OperatorDefaultIfEmpty(T defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new Subscriber<T>(child) {
+            boolean hasValue;
+            @Override
+            public void onNext(T t) {
+                hasValue = true;
+                child.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!hasValue) {
+                    try {
+                        child.onNext(defaultValue);
+                    } catch (Throwable e) {
+                        child.onError(e);
+                        return;
+                    }
+                }
+                child.onCompleted();
+            }
+            
+        };
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java b/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
deleted file mode 100644
index ecc7174d65..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationDefaultIfEmptyTest.java
+++ /dev/null
@@ -1,63 +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.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static rx.operators.OperationDefaultIfEmpty.defaultIfEmpty;
-
-import org.junit.Test;
-
-import rx.Observable;
-import rx.Observer;
-
-public class OperationDefaultIfEmptyTest {
-
-    @Test
-    public void testDefaultIfEmpty() {
-        Observable<Integer> source = Observable.from(1, 2, 3);
-        Observable<Integer> observable = Observable.create(defaultIfEmpty(
-                source, 10));
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, never()).onNext(10);
-        verify(observer, times(1)).onNext(1);
-        verify(observer, times(1)).onNext(2);
-        verify(observer, times(1)).onNext(3);
-        verify(observer, never()).onError(
-                org.mockito.Matchers.any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testDefaultIfEmptyWithEmpty() {
-        Observable<Integer> source = Observable.empty();
-        Observable<Integer> observable = Observable.create(defaultIfEmpty(
-                source, 10));
-
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = mock(Observer.class);
-        observable.subscribe(observer);
-        verify(observer, times(1)).onNext(10);
-        verify(observer, never()).onError(
-                org.mockito.Matchers.any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java
new file mode 100644
index 0000000000..321f6e1d28
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java
@@ -0,0 +1,83 @@
+/**
+ * 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;
+import rx.Subscriber;
+
+public class OperatorDefaultIfEmptyTest {
+
+    @Test
+    public void testDefaultIfEmpty() {
+        Observable<Integer> source = Observable.from(1, 2, 3);
+        Observable<Integer> observable = source.defaultIfEmpty(10);
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = mock(Observer.class);
+        observable.subscribe(observer);
+        verify(observer, never()).onNext(10);
+        verify(observer).onNext(1);
+        verify(observer).onNext(2);
+        verify(observer).onNext(3);
+        verify(observer).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+    }
+
+    @Test
+    public void testDefaultIfEmptyWithEmpty() {
+        Observable<Integer> source = Observable.empty();
+        Observable<Integer> observable = source.defaultIfEmpty(10);
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = mock(Observer.class);
+        observable.subscribe(observer);
+        
+        verify(observer).onNext(10);
+        verify(observer).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testEmptyButClientThrows() {
+        final Observer<Integer> o = mock(Observer.class);
+        
+        Observable.<Integer>empty().defaultIfEmpty(1).subscribe(new Subscriber<Integer>() {
+            @Override
+            public void onNext(Integer t) {
+                throw new OperationReduceTest.CustomException();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+        });
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any(Integer.class));
+        verify(o, never()).onCompleted();
+    }
+}

From a6b39902b83b545078be4db08afd067927605a65 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 13:12:18 +0200
Subject: [PATCH 267/422] OperatorDefer

---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +--
 ...OperationDefer.java => OperatorDefer.java} | 32 +++++++++++--------
 ...nDeferTest.java => OperatorDeferTest.java} | 27 ++++++++++++----
 3 files changed, 40 insertions(+), 23 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationDefer.java => OperatorDefer.java} (65%)
 rename rxjava-core/src/test/java/rx/operators/{OperationDeferTest.java => OperatorDeferTest.java} (75%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..03ca49c5c9 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -53,7 +53,6 @@
 import rx.operators.OperationConcat;
 import rx.operators.OperationDebounce;
 import rx.operators.OperationDefaultIfEmpty;
-import rx.operators.OperationDefer;
 import rx.operators.OperationDelay;
 import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
@@ -95,6 +94,7 @@
 import rx.operators.OperatorAsObservable;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorDefer;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
@@ -988,7 +988,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-defer">RxJava Wiki: defer()</a>
      */
     public final static <T> Observable<T> defer(Func0<? extends Observable<? extends T>> observableFactory) {
-        return create(OperationDefer.defer(observableFactory));
+        return create(new OperatorDefer<T>(observableFactory));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDefer.java b/rxjava-core/src/main/java/rx/operators/OperatorDefer.java
similarity index 65%
rename from rxjava-core/src/main/java/rx/operators/OperationDefer.java
rename to rxjava-core/src/main/java/rx/operators/OperatorDefer.java
index 734f6bbf19..a18d350c4e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationDefer.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDefer.java
@@ -16,11 +16,9 @@
 package rx.operators;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
 import rx.functions.Func0;
-import rx.observers.Subscribers;
 
 /**
  * Do not create the Observable until an Observer subscribes; create a fresh Observable on each
@@ -32,17 +30,23 @@
  * return an Observable that will call this function to generate its Observable sequence afresh
  * each time a new Observer subscribes.
  */
-public final class OperationDefer {
+public final class OperatorDefer<T> implements OnSubscribe<T> {
+    final Func0<? extends Observable<? extends T>> observableFactory;
 
-    public static <T> OnSubscribeFunc<T> defer(final Func0<? extends Observable<? extends T>> observableFactory) {
-
-        return new OnSubscribeFunc<T>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                Observable<? extends T> obs = observableFactory.call();
-                return obs.unsafeSubscribe(Subscribers.from(observer));
-            }
-        };
+    public OperatorDefer(Func0<? extends Observable<? extends T>> observableFactory) {
+        this.observableFactory = observableFactory;
+    }
 
+    @Override
+    public void call(Subscriber<? super T> s) {
+        Observable<? extends T> o;
+        try {
+            o = observableFactory.call();
+        } catch (Throwable t) {
+            s.onError(t);
+            return;
+        }
+        o.unsafeSubscribe(s);
     }
+    
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDeferTest.java
similarity index 75%
rename from rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorDeferTest.java
index d6e0f5cef0..710b75f794 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDeferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDeferTest.java
@@ -15,11 +15,7 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 
 import org.junit.Test;
 
@@ -27,10 +23,10 @@
 import rx.Observer;
 import rx.functions.Func0;
 
-public class OperationDeferTest {
+@SuppressWarnings("unchecked")
+public class OperatorDeferTest {
 
     @Test
-    @SuppressWarnings("unchecked")
     public void testDefer() throws Throwable {
 
         Func0<Observable<String>> factory = mock(Func0.class);
@@ -64,4 +60,21 @@ public void testDefer() throws Throwable {
         verify(secondObserver, times(1)).onCompleted();
 
     }
+    
+    @Test
+    public void testDeferFunctionThrows() {
+        Func0<Observable<String>> factory = mock(Func0.class);
+        
+        when(factory.call()).thenThrow(new OperationReduceTest.CustomException());
+        
+        Observable<String> result = Observable.defer(factory);
+        
+        Observer<String> o = mock(Observer.class);
+        
+        result.subscribe(o);
+        
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onNext(any(String.class));
+        verify(o, never()).onCompleted();
+    }
 }

From 08085ac4ebb4a2e5bb65abc016677e47d092b9b6 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 15:15:06 +0200
Subject: [PATCH 268/422] OperatorDematerialize

---
 rxjava-core/src/main/java/rx/Observable.java  |  6 +-
 .../rx/operators/OperationDematerialize.java  | 86 -------------------
 .../rx/operators/OperatorDematerialize.java   | 76 ++++++++++++++++
 ...st.java => OperatorDematerializeTest.java} | 37 +++++++-
 4 files changed, 112 insertions(+), 93 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDematerialize.java
 rename rxjava-core/src/test/java/rx/operators/{OperationDematerializeTest.java => OperatorDematerializeTest.java} (74%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..22252577eb 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -55,7 +55,6 @@
 import rx.operators.OperationDefaultIfEmpty;
 import rx.operators.OperationDefer;
 import rx.operators.OperationDelay;
-import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
 import rx.operators.OperationFinally;
@@ -95,6 +94,7 @@
 import rx.operators.OperatorAsObservable;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorDematerialize;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
@@ -3590,9 +3590,9 @@ public final Observable<T> delaySubscription(long delay, TimeUnit unit, Schedule
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dematerialize">RxJava Wiki: dematerialize()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229047.aspx">MSDN: Observable.dematerialize</a>
      */
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"unchecked", "rawtypes"})
     public final <T2> Observable<T2> dematerialize() {
-        return create(OperationDematerialize.dematerialize((Observable<? extends Notification<? extends T2>>) this));
+        return lift(new OperatorDematerialize());
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java b/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
deleted file mode 100644
index 026bbc891d..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationDematerialize.java
+++ /dev/null
@@ -1,86 +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.Notification;
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-
-/**
- * Reverses the effect of {@link OperatorMaterialize} by transforming the Notification objects
- * emitted by a source Observable into the items or notifications they represent.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/dematerialize.png">
- * <p>
- * See <a href="http://msdn.microsoft.com/en-us/library/hh229047(v=vs.103).aspx">here</a> for the
- * Microsoft Rx equivalent.
- */
-public final class OperationDematerialize {
-
-    /**
-     * Dematerializes the explicit notification values of an observable sequence as implicit notifications.
-     * 
-     * @param sequence
-     *            An observable sequence containing explicit notification values which have to be turned into implicit notifications.
-     * @return An observable sequence exhibiting the behavior corresponding to the source sequence's notification values.
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229047(v=vs.103).aspx">Observable.Dematerialize(TSource) Method </a>
-     */
-    public static <T> OnSubscribeFunc<T> dematerialize(final Observable<? extends Notification<? extends T>> sequence) {
-        return new DematerializeObservable<T>(sequence);
-    }
-
-    private static class DematerializeObservable<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<? extends Notification<? extends T>> sequence;
-
-        public DematerializeObservable(Observable<? extends Notification<? extends T>> sequence) {
-            this.sequence = sequence;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            return sequence.unsafeSubscribe(new Subscriber<Notification<? extends T>>() {
-                @Override
-                public void onCompleted() {
-                    observer.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    observer.onError(e);
-                }
-
-                @Override
-                public void onNext(Notification<? extends T> value) {
-                    switch (value.getKind()) {
-                    case OnNext:
-                        observer.onNext(value.getValue());
-                        break;
-                    case OnError:
-                        observer.onError(value.getThrowable());
-                        break;
-                    case OnCompleted:
-                        observer.onCompleted();
-                        break;
-                    }
-                }
-            });
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDematerialize.java b/rxjava-core/src/main/java/rx/operators/OperatorDematerialize.java
new file mode 100644
index 0000000000..043837ac42
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDematerialize.java
@@ -0,0 +1,76 @@
+/**
+ * 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.Observable.Operator;
+import rx.Subscriber;
+
+/**
+ * Reverses the effect of {@link OperatorMaterialize} by transforming the Notification objects
+ * emitted by a source Observable into the items or notifications they represent.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/dematerialize.png">
+ * <p>
+ * See <a href="http://msdn.microsoft.com/en-us/library/hh229047(v=vs.103).aspx">here</a> for the
+ * Microsoft Rx equivalent.
+ * 
+ * @param <T> the wrapped value type
+ */
+public final class OperatorDematerialize<T> implements Operator<T, Notification<T>> {
+
+    @Override
+    public Subscriber<? super Notification<T>> call(final Subscriber<? super T> child) {
+        return new Subscriber<Notification<T>>(child) {
+            /** Do not send two onCompleted events. */
+            boolean terminated;
+            @Override
+            public void onNext(Notification<T> t) {
+                switch (t.getKind()) {
+                case OnNext:
+                    if (!terminated) {
+                        child.onNext(t.getValue());
+                    }
+                    break;
+                case OnError:
+                    onError(t.getThrowable());
+                    break;
+                case OnCompleted:
+                    onCompleted();
+                    break;
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                if (!terminated) {
+                    terminated = true;
+                    child.onError(e);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!terminated) {
+                    terminated = true;
+                    child.onCompleted();
+                }
+            }
+            
+        };
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDematerializeTest.java
similarity index 74%
rename from rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorDematerializeTest.java
index c3f9954a48..3280ed3fd0 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDematerializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDematerializeTest.java
@@ -20,16 +20,16 @@
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationDematerialize.dematerialize;
 
 import org.junit.Test;
 
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
+import rx.observers.Subscribers;
 import rx.observers.TestSubscriber;
 
-public class OperationDematerializeTest {
+public class OperatorDematerializeTest {
 
     @Test
     @SuppressWarnings("unchecked")
@@ -51,7 +51,7 @@ public void testDematerialize1() {
     public void testDematerialize2() {
         Throwable exception = new Throwable("test");
         Observable<Integer> observable = Observable.error(exception);
-        Observable<Integer> dematerialize = Observable.create(dematerialize(observable.materialize()));
+        Observable<Integer> dematerialize = observable.materialize().dematerialize();
 
         Observer<Integer> observer = mock(Observer.class);
         dematerialize.subscribe(observer);
@@ -66,7 +66,7 @@ public void testDematerialize2() {
     public void testDematerialize3() {
         Exception exception = new Exception("test");
         Observable<Integer> observable = Observable.error(exception);
-        Observable<Integer> dematerialize = Observable.create(dematerialize(observable.materialize()));
+        Observable<Integer> dematerialize = observable.materialize().dematerialize();
 
         Observer<Integer> observer = mock(Observer.class);
         dematerialize.subscribe(observer);
@@ -106,4 +106,33 @@ public void testCompletePassThru() {
         verify(observer, times(0)).onNext(any(Integer.class));
     }
 
+    @Test
+    public void testHonorsContractWhenCompleted() {
+        Observable<Integer> source = Observable.just(1);
+        
+        Observable<Integer> result = source.materialize().dematerialize();
+        
+        Observer<Integer> o = mock(Observer.class);
+        
+        result.unsafeSubscribe(Subscribers.from(o));
+        
+        verify(o).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testHonorsContractWhenThrows() {
+        Observable<Integer> source = Observable.error(new OperationReduceTest.CustomException());
+        
+        Observable<Integer> result = source.materialize().dematerialize();
+        
+        Observer<Integer> o = mock(Observer.class);
+        
+        result.unsafeSubscribe(Subscribers.from(o));
+        
+        verify(o, never()).onNext(any(Integer.class));
+        verify(o, never()).onCompleted();
+        verify(o).onError(any(OperationReduceTest.CustomException.class));
+    }
 }

From 34177b0f2221ff66a293fe8164f8df8ed7241fb3 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 15:49:06 +0200
Subject: [PATCH 269/422] OperatorDistinct

---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../java/rx/operators/OperationDistinct.java  | 188 ------------------
 .../java/rx/operators/OperatorDistinct.java   |  64 ++++++
 ...nctTest.java => OperatorDistinctTest.java} |  78 +-------
 4 files changed, 74 insertions(+), 262 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationDistinct.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDistinct.java
 rename rxjava-core/src/test/java/rx/operators/{OperationDistinctTest.java => OperatorDistinctTest.java} (55%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..e6260492d6 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -56,7 +56,6 @@
 import rx.operators.OperationDefer;
 import rx.operators.OperationDelay;
 import rx.operators.OperationDematerialize;
-import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
 import rx.operators.OperationFinally;
 import rx.operators.OperationFlatMap;
@@ -95,6 +94,7 @@
 import rx.operators.OperatorAsObservable;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorDistinct;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
@@ -3606,7 +3606,7 @@ public final <T2> Observable<T2> dematerialize() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229764.aspx">MSDN: Observable.distinct</a>
      */
     public final Observable<T> distinct() {
-        return create(OperationDistinct.distinct(this));
+        return lift(new OperatorDistinct<T, T>(Functions.<T>identity()));
     }
 
     /**
@@ -3623,7 +3623,7 @@ public final Observable<T> distinct() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh244310.aspx">MSDN: Observable.distinct</a>
      */
     public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelector) {
-        return create(OperationDistinct.distinct(this, keySelector));
+        return lift(new OperatorDistinct<T, U>(keySelector));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java b/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
deleted file mode 100644
index 9b0782d4a0..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinct.java
+++ /dev/null
@@ -1,188 +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.Comparator;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Func1;
-import rx.functions.Functions;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Returns an Observable that emits all distinct items emitted by the source.
- * 
- * Be careful with this operation when using infinite or very large observables
- * as it has to store all distinct values it has received.
- */
-public final class OperationDistinct {
-
-    /**
-     * Returns an Observable that emits all distinct items emitted by the source
-     * 
-     * @param source
-     *            The source Observable to emit the distinct items for.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T, U> OnSubscribeFunc<T> distinct(Observable<? extends T> source, Func1<? super T, ? extends U> keySelector) {
-        return new Distinct<T, U>(source, keySelector);
-    }
-
-    /**
-     * Returns an Observable that emits all distinct items emitted by the source
-     * 
-     * @param source
-     *            The source Observable to emit the distinct items for.
-     * @param equalityComparator
-     *            The comparator to use for deciding whether to consider two items as equal or not.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T> OnSubscribeFunc<T> distinct(Observable<? extends T> source, Comparator<T> equalityComparator) {
-        return new DistinctWithComparator<T, T>(source, Functions.<T> identity(), equalityComparator);
-    }
-
-    /**
-     * Returns an Observable that emits all distinct items emitted by the source
-     * 
-     * @param source
-     *            The source Observable to emit the distinct items for.
-     * @param equalityComparator
-     *            The comparator to use for deciding whether to consider the two item keys as equal or not.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T, U> OnSubscribeFunc<T> distinct(Observable<? extends T> source, Func1<? super T, ? extends U> keySelector, Comparator<U> equalityComparator) {
-        return new DistinctWithComparator<T, U>(source, keySelector, equalityComparator);
-    }
-
-    /**
-     * Returns an Observable that emits all distinct items emitted by the source
-     * 
-     * @param source
-     *            The source Observable to emit the distinct items for.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T> OnSubscribeFunc<T> distinct(Observable<? extends T> source) {
-        return new Distinct<T, T>(source, Functions.<T> identity());
-    }
-
-    private static class Distinct<T, U> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> source;
-        private final Func1<? super T, ? extends U> keySelector;
-
-        private Distinct(Observable<? extends T> source, Func1<? super T, ? extends U> keySelector) {
-            this.source = source;
-            this.keySelector = keySelector;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final Subscription sourceSub = source.unsafeSubscribe(new Subscriber<T>() {
-                private final Set<U> emittedKeys = new HashSet<U>();
-
-                @Override
-                public void onCompleted() {
-                    observer.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    observer.onError(e);
-                }
-
-                @Override
-                public void onNext(T next) {
-                    U nextKey = keySelector.call(next);
-                    if (!emittedKeys.contains(nextKey)) {
-                        emittedKeys.add(nextKey);
-                        observer.onNext(next);
-                    }
-                }
-            });
-
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    sourceSub.unsubscribe();
-                }
-            });
-        }
-    }
-
-    private static class DistinctWithComparator<T, U> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> source;
-        private final Func1<? super T, ? extends U> keySelector;
-        private final Comparator<U> equalityComparator;
-
-        private DistinctWithComparator(Observable<? extends T> source, Func1<? super T, ? extends U> keySelector, Comparator<U> equalityComparator) {
-            this.source = source;
-            this.keySelector = keySelector;
-            this.equalityComparator = equalityComparator;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final Subscription sourceSub = source.unsafeSubscribe(new Subscriber<T>() {
-
-                // due to the totally arbitrary equality comparator, we can't use anything more efficient than lists here 
-                private final List<U> emittedKeys = new ArrayList<U>();
-
-                @Override
-                public void onCompleted() {
-                    observer.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    observer.onError(e);
-                }
-
-                @Override
-                public void onNext(T next) {
-                    U nextKey = keySelector.call(next);
-                    if (!alreadyEmitted(nextKey)) {
-                        emittedKeys.add(nextKey);
-                        observer.onNext(next);
-                    }
-                }
-
-                private boolean alreadyEmitted(U newKey) {
-                    for (U key : emittedKeys) {
-                        if (equalityComparator.compare(key, newKey) == 0) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-            });
-
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    sourceSub.unsubscribe();
-                }
-            });
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDistinct.java b/rxjava-core/src/main/java/rx/operators/OperatorDistinct.java
new file mode 100644
index 0000000000..02efa1b9fd
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDistinct.java
@@ -0,0 +1,64 @@
+/**
+ * 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.HashSet;
+import java.util.Set;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Returns an Observable that emits all distinct items emitted by the source.
+ * 
+ * @param <T> the value type
+ * @param <U> the key type
+ */
+public final class OperatorDistinct<T, U> implements Operator<T, T> {
+    final Func1<? super T, ? extends U> keySelector;
+
+    public OperatorDistinct(Func1<? super T, ? extends U> keySelector) {
+        this.keySelector = keySelector;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new Subscriber<T>(child) {
+            Set<U> keyMemory = new HashSet<U>();
+
+            @Override
+            public void onNext(T t) {
+                U key = keySelector.call(t);
+                if (keyMemory.add(key)) {
+                    child.onNext(t);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                keyMemory = null;
+                child.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                keyMemory = null;
+                child.onCompleted();
+            }
+            
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDistinctTest.java
similarity index 55%
rename from rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorDistinctTest.java
index b33f602dce..bef7e2ea7f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDistinctTest.java
@@ -22,9 +22,7 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.MockitoAnnotations.initMocks;
-import static rx.operators.OperationDistinct.distinct;
 
-import java.util.Comparator;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -35,7 +33,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 
-public class OperationDistinctTest {
+public class OperatorDistinctTest {
 
     @Mock
     Observer<String> w;
@@ -53,13 +51,6 @@ public String call(String s) {
         }
     };
 
-    final Comparator<String> COMPARE_LENGTH = new Comparator<String>() {
-        @Override
-        public int compare(String s1, String s2) {
-            return s1.length() - s2.length();
-        }
-    };
-
     @Before
     public void before() {
         initMocks(this);
@@ -68,7 +59,7 @@ public void before() {
     @Test
     public void testDistinctOfNone() {
         Observable<String> src = Observable.empty();
-        Observable.create(distinct(src)).subscribe(w);
+        src.distinct().subscribe(w);
 
         verify(w, never()).onNext(anyString());
         verify(w, never()).onError(any(Throwable.class));
@@ -78,7 +69,7 @@ public void testDistinctOfNone() {
     @Test
     public void testDistinctOfNoneWithKeySelector() {
         Observable<String> src = Observable.empty();
-        Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
+        src.distinct(TO_UPPER_WITH_EXCEPTION).subscribe(w);
 
         verify(w, never()).onNext(anyString());
         verify(w, never()).onError(any(Throwable.class));
@@ -88,7 +79,7 @@ public void testDistinctOfNoneWithKeySelector() {
     @Test
     public void testDistinctOfNormalSource() {
         Observable<String> src = Observable.from("a", "b", "c", "c", "c", "b", "b", "a", "e");
-        Observable.create(distinct(src)).subscribe(w);
+        src.distinct().subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext("a");
@@ -103,7 +94,7 @@ public void testDistinctOfNormalSource() {
     @Test
     public void testDistinctOfNormalSourceWithKeySelector() {
         Observable<String> src = Observable.from("a", "B", "c", "C", "c", "B", "b", "a", "E");
-        Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
+        src.distinct(TO_UPPER_WITH_EXCEPTION).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext("a");
@@ -115,65 +106,10 @@ public void testDistinctOfNormalSourceWithKeySelector() {
         verify(w, never()).onError(any(Throwable.class));
     }
 
-    @Test
-    public void testDistinctOfNormalSourceWithComparator() {
-        Observable<String> src = Observable.from("1", "12", "123", "aaa", "321", "12", "21", "1", "12345");
-        Observable.create(distinct(src, COMPARE_LENGTH)).subscribe(w);
-
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w, times(1)).onNext("1");
-        inOrder.verify(w, times(1)).onNext("12");
-        inOrder.verify(w, times(1)).onNext("123");
-        inOrder.verify(w, times(1)).onNext("12345");
-        inOrder.verify(w, times(1)).onCompleted();
-        inOrder.verify(w, never()).onNext(anyString());
-        verify(w, never()).onError(any(Throwable.class));
-    }
-
-    @Test
-    public void testDistinctOfNormalSourceWithKeySelectorAndComparator() {
-        Observable<String> src = Observable.from("a", "x", "ab", "abc", "cba", "de", "x", "a", "abcd");
-        Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
-
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w, times(1)).onNext("a");
-        inOrder.verify(w, times(1)).onNext("x");
-        inOrder.verify(w, times(1)).onNext("abc");
-        inOrder.verify(w, times(1)).onNext("abcd");
-        inOrder.verify(w, times(1)).onCompleted();
-        inOrder.verify(w, never()).onNext(anyString());
-        verify(w, never()).onError(any(Throwable.class));
-    }
-
-    @Test
-    public void testDistinctOfNormalSourceWithKeySelectorAndComparatorAndTwoSubscriptions() {
-        Observable<String> src = Observable.from("a", "x", "ab", "abc", "cba", "de", "x", "a", "abcd");
-        Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
-
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w, times(1)).onNext("a");
-        inOrder.verify(w, times(1)).onNext("x");
-        Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w2);
-        inOrder.verify(w, times(1)).onNext("abc");
-        inOrder.verify(w, times(1)).onNext("abcd");
-        inOrder.verify(w, times(1)).onCompleted();
-        inOrder.verify(w, never()).onNext(anyString());
-        verify(w, never()).onError(any(Throwable.class));
-
-        InOrder inOrder2 = inOrder(w2);
-        inOrder2.verify(w2, times(1)).onNext("a");
-        inOrder2.verify(w2, times(1)).onNext("x");
-        inOrder2.verify(w2, times(1)).onNext("abc");
-        inOrder2.verify(w2, times(1)).onNext("abcd");
-        inOrder2.verify(w2, times(1)).onCompleted();
-        inOrder2.verify(w2, never()).onNext(anyString());
-        verify(w2, never()).onError(any(Throwable.class));
-    }
-
     @Test
     public void testDistinctOfSourceWithNulls() {
         Observable<String> src = Observable.from(null, "a", "a", null, null, "b", null);
-        Observable.create(distinct(src)).subscribe(w);
+        src.distinct().subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext(null);
@@ -187,7 +123,7 @@ public void testDistinctOfSourceWithNulls() {
     @Test
     public void testDistinctOfSourceWithExceptionsFromKeySelector() {
         Observable<String> src = Observable.from("a", "b", null, "c");
-        Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
+        src.distinct(TO_UPPER_WITH_EXCEPTION).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext("a");

From 7c9ab65e9956a4fc89240886163084fa6d93d137 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 16:12:03 +0200
Subject: [PATCH 270/422] OperatorDistinctUntilChanged

---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../OperationDistinctUntilChanged.java        | 148 ------------------
 .../OperatorDistinctUntilChanged.java         |  68 ++++++++
 ... => OperatorDistinctUntilChangedTest.java} |  75 +--------
 4 files changed, 78 insertions(+), 219 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDistinctUntilChanged.java
 rename rxjava-core/src/test/java/rx/operators/{OperationDistinctUntilChangedTest.java => OperatorDistinctUntilChangedTest.java} (57%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..72498c6faa 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -57,7 +57,6 @@
 import rx.operators.OperationDelay;
 import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
-import rx.operators.OperationDistinctUntilChanged;
 import rx.operators.OperationFinally;
 import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupByUntil;
@@ -95,6 +94,7 @@
 import rx.operators.OperatorAsObservable;
 import rx.operators.OperatorCache;
 import rx.operators.OperatorCast;
+import rx.operators.OperatorDistinctUntilChanged;
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
@@ -3638,7 +3638,7 @@ public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelecto
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229494.aspx">MSDN: Observable.distinctUntilChanged</a>
      */
     public final Observable<T> distinctUntilChanged() {
-        return create(OperationDistinctUntilChanged.distinctUntilChanged(this));
+        return lift(new OperatorDistinctUntilChanged<T, T>(Functions.<T>identity()));
     }
 
     /**
@@ -3656,7 +3656,7 @@ public final Observable<T> distinctUntilChanged() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229508.aspx">MSDN: Observable.distinctUntilChanged</a>
      */
     public final <U> Observable<T> distinctUntilChanged(Func1<? super T, ? extends U> keySelector) {
-        return create(OperationDistinctUntilChanged.distinctUntilChanged(this, keySelector));
+        return lift(new OperatorDistinctUntilChanged<T, U>(keySelector));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java b/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
deleted file mode 100644
index 645bb95324..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationDistinctUntilChanged.java
+++ /dev/null
@@ -1,148 +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.Comparator;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Func1;
-import rx.functions.Functions;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Returns an Observable that emits all sequentially distinct items emitted by the source.
- */
-public final class OperationDistinctUntilChanged {
-
-    /**
-     * Returns an Observable that emits all sequentially distinct items emitted by the source.
-     * 
-     * @param source
-     *            The source Observable to emit the sequentially distinct items for.
-     * @param equalityComparator
-     *            The comparator to use for deciding whether to consider two items as equal or not.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T> OnSubscribeFunc<T> distinctUntilChanged(Observable<? extends T> source, Comparator<T> equalityComparator) {
-        return new DistinctUntilChanged<T, T>(source, Functions.<T> identity(), equalityComparator);
-    }
-
-    /**
-     * Returns an Observable that emits all sequentially distinct items emitted by the source.
-     * 
-     * @param source
-     *            The source Observable to emit the sequentially distinct items for.
-     * @param keySelector
-     *            The function to select the key to use for the equality checks.
-     * @param equalityComparator
-     *            The comparator to use for deciding whether to consider the two item keys as equal or not.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T, U> OnSubscribeFunc<T> distinctUntilChanged(Observable<? extends T> source, Func1<? super T, ? extends U> keySelector, Comparator<U> equalityComparator) {
-        return new DistinctUntilChanged<T, U>(source, keySelector, equalityComparator);
-    }
-
-    /**
-     * Returns an Observable that emits all sequentially distinct items emitted by the source.
-     * 
-     * @param source
-     *            The source Observable to emit the sequentially distinct items for.
-     * @param keySelector
-     *            The function to select the key to use for the equality checks.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T, U> OnSubscribeFunc<T> distinctUntilChanged(Observable<? extends T> source, Func1<? super T, ? extends U> keySelector) {
-        return new DistinctUntilChanged<T, U>(source, keySelector, new DefaultEqualityComparator<U>());
-    }
-
-    /**
-     * Returns an Observable that emits all sequentially distinct items emitted by the source.
-     * 
-     * @param source
-     *            The source Observable to emit the sequentially distinct items for.
-     * @return A subscription function for creating the target Observable.
-     */
-    public static <T> OnSubscribeFunc<T> distinctUntilChanged(Observable<? extends T> source) {
-        return new DistinctUntilChanged<T, T>(source, Functions.<T> identity(), new DefaultEqualityComparator<T>());
-    }
-
-    // does not define a useful ordering; it's only used for equality tests here
-    private static class DefaultEqualityComparator<T> implements Comparator<T> {
-        @Override
-        public int compare(T t1, T t2) {
-            if (t1 == null) {
-                return t2 == null ? 0 : 1;
-            } else {
-                return t1.equals(t2) ? 0 : 1;
-            }
-        }
-    }
-
-    private static class DistinctUntilChanged<T, U> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> source;
-        private final Func1<? super T, ? extends U> keySelector;
-        private final Comparator<U> equalityComparator;
-
-        private DistinctUntilChanged(Observable<? extends T> source, Func1<? super T, ? extends U> keySelector, Comparator<U> equalityComparator) {
-            this.source = source;
-            this.keySelector = keySelector;
-            this.equalityComparator = equalityComparator;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final Subscription sourceSub = source.unsafeSubscribe(new Subscriber<T>() {
-                private U lastEmittedKey;
-                private boolean hasEmitted;
-
-                @Override
-                public void onCompleted() {
-                    observer.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    observer.onError(e);
-                }
-
-                @Override
-                public void onNext(T next) {
-                    U lastKey = lastEmittedKey;
-                    U nextKey = keySelector.call(next);
-                    lastEmittedKey = nextKey;
-                    if (!hasEmitted) {
-                        hasEmitted = true;
-                        observer.onNext(next);
-                    } else if (equalityComparator.compare(lastKey, nextKey) != 0) {
-                        observer.onNext(next);
-                    }
-                }
-            });
-
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    sourceSub.unsubscribe();
-                }
-            });
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDistinctUntilChanged.java b/rxjava-core/src/main/java/rx/operators/OperatorDistinctUntilChanged.java
new file mode 100644
index 0000000000..90b1c44141
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDistinctUntilChanged.java
@@ -0,0 +1,68 @@
+/**
+ * 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.functions.Func1;
+
+/**
+ * Returns an Observable that emits all sequentially distinct items emitted by the source.
+ * @param <T> the value type
+ * @param <U> the key type
+ */
+public final class OperatorDistinctUntilChanged<T, U> implements Operator<T, T> {
+    final Func1<? super T, ? extends U> keySelector;
+
+    public OperatorDistinctUntilChanged(Func1<? super T, ? extends U> keySelector) {
+        this.keySelector = keySelector;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new Subscriber<T>(child) {
+            U previousKey;
+            boolean hasPrevious;
+            @Override
+            public void onNext(T t) {
+                U currentKey = previousKey;
+                U key = keySelector.call(t);
+                previousKey = key;
+                
+                if (hasPrevious) {
+                    if (!(currentKey == key || (key != null && key.equals(currentKey)))) {
+                        child.onNext(t);
+                    }
+                } else {
+                    hasPrevious = true;
+                    child.onNext(t);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                child.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+            
+        };
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDistinctUntilChangedTest.java
similarity index 57%
rename from rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorDistinctUntilChangedTest.java
index cc6184001b..e5bfd1bf4c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDistinctUntilChangedTest.java
@@ -22,9 +22,7 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.MockitoAnnotations.initMocks;
-import static rx.operators.OperationDistinctUntilChanged.distinctUntilChanged;
 
-import java.util.Comparator;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -35,7 +33,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 
-public class OperationDistinctUntilChangedTest {
+public class OperatorDistinctUntilChangedTest {
 
     @Mock
     Observer<String> w;
@@ -53,13 +51,6 @@ public String call(String s) {
         }
     };
 
-    final Comparator<String> COMPARE_LENGTH = new Comparator<String>() {
-        @Override
-        public int compare(String s1, String s2) {
-            return s1.length() - s2.length();
-        }
-    };
-
     @Before
     public void before() {
         initMocks(this);
@@ -68,7 +59,7 @@ public void before() {
     @Test
     public void testDistinctUntilChangedOfNone() {
         Observable<String> src = Observable.empty();
-        Observable.create(distinctUntilChanged(src)).subscribe(w);
+        src.distinctUntilChanged().subscribe(w);
 
         verify(w, never()).onNext(anyString());
         verify(w, never()).onError(any(Throwable.class));
@@ -78,7 +69,7 @@ public void testDistinctUntilChangedOfNone() {
     @Test
     public void testDistinctUntilChangedOfNoneWithKeySelector() {
         Observable<String> src = Observable.empty();
-        Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
+        src.distinctUntilChanged(TO_UPPER_WITH_EXCEPTION).subscribe(w);
 
         verify(w, never()).onNext(anyString());
         verify(w, never()).onError(any(Throwable.class));
@@ -88,7 +79,7 @@ public void testDistinctUntilChangedOfNoneWithKeySelector() {
     @Test
     public void testDistinctUntilChangedOfNormalSource() {
         Observable<String> src = Observable.from("a", "b", "c", "c", "c", "b", "b", "a", "e");
-        Observable.create(distinctUntilChanged(src)).subscribe(w);
+        src.distinctUntilChanged().subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext("a");
@@ -105,7 +96,7 @@ public void testDistinctUntilChangedOfNormalSource() {
     @Test
     public void testDistinctUntilChangedOfNormalSourceWithKeySelector() {
         Observable<String> src = Observable.from("a", "b", "c", "C", "c", "B", "b", "a", "e");
-        Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
+        src.distinctUntilChanged(TO_UPPER_WITH_EXCEPTION).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext("a");
@@ -122,7 +113,7 @@ public void testDistinctUntilChangedOfNormalSourceWithKeySelector() {
     @Test
     public void testDistinctUntilChangedOfSourceWithNulls() {
         Observable<String> src = Observable.from(null, "a", "a", null, null, "b", null, null);
-        Observable.create(distinctUntilChanged(src)).subscribe(w);
+        src.distinctUntilChanged().subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext(null);
@@ -138,7 +129,7 @@ public void testDistinctUntilChangedOfSourceWithNulls() {
     @Test
     public void testDistinctUntilChangedOfSourceWithExceptionsFromKeySelector() {
         Observable<String> src = Observable.from("a", "b", null, "c");
-        Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
+        src.distinctUntilChanged(TO_UPPER_WITH_EXCEPTION).subscribe(w);
 
         InOrder inOrder = inOrder(w);
         inOrder.verify(w, times(1)).onNext("a");
@@ -147,56 +138,4 @@ public void testDistinctUntilChangedOfSourceWithExceptionsFromKeySelector() {
         inOrder.verify(w, never()).onNext(anyString());
         inOrder.verify(w, never()).onCompleted();
     }
-
-    @Test
-    public void testDistinctUntilChangedWithComparator() {
-        Observable<String> src = Observable.from("a", "b", "c", "aa", "bb", "c", "ddd");
-        Observable.create(distinctUntilChanged(src, COMPARE_LENGTH)).subscribe(w);
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w, times(1)).onNext("a");
-        inOrder.verify(w, times(1)).onNext("aa");
-        inOrder.verify(w, times(1)).onNext("c");
-        inOrder.verify(w, times(1)).onNext("ddd");
-        inOrder.verify(w, times(1)).onCompleted();
-        inOrder.verify(w, never()).onNext(anyString());
-        verify(w, never()).onError(any(Throwable.class));
-    }
-
-    @Test
-    public void testDistinctUntilChangedWithComparatorAndKeySelector() {
-        Observable<String> src = Observable.from("a", "b", "x", "aa", "bb", "c", "ddd");
-        Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w, times(1)).onNext("a");
-        inOrder.verify(w, times(1)).onNext("x");
-        inOrder.verify(w, times(1)).onNext("c");
-        inOrder.verify(w, times(1)).onNext("ddd");
-        inOrder.verify(w, times(1)).onCompleted();
-        inOrder.verify(w, never()).onNext(anyString());
-        verify(w, never()).onError(any(Throwable.class));
-    }
-
-    @Test
-    public void testDistinctUntilChangedWithComparatorAndKeySelectorandTwoSubscriptions() {
-        Observable<String> src = Observable.from("a", "b", "x", "aa", "bb", "c", "ddd");
-        Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
-        InOrder inOrder = inOrder(w);
-        inOrder.verify(w, times(1)).onNext("a");
-        inOrder.verify(w, times(1)).onNext("x");
-        Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w2);
-        inOrder.verify(w, times(1)).onNext("c");
-        inOrder.verify(w, times(1)).onNext("ddd");
-        inOrder.verify(w, times(1)).onCompleted();
-        inOrder.verify(w, never()).onNext(anyString());
-        verify(w, never()).onError(any(Throwable.class));
-
-        InOrder inOrder2 = inOrder(w2);
-        inOrder2.verify(w2, times(1)).onNext("a");
-        inOrder2.verify(w2, times(1)).onNext("x");
-        inOrder2.verify(w2, times(1)).onNext("c");
-        inOrder2.verify(w2, times(1)).onNext("ddd");
-        inOrder2.verify(w2, times(1)).onCompleted();
-        inOrder2.verify(w2, never()).onNext(anyString());
-        verify(w2, never()).onError(any(Throwable.class));
-    }
 }

From f58b9bc193b2431dfffaebbd02edf88d18fddb08 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 16:24:50 +0200
Subject: [PATCH 271/422] OperatorFinallyDo

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../java/rx/operators/OperationFinally.java   | 106 ------------------
 .../java/rx/operators/OperatorFinally.java    |  68 +++++++++++
 ...allyTest.java => OperatorFinallyTest.java} |   5 +-
 4 files changed, 72 insertions(+), 111 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationFinally.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorFinally.java
 rename rxjava-core/src/test/java/rx/operators/{OperationFinallyTest.java => OperatorFinallyTest.java} (90%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..1d9a2bde0a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -58,7 +58,6 @@
 import rx.operators.OperationDematerialize;
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
-import rx.operators.OperationFinally;
 import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupByUntil;
 import rx.operators.OperationGroupJoin;
@@ -98,6 +97,7 @@
 import rx.operators.OperatorDoOnEach;
 import rx.operators.OperatorElementAt;
 import rx.operators.OperatorFilter;
+import rx.operators.OperatorFinally;
 import rx.operators.OperatorGroupBy;
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMaterialize;
@@ -3923,7 +3923,7 @@ public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212133.aspx">MSDN: Observable.Finally</a>
      */
     public final Observable<T> finallyDo(Action0 action) {
-        return create(OperationFinally.finallyDo(this, action));
+        return lift(new OperatorFinally<T>(action));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFinally.java b/rxjava-core/src/main/java/rx/operators/OperationFinally.java
deleted file mode 100644
index f16b4651ab..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationFinally.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 rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-
-/**
- * Registers an action to be called when an Observable invokes onComplete or onError.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/finallyDo.png">
- * <p>
- * See also the <a href="http://msdn.microsoft.com/en-us/library/hh212133(v=vs.103).aspx">MSDN
- * Observable.Finally method</a>
- */
-public final class OperationFinally {
-
-    /**
-     * Call a given action when a sequence completes (with or without an
-     * exception). The returned observable is exactly as threadsafe as the
-     * source observable.
-     * <p/>
-     * Note that "finally" is a Java reserved word and cannot be an identifier,
-     * so we use "finallyDo".
-     * 
-     * @param sequence
-     *            An observable sequence of elements
-     * @param action
-     *            An action to be taken when the sequence is complete or throws an exception
-     * @return An observable sequence with the same elements as the input.
-     *         After the last element is consumed (and {@link Observer#onCompleted} has been called),
-     *         or after an exception is thrown (and {@link Observer#onError} has been called),
-     *         the given action will be called.
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212133(v=vs.103).aspx">MSDN Observable.Finally method</a>
-     */
-    public static <T> OnSubscribeFunc<T> finallyDo(final Observable<? extends T> sequence, final Action0 action) {
-        return new OnSubscribeFunc<T>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new Finally<T>(sequence, action).onSubscribe(observer);
-            }
-        };
-    }
-
-    private static class Finally<T> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> sequence;
-        private final Action0 finalAction;
-
-        Finally(final Observable<? extends T> sequence, Action0 finalAction) {
-            this.sequence = sequence;
-            this.finalAction = finalAction;
-        }
-
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            return sequence.unsafeSubscribe(new FinallyObserver(observer));
-        }
-
-        private class FinallyObserver extends Subscriber<T> {
-            private final Observer<? super T> observer;
-
-            FinallyObserver(Observer<? super T> observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onCompleted() {
-                try {
-                    observer.onCompleted();
-                } finally {
-                    finalAction.call();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                try {
-                    observer.onError(e);
-                } finally {
-                    finalAction.call();
-                }
-            }
-
-            @Override
-            public void onNext(T args) {
-                observer.onNext(args);
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorFinally.java b/rxjava-core/src/main/java/rx/operators/OperatorFinally.java
new file mode 100644
index 0000000000..4dc4ef3818
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorFinally.java
@@ -0,0 +1,68 @@
+/**
+ * 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.functions.Action0;
+
+/**
+ * Registers an action to be called after an Observable invokes onComplete or onError.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/finallyDo.png">
+ * <p>
+ * See also the <a href="http://msdn.microsoft.com/en-us/library/hh212133(v=vs.103).aspx">MSDN
+ * Observable.Finally method</a>
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorFinally<T> implements Operator<T, T> {
+    final Action0 action;
+
+    public OperatorFinally(Action0 action) {
+        this.action = action;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new Subscriber<T>(child) {
+
+            @Override
+            public void onNext(T t) {
+                child.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                try {
+                    child.onError(e);
+                } finally {
+                    action.call();
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                try {
+                    child.onCompleted();
+                } finally {
+                    action.call();
+                }
+            }
+        };
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java b/rxjava-core/src/test/java/rx/operators/OperatorFinallyTest.java
similarity index 90%
rename from rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorFinallyTest.java
index 2db5f7722f..6e8cefa9d9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFinallyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorFinallyTest.java
@@ -18,7 +18,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationFinally.finallyDo;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -27,7 +26,7 @@
 import rx.Observer;
 import rx.functions.Action0;
 
-public class OperationFinallyTest {
+public class OperatorFinallyTest {
 
     private Action0 aAction0;
     private Observer<String> observer;
@@ -41,7 +40,7 @@ public void before() {
     }
 
     private void checkActionCalled(Observable<String> input) {
-        Observable.create(finallyDo(input, aAction0)).subscribe(observer);
+        input.finallyDo(aAction0).subscribe(observer);
         verify(aAction0, times(1)).call();
     }
 

From e4cb23ceb8fda49a2abcfaa9233fdaa9db2aa812 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 24 Apr 2014 17:12:19 +0200
Subject: [PATCH 272/422] OperatorMergeMap

---
 rxjava-core/src/main/java/rx/Observable.java  |  11 +-
 .../java/rx/operators/OperationFlatMap.java   | 394 ------------------
 .../rx/operators/OperatorMergeMapPair.java    | 120 ++++++
 .../operators/OperatorMergeMapTransform.java  | 131 ++++++
 ...MapTest.java => OperatorMergeMapTest.java} |   2 +-
 5 files changed, 258 insertions(+), 400 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMergeMapPair.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMergeMapTransform.java
 rename rxjava-core/src/test/java/rx/operators/{OperationFlatMapTest.java => OperatorMergeMapTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..985e3e8c02 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -59,7 +59,6 @@
 import rx.operators.OperationDistinct;
 import rx.operators.OperationDistinctUntilChanged;
 import rx.operators.OperationFinally;
-import rx.operators.OperationFlatMap;
 import rx.operators.OperationGroupByUntil;
 import rx.operators.OperationGroupJoin;
 import rx.operators.OperationInterval;
@@ -102,6 +101,8 @@
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMaterialize;
 import rx.operators.OperatorMerge;
+import rx.operators.OperatorMergeMapPair;
+import rx.operators.OperatorMergeMapTransform;
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
@@ -4322,7 +4323,7 @@ public final <R> Observable<R> mergeMap(
             Func1<? super T, ? extends Observable<? extends R>> onNext,
             Func1<? super Throwable, ? extends Observable<? extends R>> onError,
             Func0<? extends Observable<? extends R>> onCompleted) {
-        return create(OperationFlatMap.flatMap(this, onNext, onError, onCompleted));
+        return lift(new OperatorMergeMapTransform<T, R>(onNext, onError, onCompleted));
     }
 
     /**
@@ -4345,7 +4346,7 @@ public final <R> Observable<R> mergeMap(
      */
     public final <U, R> Observable<R> mergeMap(Func1<? super T, ? extends Observable<? extends U>> collectionSelector,
             Func2<? super T, ? super U, ? extends R> resultSelector) {
-        return create(OperationFlatMap.flatMap(this, collectionSelector, resultSelector));
+        return lift(new OperatorMergeMapPair<T, U, R>(collectionSelector, resultSelector));
     }
 
     /**
@@ -4363,7 +4364,7 @@ public final <U, R> Observable<R> mergeMap(Func1<? super T, ? extends Observable
      *         the values in the Iterables corresponding to those items, as generated by {@code collectionSelector}
      */
     public final <R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector) {
-        return merge(map(OperationFlatMap.flatMapIterableFunc(collectionSelector)));
+        return merge(map(OperatorMergeMapPair.convertSelector(collectionSelector)));
     }
 
     /**
@@ -4387,7 +4388,7 @@ public final <R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Itera
      */
     public final <U, R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Iterable<? extends U>> collectionSelector,
             Func2<? super T, ? super U, ? extends R> resultSelector) {
-        return mergeMap(OperationFlatMap.flatMapIterableFunc(collectionSelector), resultSelector);
+        return mergeMap(OperatorMergeMapPair.convertSelector(collectionSelector), resultSelector);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java b/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
deleted file mode 100644
index 6d2606b2f9..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationFlatMap.java
+++ /dev/null
@@ -1,394 +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.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func0;
-import rx.functions.Func1;
-import rx.functions.Func2;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-
-/**
- * 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 <T, U, R> OnSubscribeFunc<R> flatMap(Observable<? extends T> source,
-            Func1<? super T, ? extends Observable<? extends U>> collectionSelector,
-            Func2<? super T, ? super U, ? extends R> resultSelector
-            ) {
-        return new FlatMapPairSelector<T, U, R>(source, collectionSelector, resultSelector);
-    }
-
-    /**
-     * Converts the result Iterable of a function into an Observable.
-     */
-    public static <T, U> Func1<T, Observable<U>> flatMapIterableFunc(
-            Func1<? super T, ? extends Iterable<? extends U>> collectionSelector) {
-        return new IterableToObservableFunc<T, U>(collectionSelector);
-    }
-
-    /**
-     * Converts the result Iterable of a function into an Observable.
-     * 
-     * @param <T>
-     *            the parameter type
-     * @param <R>
-     *            the result type
-     */
-    private static final class IterableToObservableFunc<T, R> implements Func1<T, Observable<R>> {
-        final Func1<? super T, ? extends Iterable<? extends R>> func;
-
-        public IterableToObservableFunc(Func1<? super T, ? extends Iterable<? extends R>> func) {
-            this.func = func;
-        }
-
-        @Override
-        public Observable<R> 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 <T>
-     *            the source value type
-     * @param <U>
-     *            the collection value type
-     * @param <R>
-     *            the result type
-     */
-    private static final class FlatMapPairSelector<T, U, R> implements OnSubscribeFunc<R> {
-        final Observable<? extends T> source;
-        final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
-        final Func2<? super T, ? super U, ? extends R> resultSelector;
-
-        public FlatMapPairSelector(Observable<? extends T> source, Func1<? super T, ? extends Observable<? extends U>> collectionSelector, Func2<? super T, ? super U, ? extends R> resultSelector) {
-            this.source = source;
-            this.collectionSelector = collectionSelector;
-            this.resultSelector = resultSelector;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super R> t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            csub.add(source.unsafeSubscribe(new SourceObserver<T, U, R>(t1, collectionSelector, resultSelector, csub)));
-
-            return csub;
-        }
-
-        /** Observes the source, starts the collections and projects the result. */
-        private static final class SourceObserver<T, U, R> extends Subscriber<T> {
-            final Observer<? super R> observer;
-            final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
-            final Func2<? super T, ? super U, ? extends R> 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<? super R> observer, Func1<? super T, ? extends Observable<? extends U>> collectionSelector, Func2<? super T, ? super U, ? extends R> 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<? extends U> coll;
-                try {
-                    coll = collectionSelector.call(args);
-                } catch (Throwable e) {
-                    onError(e);
-                    return;
-                }
-
-                SerialSubscription ssub = new SerialSubscription();
-                csub.add(ssub);
-                wip.incrementAndGet();
-
-                ssub.set(coll.unsafeSubscribe(new CollectionObserver<T, U, R>(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<T, U, R> extends Subscriber<U> {
-            final SourceObserver<T, U, R> so;
-            final Subscription cancel;
-            final T value;
-
-            public CollectionObserver(SourceObserver<T, U, R> 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);
-            }
-        };
-    }
-
-    /**
-     * Projects the notification of an observable sequence to an observable
-     * sequence and merges the results into one.
-     */
-    public static <T, R> OnSubscribeFunc<R> flatMap(Observable<? extends T> source,
-            Func1<? super T, ? extends Observable<? extends R>> onNext,
-            Func1<? super Throwable, ? extends Observable<? extends R>> onError,
-            Func0<? extends Observable<? extends R>> onCompleted) {
-        return new FlatMapTransform<T, R>(source, onNext, onError, onCompleted);
-    }
-
-    /**
-     * Projects the notification of an observable sequence to an observable
-     * sequence and merges the results into one.
-     * 
-     * @param <T>
-     *            the source value type
-     * @param <R>
-     *            the result value type
-     */
-    private static final class FlatMapTransform<T, R> implements OnSubscribeFunc<R> {
-        final Observable<? extends T> source;
-        final Func1<? super T, ? extends Observable<? extends R>> onNext;
-        final Func1<? super Throwable, ? extends Observable<? extends R>> onError;
-        final Func0<? extends Observable<? extends R>> onCompleted;
-
-        public FlatMapTransform(Observable<? extends T> source, Func1<? super T, ? extends Observable<? extends R>> onNext, Func1<? super Throwable, ? extends Observable<? extends R>> onError, Func0<? extends Observable<? extends R>> onCompleted) {
-            this.source = source;
-            this.onNext = onNext;
-            this.onError = onError;
-            this.onCompleted = onCompleted;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super R> t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            csub.add(source.unsafeSubscribe(new SourceObserver<T, R>(t1, onNext, onError, onCompleted, csub)));
-
-            return csub;
-        }
-
-        /**
-         * Observe the source and merge the values.
-         * 
-         * @param <T>
-         *            the source value type
-         * @param <R>
-         *            the result value type
-         */
-        private static final class SourceObserver<T, R> extends Subscriber<T> {
-            final Observer<? super R> observer;
-            final Func1<? super T, ? extends Observable<? extends R>> onNext;
-            final Func1<? super Throwable, ? extends Observable<? extends R>> onError;
-            final Func0<? extends Observable<? extends R>> onCompleted;
-            final CompositeSubscription csub;
-            final AtomicInteger wip;
-            volatile boolean done;
-            final Object guard;
-
-            public SourceObserver(Observer<? super R> observer, Func1<? super T, ? extends Observable<? extends R>> onNext, Func1<? super Throwable, ? extends Observable<? extends R>> onError, Func0<? extends Observable<? extends R>> 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<? extends R> 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<? extends R> 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<? extends R> o;
-                try {
-                    o = onCompleted.call();
-                } catch (Throwable t) {
-                    synchronized (guard) {
-                        observer.onError(t);
-                    }
-                    csub.unsubscribe();
-                    return;
-                }
-                subscribeInner(o);
-                done = true;
-                finish();
-            }
-
-            void subscribeInner(Observable<? extends R> o) {
-                SerialSubscription ssub = new SerialSubscription();
-                wip.incrementAndGet();
-                csub.add(ssub);
-
-                ssub.set(o.unsafeSubscribe(new CollectionObserver<T, R>(this, ssub)));
-            }
-
-            void finish() {
-                if (wip.decrementAndGet() == 0) {
-                    synchronized (guard) {
-                        observer.onCompleted();
-                    }
-                    csub.unsubscribe();
-                }
-            }
-        }
-
-        /** Observes the collections. */
-        private static final class CollectionObserver<T, R> extends Subscriber<R> {
-            final SourceObserver<T, R> parent;
-            final Subscription cancel;
-
-            public CollectionObserver(SourceObserver<T, R> 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/main/java/rx/operators/OperatorMergeMapPair.java b/rxjava-core/src/main/java/rx/operators/OperatorMergeMapPair.java
new file mode 100644
index 0000000000..947347e882
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMergeMapPair.java
@@ -0,0 +1,120 @@
+/**
+ * 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.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Observable that pairs up the source values and all the derived collection
+ * values and projects them via the selector.
+ * 
+ * @param <T> the input value type
+ * @param <U> the derived collection value type
+ * @param <R> the result type
+ */
+public final class OperatorMergeMapPair<T, U, R> implements Operator<R, T> {
+    
+    public static <T, U> Func1<T, Observable<U>> convertSelector(final Func1<? super T, ? extends Iterable<? extends U>> selector) {
+        return new Func1<T, Observable<U>>() {
+            @Override
+            public Observable<U> call(T t1) {
+                return Observable.from(selector.call(t1));
+            }
+        };
+    }
+    
+    final Func1<? super T, ? extends Observable<? extends U>> collectionSelector;
+    final Func2<? super T, ? super U, ? extends R> resultSelector;
+
+    public OperatorMergeMapPair(Func1<? super T, ? extends Observable<? extends U>> collectionSelector, 
+            Func2<? super T, ? super U, ? extends R> resultSelector) {
+        this.collectionSelector = collectionSelector;
+        this.resultSelector = resultSelector;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super R> child) {
+        final SerializedSubscriber<R> s = new SerializedSubscriber<R>(child);
+        final CompositeSubscription csub = new CompositeSubscription();
+        child.add(csub);
+        
+        return new Subscriber<T>(child) {
+            final AtomicInteger wip = new AtomicInteger(1);
+            final Subscriber<?> self = this;
+            @Override
+            public void onNext(final T t) {
+                Observable<? extends U> collection;
+                try {
+                    collection = collectionSelector.call(t);
+                } catch (Throwable e) {
+                    onError(e);
+                    return;
+                }
+                
+                Subscriber<U> collectionSub = new Subscriber<U>() {
+
+                    @Override
+                    public void onNext(U u) {
+                        try {
+                           s.onNext(resultSelector.call(t, u));
+                        } catch (Throwable e) {
+                            onError(e);
+                        }
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        self.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        try {
+                            self.onCompleted();
+                        } finally {
+                            csub.remove(this);
+                        }
+                    }
+                };
+                csub.add(collectionSub);
+                wip.incrementAndGet();
+                
+                collection.unsafeSubscribe(collectionSub);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                if (wip.decrementAndGet() == 0) {
+                    s.onCompleted();
+                }
+            }
+            
+        };
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMergeMapTransform.java b/rxjava-core/src/main/java/rx/operators/OperatorMergeMapTransform.java
new file mode 100644
index 0000000000..88d49cfb57
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMergeMapTransform.java
@@ -0,0 +1,131 @@
+/**
+ * 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.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Projects the notification of an observable sequence to an observable
+ * sequence and merges the results into one.
+ * 
+ * @param <T> the input value type
+ * @param <R> the output value type
+ */
+public final class OperatorMergeMapTransform<T, R> implements Operator<R, T> {
+    final Func1<? super T, ? extends Observable<? extends R>> onNext;
+    final Func1<? super Throwable, ? extends Observable<? extends R>> onError;
+    final Func0<? extends Observable<? extends R>> onCompleted;
+
+    public OperatorMergeMapTransform(Func1<? super T, ? extends Observable<? extends R>> onNext, 
+            Func1<? super Throwable, ? extends Observable<? extends R>> onError, 
+            Func0<? extends Observable<? extends R>> onCompleted) {
+        this.onNext = onNext;
+        this.onError = onError;
+        this.onCompleted = onCompleted;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super R> child) {
+        final SerializedSubscriber<R> s = new SerializedSubscriber<R>(child);
+        final CompositeSubscription csub = new CompositeSubscription();
+        child.add(csub);
+        
+        return new Subscriber<T>(child) {
+            final AtomicInteger wip = new AtomicInteger(1);
+            @Override
+            public void onNext(T t) {
+                Observable<? extends R> o;
+                try {
+                    o = onNext.call(t);
+                } catch (Throwable e) {
+                    error(e);
+                    return;
+                }
+                subscribeTo(o);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                Observable<? extends R> o;
+                try {
+                    o = onError.call(e);
+                } catch (Throwable t) {
+                    error(t);
+                    return;
+                }
+                subscribeTo(o);
+                finish();
+            }
+
+            @Override
+            public void onCompleted() {
+                Observable<? extends R> o;
+                try {
+                    o = onCompleted.call();
+                } catch (Throwable e) {
+                    error(e);
+                    return;
+                }
+                subscribeTo(o);
+                finish();
+            }
+            void finish() {
+                if (wip.decrementAndGet() == 0) {
+                    s.onCompleted();
+                }
+            }
+            void error(Throwable t) {
+                s.onError(t);
+                unsubscribe();
+            }
+            void subscribeTo(Observable<? extends R> o) {
+                Subscriber<R> oSub = new Subscriber<R>() {
+
+                    @Override
+                    public void onNext(R t) {
+                        s.onNext(t);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        error(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        try {
+                            finish();
+                        } finally {
+                            csub.remove(this);
+                        }
+                    }
+                };
+                csub.add(oSub);
+                wip.incrementAndGet();
+
+                o.unsafeSubscribe(oSub);
+            }
+        };
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeMapTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorMergeMapTest.java
index 8eb9ec7960..604096b446 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationFlatMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeMapTest.java
@@ -32,7 +32,7 @@
 import rx.functions.Func1;
 import rx.functions.Func2;
 
-public class OperationFlatMapTest {
+public class OperatorMergeMapTest {
     @Test
     public void testNormal() {
         @SuppressWarnings("unchecked")

From bf976a2683fdef06fcbaff8e12edcc80c27f86bf Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Thu, 24 Apr 2014 23:25:24 +0800
Subject: [PATCH 273/422] OperatorToObservableFuture

---
 rxjava-core/src/main/java/rx/Observable.java  |  8 ++--
 ...e.java => OperatorToObservableFuture.java} | 47 ++++++++++---------
 ...va => OperatorToObservableFutureTest.java} | 17 ++++---
 3 files changed, 38 insertions(+), 34 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationToObservableFuture.java => OperatorToObservableFuture.java} (59%)
 rename rxjava-core/src/test/java/rx/operators/{OperationToObservableFutureTest.java => OperatorToObservableFutureTest.java} (75%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 7fea0a1fb1..abfb420782 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -86,7 +86,6 @@
 import rx.operators.OperationTimer;
 import rx.operators.OperationToMap;
 import rx.operators.OperationToMultimap;
-import rx.operators.OperationToObservableFuture;
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
 import rx.operators.OperatorAll;
@@ -121,6 +120,7 @@
 import rx.operators.OperatorTimeout;
 import rx.operators.OperatorTimeoutWithSelector;
 import rx.operators.OperatorTimestamp;
+import rx.operators.OperatorToObservableFuture;
 import rx.operators.OperatorToObservableList;
 import rx.operators.OperatorToObservableSortedList;
 import rx.operators.OperatorUnsubscribeOn;
@@ -1083,7 +1083,7 @@ public final static <T> Observable<T> error(Throwable exception, Scheduler sched
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      */
     public final static <T> Observable<T> from(Future<? extends T> future) {
-        return create(OperationToObservableFuture.toObservableFuture(future));
+        return create(OperatorToObservableFuture.toObservableFuture(future));
     }
 
     /**
@@ -1109,7 +1109,7 @@ public final static <T> Observable<T> from(Future<? extends T> future) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      */
     public final static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
-        return create(OperationToObservableFuture.toObservableFuture(future, timeout, unit));
+        return create(OperatorToObservableFuture.toObservableFuture(future, timeout, unit));
     }
 
     /**
@@ -1132,7 +1132,7 @@ public final static <T> Observable<T> from(Future<? extends T> future, long time
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      */
     public final static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler) {
-        return create(OperationToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
+        return create(OperatorToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java b/rxjava-core/src/main/java/rx/operators/OperatorToObservableFuture.java
similarity index 59%
rename from rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
rename to rxjava-core/src/main/java/rx/operators/OperatorToObservableFuture.java
index fbb989b4b2..e263ff5023 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationToObservableFuture.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorToObservableFuture.java
@@ -18,9 +18,9 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Action0;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -34,15 +34,15 @@
  * This is blocking so the Subscription returned when calling
  * <code>Observable.unsafeSubscribe(Observer)</code> does nothing.
  */
-public class OperationToObservableFuture {
-    /* package accessible for unit tests */static class ToObservableFuture<T> implements OnSubscribeFunc<T> {
+public class OperatorToObservableFuture {
+    /* package accessible for unit tests */static class ToObservableFuture<T> implements OnSubscribe<T> {
         private final Future<? extends T> that;
-        private final Long time;
+        private final long time;
         private final TimeUnit unit;
 
         public ToObservableFuture(Future<? extends T> that) {
             this.that = that;
-            this.time = null;
+            this.time = 0;
             this.unit = null;
         }
 
@@ -53,29 +53,34 @@ public ToObservableFuture(Future<? extends T> that, long time, TimeUnit unit) {
         }
 
         @Override
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            try {
-                T value = (time == null) ? (T) that.get() : (T) that.get(time, unit);
-
-                if (!that.isCancelled()) {
-                    observer.onNext(value);
+        public void call(Subscriber<? super T> subscriber) {
+            subscriber.add(Subscriptions.create(new Action0() {
+                @Override
+                public void call() {
+                    // If the Future is already completed, "cancel" does nothing.
+                    that.cancel(true);
                 }
-                observer.onCompleted();
+            }));
+            try {
+                T value = (unit == null) ? (T) that.get() : (T) that.get(time, unit);
+                subscriber.onNext(value);
+                subscriber.onCompleted();
             } catch (Throwable e) {
-                observer.onError(e);
+                // If this Observable is unsubscribed, we will receive an CancellationException.
+                // However, CancellationException will not be passed to the final Subscriber
+                // since it's already subscribed.
+                // If the Future is canceled in other place, CancellationException will be still
+                // passed to the final Subscriber.
+                subscriber.onError(e);
             }
-
-            // the get() has already completed so there is no point in
-            // giving the user a way to cancel.
-            return Subscriptions.empty();
         }
     }
 
-    public static <T> OnSubscribeFunc<T> toObservableFuture(final Future<? extends T> that) {
+    public static <T> OnSubscribe<T> toObservableFuture(final Future<? extends T> that) {
         return new ToObservableFuture<T>(that);
     }
 
-    public static <T> OnSubscribeFunc<T> toObservableFuture(final Future<? extends T> that, long time, TimeUnit unit) {
+    public static <T> OnSubscribe<T> toObservableFuture(final Future<? extends T> that, long time, TimeUnit unit) {
         return new ToObservableFuture<T>(that, time, unit);
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToObservableFutureTest.java
similarity index 75%
rename from rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorToObservableFutureTest.java
index 087fd1b6f4..8fdd6999df 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToObservableFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToObservableFutureTest.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
@@ -25,28 +26,27 @@
 
 import org.junit.Test;
 
+import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
 import rx.observers.TestObserver;
-import rx.operators.OperationToObservableFuture.ToObservableFuture;
 
-public class OperationToObservableFutureTest {
+public class OperatorToObservableFutureTest {
 
     @Test
     public void testSuccess() throws Exception {
         Future<Object> future = mock(Future.class);
         Object value = new Object();
         when(future.get()).thenReturn(value);
-        ToObservableFuture<Object> ob = new ToObservableFuture<Object>(future);
         Observer<Object> o = mock(Observer.class);
 
-        Subscription sub = ob.onSubscribe(new TestObserver<Object>(o));
+        Subscription sub = Observable.from(future).subscribe(new TestObserver<Object>(o));
         sub.unsubscribe();
 
         verify(o, times(1)).onNext(value);
         verify(o, times(1)).onCompleted();
-        verify(o, never()).onError(null);
-        verify(future, never()).cancel(true);
+        verify(o, never()).onError(any(Throwable.class));
+        verify(future, times(1)).cancel(true);
     }
 
     @Test
@@ -54,15 +54,14 @@ public void testFailure() throws Exception {
         Future<Object> future = mock(Future.class);
         RuntimeException e = new RuntimeException();
         when(future.get()).thenThrow(e);
-        ToObservableFuture<Object> ob = new ToObservableFuture<Object>(future);
         Observer<Object> o = mock(Observer.class);
 
-        Subscription sub = ob.onSubscribe(new TestObserver<Object>(o));
+        Subscription sub = Observable.from(future).subscribe(new TestObserver<Object>(o));
         sub.unsubscribe();
 
         verify(o, never()).onNext(null);
         verify(o, never()).onCompleted();
         verify(o, times(1)).onError(e);
-        verify(future, never()).cancel(true);
+        verify(future, times(1)).cancel(true);
     }
 }

From 3ff868ec941ca86c8ab826c3b7480c1be5b4fde5 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 24 Apr 2014 14:16:42 -0700
Subject: [PATCH 274/422] Method Signature Cleanup

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4162a2fc79..2e89352ea3 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -260,7 +260,7 @@ public static interface OnSubscribeFunc<T> 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 <R> Observable<R> lift(final Operator<? extends R, ? super T> lift) {
+    public final <R> Observable<R> lift(final Operator<? extends R, ? super T> lift) {
         return new Observable<R>(new OnSubscribe<R>() {
             @Override
             public void call(Subscriber<? super R> o) {
@@ -517,6 +517,7 @@ public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {
         return combineLatest(Arrays.asList(o1, o2), Functions.fromFunc(combineFunction));
     }
@@ -540,6 +541,7 @@ public static final <T1, T2, R> Observable<R> combineLatest(Observable<? extends
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {
         return combineLatest(Arrays.asList(o1, o2, o3), Functions.fromFunc(combineFunction));
     }
@@ -565,6 +567,7 @@ public static final <T1, T2, T3, R> Observable<R> combineLatest(Observable<? ext
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4,
             Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineFunction) {
         return combineLatest(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(combineFunction));
@@ -593,6 +596,7 @@ public static final <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<?
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5,
             Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineFunction) {
         return combineLatest(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(combineFunction));
@@ -623,6 +627,7 @@ public static final <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observab
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
             Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineFunction) {
         return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(combineFunction));
@@ -655,6 +660,7 @@ public static final <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Obse
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
             Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineFunction) {
         return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(combineFunction));
@@ -689,6 +695,7 @@ public static final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
             Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineFunction) {
         return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(combineFunction));
@@ -725,6 +732,7 @@ public static final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLat
      *         Observables by means of the given aggregation function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
      */
+    @SuppressWarnings("unchecked")
     public static final <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
             Observable<? extends T9> o9,
             Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> combineFunction) {
@@ -778,8 +786,6 @@ public final static <T> Observable<T> concat(Observable<? extends Observable<? e
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2) {
         return concat(from(t1, t2));
     }
@@ -801,8 +807,6 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
         return concat(from(t1, t2, t3));
     }
@@ -826,8 +830,6 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
         return concat(from(t1, t2, t3, t4));
     }
@@ -853,8 +855,6 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
         return concat(from(t1, t2, t3, t4, t5));
     }
@@ -882,8 +882,6 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
         return concat(from(t1, t2, t3, t4, t5, t6));
     }
@@ -913,8 +911,6 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
         return concat(from(t1, t2, t3, t4, t5, t6, t7));
     }
@@ -946,8 +942,6 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
         return concat(from(t1, t2, t3, t4, t5, t6, t7, t8));
     }
@@ -981,8 +975,6 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
         return concat(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }

From 6b6d21421c5497dec523cd6e34c2313ace7b1724 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 24 Apr 2014 19:50:42 -0700
Subject: [PATCH 275/422] Handle Thrown Errors with UnsafeSubscribe

... oxymoronic commit here ... adding some safety to unsafeSubscribe.
... fixes https://github.com/Netflix/RxJava/issues/1090
---
 rxjava-core/src/main/java/rx/Observable.java  | 10 ++++++-
 .../java/rx/operators/OperatorMergeTest.java  | 18 +++++++++++
 .../rx/operators/OperatorSubscribeOnTest.java | 30 +++++++++++++++++++
 3 files changed, 57 insertions(+), 1 deletion(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 2e89352ea3..e017088b2a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6231,7 +6231,15 @@ public void onNext(T t) {
      * @return Subscription which is the Subscriber passed in
      */
     public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
-        onSubscribe.call(subscriber);
+        try {
+            onSubscribe.call(subscriber);
+        } catch (Throwable e) {
+            if (e instanceof OnErrorNotImplementedException) {
+                throw (OnErrorNotImplementedException) e;
+            }
+            // handle broken contracts: https://github.com/Netflix/RxJava/issues/1090
+            subscriber.onError(e);
+        }
         return subscriber;
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index a4d7583d40..61ad93e93b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -323,6 +323,24 @@ public void testError2() {
         verify(stringObserver, times(0)).onNext("eight");
         verify(stringObserver, times(0)).onNext("nine");
     }
+    
+    @Test
+    public void testThrownErrorHandling() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        Observable<String> o1 = Observable.create(new OnSubscribe<String>() {
+
+            @Override
+            public void call(Subscriber<? super String> s) {
+                throw new RuntimeException("fail");
+            }
+
+        });
+
+        Observable.merge(o1, o1).subscribe(ts);
+        ts.awaitTerminalEvent(1000, TimeUnit.MILLISECONDS);
+        ts.assertTerminalEvent();
+        System.out.println("Error: " + ts.getOnErrorEvents());
+    }
 
     private static class TestSynchronousObservable implements Observable.OnSubscribeFunc<String> {
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
index db27182581..8315f43fa7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSubscribeOnTest.java
@@ -77,6 +77,36 @@ public void call(
         assertEquals(0, observer.getOnErrorEvents().size());
         assertEquals(1, observer.getOnCompletedEvents().size());
     }
+    
+    @Test
+    public void testThrownErrorHandling() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        Observable.create(new OnSubscribe<String>() {
+
+            @Override
+            public void call(Subscriber<? super String> s) {
+                throw new RuntimeException("fail");
+            }
+
+        }).subscribeOn(Schedulers.computation()).subscribe(ts);
+        ts.awaitTerminalEvent(1000, TimeUnit.MILLISECONDS);
+        ts.assertTerminalEvent();
+    }
+    
+    @Test
+    public void testOnError() {
+        TestSubscriber<String> ts = new TestSubscriber<String>();
+        Observable.create(new OnSubscribe<String>() {
+
+            @Override
+            public void call(Subscriber<? super String> s) {
+                s.onError(new RuntimeException("fail"));
+            }
+
+        }).subscribeOn(Schedulers.computation()).subscribe(ts);
+        ts.awaitTerminalEvent(1000, TimeUnit.MILLISECONDS);
+        ts.assertTerminalEvent();
+    }
 
     public static class SlowScheduler extends Scheduler {
         final Scheduler actual;

From 12723ef05410dc32ab2461be97a23fb9949910b8 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Thu, 24 Apr 2014 19:55:02 -0700
Subject: [PATCH 276/422] Reconnecting ObservableExecutionHook.onCreate

Somehow this got lost in the refactorings over the past few weeks.
---
 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 e017088b2a..746362ca78 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -174,7 +174,7 @@ protected Observable(OnSubscribe<T> f) {
         this.onSubscribe = f;
     }
 
-    private final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
+    private static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
 
     /**
      * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
@@ -201,7 +201,7 @@ protected Observable(OnSubscribe<T> f) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.create.aspx">MSDN: Observable.Create</a>
      */
     public final static <T> Observable<T> create(OnSubscribe<T> f) {
-        return new Observable<T>(f);
+        return new Observable<T>(hook.onCreate(f));
     }
 
     /**

From 5f1743572d6d5257ecb3498c68357e833c56aaa1 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Fri, 25 Apr 2014 03:14:53 +0000
Subject: [PATCH 277/422] [Gradle Release Plugin] - pre tag commit:  '0.18.1'.

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

diff --git a/gradle.properties b/gradle.properties
index b059c1d77c..0d7beedff4 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.1-SNAPSHOT
+version=0.18.1

From cc85f0e775fbc961e123224a30875048bfc9ae5d Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Fri, 25 Apr 2014 03:14:57 +0000
Subject: [PATCH 278/422] [Gradle Release Plugin] - new version commit: 
 '0.18.2-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index 0d7beedff4..ba85b03230 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.1
+version=0.18.2-SNAPSHOT

From 12e5512b035a41995313e46db6fd6aded6987a4c Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Thu, 24 Apr 2014 20:25:41 -0700
Subject: [PATCH 279/422] 0.18.1

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

diff --git a/CHANGES.md b/CHANGES.md
index 523f7b2130..f68da5287a 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,24 @@
 # RxJava Releases #
 
+### Version 0.18.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.1%22)) ###
+
+* [Pull 1065] (https://github.com/Netflix/RxJava/pull/1065] Optimize OperatorSkipLastTimed
+* [Pull 1073] (https://github.com/Netflix/RxJava/pull/1073] OperatorBuffer
+* [Pull 1074] (https://github.com/Netflix/RxJava/pull/1074] OperatorConcat
+* [Pull 1088] (https://github.com/Netflix/RxJava/pull/1088] OperatorToObservableFuture
+* [Pull 1087] (https://github.com/Netflix/RxJava/pull/1087] OperatorMergeMap
+* [Pull 1086] (https://github.com/Netflix/RxJava/pull/1086] OperatorFinallyDo
+* [Pull 1085] (https://github.com/Netflix/RxJava/pull/1085] OperatorDistinctUntilChanged
+* [Pull 1084] (https://github.com/Netflix/RxJava/pull/1084] OperatorDistinct
+* [Pull 1083] (https://github.com/Netflix/RxJava/pull/1083] OperatorDematerialize
+* [Pull 1081] (https://github.com/Netflix/RxJava/pull/1081] OperatorDefer
+* [Pull 1080] (https://github.com/Netflix/RxJava/pull/1080] OperatorDefaultIfEmpty
+* [Pull 1079] (https://github.com/Netflix/RxJava/pull/1079] OperatorCombineLatest
+* [Pull 1074] (https://github.com/Netflix/RxJava/pull/1074] OperatorConcat
+* [Pull 1073] (https://github.com/Netflix/RxJava/pull/1073] OperatorBuffer
+* [Pull 1091] (https://github.com/Netflix/RxJava/pull/1091] Handle Thrown Errors with UnsafeSubscribe
+* [Pull 1092] (https://github.com/Netflix/RxJava/pull/1092] Restore ObservableExecutionHook.onCreate
+
 ### Version 0.18.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.0%22)) ###
 
 This release takes us a step closer to [1.0](https://github.com/Netflix/RxJava/issues/1001) by completing some of the remaining work on the roadmap.

From 95e0636fca782d0773375429922bc1fb3bf6b7b4 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Thu, 24 Apr 2014 20:26:55 -0700
Subject: [PATCH 280/422] 0.18.1

---
 CHANGES.md | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index f68da5287a..fa5ddaccb6 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -2,22 +2,22 @@
 
 ### Version 0.18.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.1%22)) ###
 
-* [Pull 1065] (https://github.com/Netflix/RxJava/pull/1065] Optimize OperatorSkipLastTimed
-* [Pull 1073] (https://github.com/Netflix/RxJava/pull/1073] OperatorBuffer
-* [Pull 1074] (https://github.com/Netflix/RxJava/pull/1074] OperatorConcat
-* [Pull 1088] (https://github.com/Netflix/RxJava/pull/1088] OperatorToObservableFuture
-* [Pull 1087] (https://github.com/Netflix/RxJava/pull/1087] OperatorMergeMap
-* [Pull 1086] (https://github.com/Netflix/RxJava/pull/1086] OperatorFinallyDo
-* [Pull 1085] (https://github.com/Netflix/RxJava/pull/1085] OperatorDistinctUntilChanged
-* [Pull 1084] (https://github.com/Netflix/RxJava/pull/1084] OperatorDistinct
-* [Pull 1083] (https://github.com/Netflix/RxJava/pull/1083] OperatorDematerialize
-* [Pull 1081] (https://github.com/Netflix/RxJava/pull/1081] OperatorDefer
-* [Pull 1080] (https://github.com/Netflix/RxJava/pull/1080] OperatorDefaultIfEmpty
-* [Pull 1079] (https://github.com/Netflix/RxJava/pull/1079] OperatorCombineLatest
-* [Pull 1074] (https://github.com/Netflix/RxJava/pull/1074] OperatorConcat
-* [Pull 1073] (https://github.com/Netflix/RxJava/pull/1073] OperatorBuffer
-* [Pull 1091] (https://github.com/Netflix/RxJava/pull/1091] Handle Thrown Errors with UnsafeSubscribe
-* [Pull 1092] (https://github.com/Netflix/RxJava/pull/1092] Restore ObservableExecutionHook.onCreate
+* [Pull 1065] (https://github.com/Netflix/RxJava/pull/1065) Optimize OperatorSkipLastTimed
+* [Pull 1073] (https://github.com/Netflix/RxJava/pull/1073) OperatorBuffer
+* [Pull 1074] (https://github.com/Netflix/RxJava/pull/1074) OperatorConcat
+* [Pull 1088] (https://github.com/Netflix/RxJava/pull/1088) OperatorToObservableFuture
+* [Pull 1087] (https://github.com/Netflix/RxJava/pull/1087) OperatorMergeMap
+* [Pull 1086] (https://github.com/Netflix/RxJava/pull/1086) OperatorFinallyDo
+* [Pull 1085] (https://github.com/Netflix/RxJava/pull/1085) OperatorDistinctUntilChanged
+* [Pull 1084] (https://github.com/Netflix/RxJava/pull/1084) OperatorDistinct
+* [Pull 1083] (https://github.com/Netflix/RxJava/pull/1083) OperatorDematerialize
+* [Pull 1081] (https://github.com/Netflix/RxJava/pull/1081) OperatorDefer
+* [Pull 1080] (https://github.com/Netflix/RxJava/pull/1080) OperatorDefaultIfEmpty
+* [Pull 1079] (https://github.com/Netflix/RxJava/pull/1079) OperatorCombineLatest
+* [Pull 1074] (https://github.com/Netflix/RxJava/pull/1074) OperatorConcat
+* [Pull 1073] (https://github.com/Netflix/RxJava/pull/1073) OperatorBuffer
+* [Pull 1091] (https://github.com/Netflix/RxJava/pull/1091) Handle Thrown Errors with UnsafeSubscribe
+* [Pull 1092] (https://github.com/Netflix/RxJava/pull/1092) Restore ObservableExecutionHook.onCreate
 
 ### Version 0.18.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.0%22)) ###
 

From d726e5cfed5668e724b9fd30bec87c28120c16c9 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 25 Apr 2014 09:53:41 +0200
Subject: [PATCH 281/422] OperatorDebounce

---
 rxjava-core/src/main/java/rx/Observable.java  |  13 +-
 .../java/rx/operators/OperationDebounce.java  | 318 ------------------
 .../OperatorDebounceWithSelector.java         | 100 ++++++
 .../operators/OperatorDebounceWithTime.java   | 184 ++++++++++
 ...nceTest.java => OperatorDebounceTest.java} |  55 ++-
 5 files changed, 341 insertions(+), 329 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationDebounce.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDebounceWithSelector.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java
 rename rxjava-core/src/test/java/rx/operators/{OperationDebounceTest.java => OperatorDebounceTest.java} (84%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..aaf61a942d 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -48,7 +48,6 @@
 import rx.observers.SafeSubscriber;
 import rx.operators.OnSubscribeFromIterable;
 import rx.operators.OnSubscribeRange;
-import rx.operators.OperationDebounce;
 import rx.operators.OperationDelay;
 import rx.operators.OperationGroupByUntil;
 import rx.operators.OperationGroupJoin;
@@ -90,6 +89,8 @@
 import rx.operators.OperatorCast;
 import rx.operators.OperatorCombineLatest;
 import rx.operators.OperatorConcat;
+import rx.operators.OperatorDebounceWithSelector;
+import rx.operators.OperatorDebounceWithTime;
 import rx.operators.OperatorDefaultIfEmpty;
 import rx.operators.OperatorDefer;
 import rx.operators.OperatorDematerialize;
@@ -3378,7 +3379,7 @@ public final Integer call(Integer t1, T t2) {
      *         within a computed debounce duration
      */
     public final <U> Observable<T> debounce(Func1<? super T, ? extends Observable<U>> debounceSelector) {
-        return create(OperationDebounce.debounceSelector(this, debounceSelector));
+        return lift(new OperatorDebounceWithSelector<T, U>(debounceSelector));
     }
 
     /**
@@ -3410,7 +3411,7 @@ public final <U> Observable<T> debounce(Func1<? super T, ? extends Observable<U>
      * @see #throttleWithTimeout(long, TimeUnit)
      */
     public final Observable<T> debounce(long timeout, TimeUnit unit) {
-        return create(OperationDebounce.debounce(this, timeout, unit));
+        return lift(new OperatorDebounceWithTime<T>(timeout, unit, Schedulers.computation()));
     }
 
     /**
@@ -3445,7 +3446,7 @@ public final Observable<T> debounce(long timeout, TimeUnit unit) {
      * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
      */
     public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationDebounce.debounce(this, timeout, unit, scheduler));
+        return lift(new OperatorDebounceWithTime<T>(timeout, unit, scheduler));
     }
 
     /**
@@ -6831,7 +6832,7 @@ public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit, Sc
      * @see #debounce(long, TimeUnit)
      */
     public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
-        return create(OperationDebounce.debounce(this, timeout, unit));
+        return debounce(timeout, unit);
     }
 
     /**
@@ -6866,7 +6867,7 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
      * @see #debounce(long, TimeUnit, Scheduler)
      */
     public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationDebounce.debounce(this, timeout, unit, scheduler));
+        return debounce(timeout, unit, scheduler);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java b/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
deleted file mode 100644
index 6b112cc7f9..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationDebounce.java
+++ /dev/null
@@ -1,318 +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.atomic.AtomicReference;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Func1;
-import rx.observers.SerializedObserver;
-import rx.schedulers.Schedulers;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-
-/**
- * This operation is used to filter out bursts of events. This is done by ignoring the events from an observable which are too
- * quickly followed up with other values. Values which are not followed up by other values within the specified timeout are published
- * as soon as the timeout expires.
- */
-public final class OperationDebounce {
-
-    /**
-     * This operation filters out events which are published too quickly in succession. This is done by dropping events which are
-     * followed up by other events before a specified timer has expired. If the timer expires and no follow up event was published (yet)
-     * the last received event is published.
-     * 
-     * @param items
-     *            The {@link Observable} which is publishing events.
-     * @param timeout
-     *            How long each event has to be the 'last event' before it gets published.
-     * @param unit
-     *            The unit of time for the specified timeout.
-     * @return A {@link Func1} which performs the throttle operation.
-     */
-    public static <T> OnSubscribeFunc<T> debounce(Observable<T> items, long timeout, TimeUnit unit) {
-        return debounce(items, timeout, unit, Schedulers.computation());
-    }
-
-    /**
-     * This operation filters out events which are published too quickly in succession. This is done by dropping events which are
-     * followed up by other events before a specified timer has expired. If the timer expires and no follow up event was published (yet)
-     * the last received event is published.
-     * 
-     * @param items
-     *            The {@link Observable} which is publishing events.
-     * @param timeout
-     *            How long each event has to be the 'last event' before it gets published.
-     * @param unit
-     *            The unit of time for the specified timeout.
-     * @param scheduler
-     *            The {@link Scheduler} to use internally to manage the timers which handle timeout for each event.
-     * @return A {@link Func1} which performs the throttle operation.
-     */
-    public static <T> OnSubscribeFunc<T> debounce(final Observable<T> items, final long timeout, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<T>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new Debounce<T>(items, timeout, unit, scheduler).onSubscribe(observer);
-            }
-        };
-    }
-
-    private static class Debounce<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<T> items;
-        private final long timeout;
-        private final TimeUnit unit;
-        private final Scheduler scheduler;
-
-        public Debounce(Observable<T> items, long timeout, TimeUnit unit, Scheduler scheduler) {
-            this.items = items;
-            this.timeout = timeout;
-            this.unit = unit;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            return items.unsafeSubscribe(new DebounceObserver<T>(observer, timeout, unit, scheduler));
-        }
-    }
-
-    private static class DebounceObserver<T> extends Subscriber<T> {
-
-        private final Observer<? super T> observer;
-        private final long timeout;
-        private final TimeUnit unit;
-        private final Scheduler.Worker scheduler;
-
-        private final AtomicReference<Subscription> lastScheduledNotification = new AtomicReference<Subscription>();
-
-        public DebounceObserver(Observer<? super T> observer, long timeout, TimeUnit unit, Scheduler scheduler) {
-            // we need to synchronize the observer since the on* events can be coming from different
-            // threads and are thus non-deterministic and could be interleaved
-            this.observer = new SerializedObserver<T>(observer);
-            this.timeout = timeout;
-            this.unit = unit;
-            this.scheduler = scheduler.createWorker();
-        }
-
-        @Override
-        public void onCompleted() {
-            /*
-             * Cancel previous subscription if it has not already executed.
-             * Expected that some race-condition will occur as this is crossing over thread boundaries
-             * We are using SynchronizedObserver around 'observer' to handle interleaving and out-of-order calls.
-             */
-            lastScheduledNotification.get().unsubscribe();
-            observer.onCompleted();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            /*
-             * Cancel previous subscription if it has not already executed.
-             * Expected that some race-condition will occur as this is crossing over thread boundaries
-             * We are using SynchronizedObserver around 'observer' to handle interleaving and out-of-order calls.
-             */
-            lastScheduledNotification.get().unsubscribe();
-            observer.onError(e);
-        }
-
-        @Override
-        public void onNext(final T v) {
-            Subscription previousSubscription = lastScheduledNotification.getAndSet(scheduler.schedule(new Action0() {
-
-                @Override
-                public void call() {
-                    observer.onNext(v);
-                }
-
-            }, timeout, unit));
-
-            // cancel previous if not already executed
-            if (previousSubscription != null) {
-                previousSubscription.unsubscribe();
-            }
-        }
-    }
-
-    /**
-     * Delay the emission via another observable if no new source appears in the meantime.
-     */
-    public static <T, U> OnSubscribeFunc<T> debounceSelector(
-            Observable<? extends T> source,
-            Func1<? super T, ? extends Observable<U>> debounceSelector) {
-        return new DebounceSelector<T, U>(source, debounceSelector);
-    }
-
-    /**
-     * Delay the emission via another observable if no new source appears in the meantime.
-     */
-    private static final class DebounceSelector<T, U> implements OnSubscribeFunc<T> {
-        final Observable<? extends T> source;
-        final Func1<? super T, ? extends Observable<U>> debounceSelector;
-
-        public DebounceSelector(Observable<? extends T> source, Func1<? super T, ? extends Observable<U>> debounceSelector) {
-            this.source = source;
-            this.debounceSelector = debounceSelector;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            csub.add(source.unsafeSubscribe(new SourceObserver<T, U>(t1, debounceSelector, csub)));
-
-            return csub;
-        }
-
-        /** Observe the source. */
-        private static final class SourceObserver<T, U> extends Subscriber<T> {
-            final Observer<? super T> observer;
-            final Func1<? super T, ? extends Observable<U>> debounceSelector;
-            final CompositeSubscription cancel;
-            final SerialSubscription ssub = new SerialSubscription();
-            long index;
-            T value;
-            boolean hasValue;
-            final Object guard;
-
-            public SourceObserver(
-                    Observer<? super T> observer,
-                    Func1<? super T, ? extends Observable<U>> 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<U> 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.unsafeSubscribe(new DebounceObserver<T, U>(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<T, U> extends Subscriber<U> {
-            final SourceObserver<T, U> parent;
-            final Subscription cancel;
-            final T value;
-            final long currentIndex;
-
-            public DebounceObserver(SourceObserver<T, U> 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/main/java/rx/operators/OperatorDebounceWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithSelector.java
new file mode 100644
index 0000000000..cfdf5af7f1
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithSelector.java
@@ -0,0 +1,100 @@
+/**
+ * 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.functions.Func1;
+import rx.observers.SerializedSubscriber;
+import rx.operators.OperatorDebounceWithTime.DebounceState;
+import rx.subscriptions.SerialSubscription;
+
+/**
+ * Delay the emission via another observable if no new source appears in the meantime.
+ * 
+ * @param <T> the value type of the main sequence
+ * @param <U> the value type of the boundary sequence
+ */
+public final class OperatorDebounceWithSelector<T, U> implements Operator<T, T> {
+    final Func1<? super T, ? extends Observable<U>> selector;
+    
+    public OperatorDebounceWithSelector(Func1<? super T, ? extends Observable<U>> selector) {
+        this.selector = selector;
+    }
+    
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final SerialSubscription ssub = new SerialSubscription();
+        child.add(ssub);
+        
+        return new Subscriber<T>(child) {
+            final DebounceState<T> state = new DebounceState<T>();
+            final Subscriber<?> self = this;
+            @Override
+            public void onNext(T t) {
+                Observable<U> debouncer;
+                
+                try {
+                    debouncer = selector.call(t);
+                } catch (Throwable e) {
+                    onError(e);
+                    return;
+                }
+                
+                
+                final int index = state.next(t);
+                
+                Subscriber<U> debounceSubscriber = new Subscriber<U>() {
+
+                    @Override
+                    public void onNext(U t) {
+                        onCompleted();
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        self.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        state.emit(index, s, self);
+                        unsubscribe();
+                    }
+                };
+                ssub.set(debounceSubscriber);
+                
+                debouncer.unsafeSubscribe(debounceSubscriber);
+                
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+                state.clear();
+            }
+
+            @Override
+            public void onCompleted() {
+                state.emitAndComplete(s, this);
+            }
+        };
+    }
+    
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java b/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java
new file mode 100644
index 0000000000..a67f480a3c
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java
@@ -0,0 +1,184 @@
+/**
+ * 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.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.SerialSubscription;
+
+/**
+ * This operation filters out events which are published too quickly in succession. This is done by dropping events which are
+ * followed up by other events before a specified timer has expired. If the timer expires and no follow up event was published (yet)
+ * the last received event is published.
+ *
+ * @param <T> the value type
+ */
+public final class OperatorDebounceWithTime<T> implements Operator<T, T> {
+    final long timeout;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+    /**
+     * @param timeout
+     *            How long each event has to be the 'last event' before it gets published.
+     * @param unit
+     *            The unit of time for the specified timeout.
+     * @param scheduler
+     *            The {@link Scheduler} to use internally to manage the timers which handle timeout for each event.
+     *
+     */
+    public OperatorDebounceWithTime(long timeout, TimeUnit unit, Scheduler scheduler) {
+        this.timeout = timeout;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+    
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        final Worker worker = scheduler.createWorker();
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final SerialSubscription ssub = new SerialSubscription();
+        
+        s.add(worker);
+        s.add(ssub);
+        
+        return new Subscriber<T>(child) {
+            final DebounceState<T> state = new DebounceState<T>();
+            final Subscriber<?> self = this;
+            @Override
+            public void onNext(final T t) {
+                
+                final int index = state.next(t);
+                ssub.set(worker.schedule(new Action0() {
+                    @Override
+                    public void call() {
+                        state.emit(index, s, self);
+                    }
+                }, timeout, unit));
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+                state.clear();
+            }
+            
+            @Override
+            public void onCompleted() {
+                state.emitAndComplete(s, this);
+            }
+        };
+    }
+    /**
+     * Tracks the last value to be emitted and manages completion.
+     * @param <T> the value type
+     */
+    static final class DebounceState<T> {
+        /** Guarded by this. */
+        int index;
+        /** Guarded by this. */
+        T value;
+        /** Guarded by this. */
+        boolean hasValue;
+        /** Guarded by this. */
+        boolean terminate;
+        /** Guarded by this. */
+        boolean emitting;
+        
+        public synchronized int next(T value) {
+            this.value = value;
+            this.hasValue = true;
+            return ++index;
+        }
+        public void emit(int index, Subscriber<T> onNextAndComplete, Subscriber<?> onError) {
+            T localValue;
+            boolean localHasValue;
+            boolean localTerminate;
+            synchronized (this) {
+                if (emitting || !hasValue || index != this.index) {
+                    return;
+                }
+                localValue = value;
+                localHasValue = hasValue;
+                localTerminate = terminate;
+                
+                value = null;
+                hasValue = false;
+                emitting = true;
+            }
+
+            if  (localHasValue) {
+                try {
+                    onNextAndComplete.onNext(localValue);
+                } catch (Throwable e) {
+                    onError.onError(e);
+                    return;
+                }
+            }
+            if (localTerminate) {
+                onNextAndComplete.onCompleted();
+                return;
+            }
+
+            synchronized (this) {
+                if (!terminate) {
+                    emitting = false;
+                    return;
+                }
+            }
+            
+            onNextAndComplete.onCompleted();
+        }
+        public void emitAndComplete(Subscriber<T> onNextAndComplete, Subscriber<?> onError) {
+            T localValue;
+            boolean localHasValue;
+            
+            synchronized (this) {
+                if (emitting) {
+                    terminate = true;
+                    return;
+                }
+                localValue = value;
+                localHasValue = hasValue;
+                
+                value = null;
+                hasValue = false;
+
+                emitting = true;
+            }
+
+            if  (localHasValue) {
+                try {
+                    onNextAndComplete.onNext(localValue);
+                } catch (Throwable e) {
+                    onError.onError(e);
+                    return;
+                }
+            }
+            onNextAndComplete.onCompleted();
+        }
+        public synchronized void clear() {
+            ++index;
+            value = null;
+            hasValue = false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDebounceTest.java
similarity index 84%
rename from rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorDebounceTest.java
index 7cf989a02a..3f4785c779 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDebounceTest.java
@@ -39,7 +39,7 @@
 import rx.subjects.PublishSubject;
 import rx.subscriptions.Subscriptions;
 
-public class OperationDebounceTest {
+public class OperatorDebounceTest {
 
     private TestScheduler scheduler;
     private Observer<String> observer;
@@ -67,7 +67,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationDebounce.debounce(source, 400, TimeUnit.MILLISECONDS, scheduler));
+        Observable<String> sampled = source.debounce(400, TimeUnit.MILLISECONDS, scheduler);
         sampled.subscribe(observer);
 
         scheduler.advanceTimeTo(0, TimeUnit.MILLISECONDS);
@@ -100,7 +100,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationDebounce.debounce(source, 200, TimeUnit.MILLISECONDS, scheduler));
+        Observable<String> sampled = source.debounce(200, TimeUnit.MILLISECONDS, scheduler);
         sampled.subscribe(observer);
 
         scheduler.advanceTimeTo(0, TimeUnit.MILLISECONDS);
@@ -125,7 +125,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationDebounce.debounce(source, 400, TimeUnit.MILLISECONDS, scheduler));
+        Observable<String> sampled = source.debounce(400, TimeUnit.MILLISECONDS, scheduler);
         sampled.subscribe(observer);
 
         scheduler.advanceTimeTo(0, TimeUnit.MILLISECONDS);
@@ -252,4 +252,49 @@ public Observable<Integer> call(Integer t1) {
         verify(o, never()).onCompleted();
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
-}
+    @Test
+    public void debounceTimedLastIsNotLost() {
+        PublishSubject<Integer> source = PublishSubject.create();
+        
+        @SuppressWarnings("unchecked")
+        Observer<Object> o = mock(Observer.class);
+
+        source.debounce(100, TimeUnit.MILLISECONDS, scheduler).subscribe(o);
+        
+        source.onNext(1);
+        source.onCompleted();
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        verify(o).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void debounceSelectorLastIsNotLost() {
+        PublishSubject<Integer> source = PublishSubject.create();
+        final PublishSubject<Integer> debouncer = PublishSubject.create();
+
+        Func1<Integer, Observable<Integer>> debounceSel = new Func1<Integer, Observable<Integer>>() {
+
+            @Override
+            public Observable<Integer> call(Integer t1) {
+                return debouncer;
+            }
+        };
+
+        @SuppressWarnings("unchecked")
+        Observer<Object> o = mock(Observer.class);
+
+        source.debounce(debounceSel).subscribe(o);
+        
+        source.onNext(1);
+        source.onCompleted();
+
+        debouncer.onCompleted();
+
+        verify(o).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+}
\ No newline at end of file

From 45d0eaf5de974fb89d5132679cc34d10d92dbdca Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 25 Apr 2014 10:03:41 +0200
Subject: [PATCH 282/422] Removed localTerminate as it is never observed as
 true at that point.

---
 .../main/java/rx/operators/OperatorDebounceWithTime.java   | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java b/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java
index a67f480a3c..b1b5b6f9e9 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDebounceWithTime.java
@@ -111,14 +111,12 @@ public synchronized int next(T value) {
         public void emit(int index, Subscriber<T> onNextAndComplete, Subscriber<?> onError) {
             T localValue;
             boolean localHasValue;
-            boolean localTerminate;
             synchronized (this) {
                 if (emitting || !hasValue || index != this.index) {
                     return;
                 }
                 localValue = value;
                 localHasValue = hasValue;
-                localTerminate = terminate;
                 
                 value = null;
                 hasValue = false;
@@ -133,11 +131,8 @@ public void emit(int index, Subscriber<T> onNextAndComplete, Subscriber<?> onErr
                     return;
                 }
             }
-            if (localTerminate) {
-                onNextAndComplete.onCompleted();
-                return;
-            }
 
+            // Check if a termination was requested in the meantime.
             synchronized (this) {
                 if (!terminate) {
                     emitting = false;

From f4955b048cde8d782617d79231ebc08bd0f92b26 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 25 Apr 2014 10:49:10 +0200
Subject: [PATCH 283/422] OperatorGroupByUntil

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../rx/operators/OperationGroupByUntil.java   | 246 ------------------
 .../rx/operators/OperatorGroupByUntil.java    | 239 +++++++++++++++++
 ...est.java => OperatorGroupByUntilTest.java} |   2 +-
 4 files changed, 242 insertions(+), 249 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorGroupByUntil.java
 rename rxjava-core/src/test/java/rx/operators/{OperationGroupByUntilTest.java => OperatorGroupByUntilTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..0ffc8fc3e4 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -50,7 +50,7 @@
 import rx.operators.OnSubscribeRange;
 import rx.operators.OperationDebounce;
 import rx.operators.OperationDelay;
-import rx.operators.OperationGroupByUntil;
+import rx.operators.OperatorGroupByUntil;
 import rx.operators.OperationGroupJoin;
 import rx.operators.OperationInterval;
 import rx.operators.OperationJoin;
@@ -4081,7 +4081,7 @@ public final <TKey, TDuration> Observable<GroupedObservable<TKey, T>> groupByUnt
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229433.aspx">MSDN: Observable.GroupByUntil</a>
      */
     public final <TKey, TValue, TDuration> Observable<GroupedObservable<TKey, TValue>> groupByUntil(Func1<? super T, ? extends TKey> keySelector, Func1<? super T, ? extends TValue> valueSelector, Func1<? super GroupedObservable<TKey, TValue>, ? extends Observable<? extends TDuration>> durationSelector) {
-        return create(new OperationGroupByUntil<T, TKey, TValue, TDuration>(this, keySelector, valueSelector, durationSelector));
+        return lift(new OperatorGroupByUntil<T, TKey, TValue, TDuration>(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
deleted file mode 100644
index 4875bfd9c4..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupByUntil.java
+++ /dev/null
@@ -1,246 +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.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import rx.Observable;
-import rx.Observable.OnSubscribe;
-import rx.Observable.OnSubscribeFunc;
-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;
-
-/**
- * Groups the elements of an observable sequence according to a specified key selector, value selector and duration selector function.
- * 
- * @see <a href='http://msdn.microsoft.com/en-us/library/hh211932.aspx'>MSDN: Observable.GroupByUntil</a>
- * @see <a href='http://msdn.microsoft.com/en-us/library/hh229433.aspx'>MSDN: Observable.GroupByUntil</a>
- */
-public class OperationGroupByUntil<TSource, TKey, TResult, TDuration> implements OnSubscribeFunc<GroupedObservable<TKey, TResult>> {
-    final Observable<TSource> source;
-    final Func1<? super TSource, ? extends TKey> keySelector;
-    final Func1<? super TSource, ? extends TResult> valueSelector;
-    final Func1<? super GroupedObservable<TKey, TResult>, ? extends Observable<? extends TDuration>> durationSelector;
-
-    public OperationGroupByUntil(Observable<TSource> source,
-            Func1<? super TSource, ? extends TKey> keySelector,
-            Func1<? super TSource, ? extends TResult> valueSelector,
-            Func1<? super GroupedObservable<TKey, TResult>, ? extends Observable<? extends TDuration>> durationSelector) {
-        this.source = source;
-        this.keySelector = keySelector;
-        this.valueSelector = valueSelector;
-        this.durationSelector = durationSelector;
-    }
-
-    @Override
-    public Subscription onSubscribe(Observer<? super GroupedObservable<TKey, TResult>> t1) {
-        SerialSubscription cancel = new SerialSubscription();
-        ResultSink sink = new ResultSink(t1, cancel);
-        cancel.set(sink.run());
-        return cancel;
-    }
-
-    /** The source value sink and group manager. */
-    class ResultSink extends Subscriber<TSource> {
-        /** Guarded by gate. */
-        protected final Observer<? super GroupedObservable<TKey, TResult>> observer;
-        protected final Subscription cancel;
-        protected final CompositeSubscription group = new CompositeSubscription();
-        protected final Object gate = new Object();
-        /** Guarded by gate. */
-        protected final Map<TKey, GroupSubject<TKey, TResult>> map = new HashMap<TKey, GroupSubject<TKey, TResult>>();
-
-        public ResultSink(Observer<? super GroupedObservable<TKey, TResult>> observer, Subscription cancel) {
-            this.observer = observer;
-            this.cancel = cancel;
-        }
-
-        /** Prepare the subscription tree. */
-        public Subscription run() {
-            SerialSubscription toSource = new SerialSubscription();
-            group.add(toSource);
-
-            toSource.set(source.unsafeSubscribe(this));
-
-            return group;
-        }
-
-        @Override
-        public void onNext(TSource args) {
-            TKey key;
-            TResult value;
-            try {
-                key = keySelector.call(args);
-                value = valueSelector.call(args);
-            } catch (Throwable t) {
-                onError(t);
-                return;
-            }
-
-            GroupSubject<TKey, TResult> g;
-            boolean newGroup = false;
-            synchronized (gate) {
-                g = map.get(key);
-                if (g == null) {
-                    g = create(key);
-                    map.put(key, g);
-                    newGroup = true;
-                }
-            }
-
-            if (newGroup) {
-                Observable<? extends TDuration> duration;
-                try {
-                    duration = durationSelector.call(g.toObservable());
-                } catch (Throwable t) {
-                    onError(t);
-                    return;
-                }
-
-                synchronized (gate) {
-                    observer.onNext(g.toObservable());
-                }
-
-                SerialSubscription durationHandle = new SerialSubscription();
-                group.add(durationHandle);
-
-                DurationObserver durationObserver = new DurationObserver(key, durationHandle);
-                durationHandle.set(duration.unsafeSubscribe(durationObserver));
-
-            }
-
-            synchronized (gate) {
-                g.onNext(value);
-            }
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            synchronized (gate) {
-                List<GroupSubject<TKey, TResult>> gs = new ArrayList<GroupSubject<TKey, TResult>>(map.values());
-                map.clear();
-                for (GroupSubject<TKey, TResult> g : gs) {
-                    g.onError(e);
-                }
-                observer.onError(e);
-            }
-            cancel.unsubscribe();
-        }
-
-        @Override
-        public void onCompleted() {
-            synchronized (gate) {
-                List<GroupSubject<TKey, TResult>> gs = new ArrayList<GroupSubject<TKey, TResult>>(map.values());
-                map.clear();
-                for (GroupSubject<TKey, TResult> g : gs) {
-                    g.onCompleted();
-                }
-                observer.onCompleted();
-            }
-            cancel.unsubscribe();
-        }
-
-        /** Create a new group. */
-        public GroupSubject<TKey, TResult> create(TKey key) {
-            PublishSubject<TResult> publish = PublishSubject.create();
-            return new GroupSubject<TKey, TResult>(key, publish);
-        }
-
-        /** Terminate a group. */
-        public void expire(TKey key, Subscription handle) {
-            synchronized (gate) {
-                GroupSubject<TKey, TResult> g = map.remove(key);
-                if (g != null) {
-                    g.onCompleted();
-                }
-            }
-            handle.unsubscribe();
-        }
-
-        /** Observe the completion of a group. */
-        class DurationObserver extends Subscriber<TDuration> {
-            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);
-            }
-
-        }
-    }
-
-    /** A grouped observable with subject-like behavior. */
-    public static class GroupSubject<K, V> extends Subscriber<V> {
-        protected final Subject<V, V> publish;
-        private final K key;
-
-        public GroupSubject(K key, final Subject<V, V> publish) {
-            this.key = key;
-            this.publish = publish;
-        }
-
-        public GroupedObservable<K, V> toObservable() {
-            return new GroupedObservable<K, V>(key, new OnSubscribe<V>() {
-                @Override
-                public void call(Subscriber<? super V> o) {
-                    publish.unsafeSubscribe(o);
-                }
-            });
-        }
-
-        @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/OperatorGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupByUntil.java
new file mode 100644
index 0000000000..caecd15440
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupByUntil.java
@@ -0,0 +1,239 @@
+/**
+ * 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.HashMap;
+import java.util.List;
+import java.util.Map;
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.functions.Func1;
+import rx.observables.GroupedObservable;
+import rx.observers.SerializedObserver;
+import rx.observers.SerializedSubscriber;
+import rx.subjects.PublishSubject;
+import rx.subjects.Subject;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Groups the elements of an observable sequence according to a specified key selector, value selector and duration selector function.
+ * 
+ * @see <a href='http://msdn.microsoft.com/en-us/library/hh211932.aspx'>MSDN: Observable.GroupByUntil</a>
+ * @see <a href='http://msdn.microsoft.com/en-us/library/hh229433.aspx'>MSDN: Observable.GroupByUntil</a>
+ * 
+ * @param <T> the source value type
+ * @param <K> the group key type
+ * @param <R> the value type of the groups
+ * @param <D> the type of the duration
+ */
+public class OperatorGroupByUntil<T, K, R, D> implements Operator<GroupedObservable<K, R>, T> {
+    final Func1<? super T, ? extends K> keySelector;
+    final Func1<? super T, ? extends R> valueSelector;
+    final Func1<? super GroupedObservable<K, R>, ? extends Observable<? extends D>> durationSelector;
+
+    public OperatorGroupByUntil(
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends R> valueSelector,
+            Func1<? super GroupedObservable<K, R>, ? extends Observable<? extends D>> durationSelector) {
+        this.keySelector = keySelector;
+        this.valueSelector = valueSelector;
+        this.durationSelector = durationSelector;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super GroupedObservable<K, R>> child) {
+        final SerializedSubscriber<GroupedObservable<K, R>> s = new SerializedSubscriber<GroupedObservable<K, R>>(child);
+        final CompositeSubscription csub = new CompositeSubscription();
+        child.add(csub);
+        
+        return new Subscriber<T>(child) {
+            final Object guard = new Object();
+            /** Guarded by guard. */
+            Map<K, GroupSubject<K, R>> groups = new HashMap<K, GroupSubject<K, R>>();
+            
+            final Subscriber<T> self = this;
+            @Override
+            public void onNext(T t) {
+                K key;
+                R value;
+                try {
+                    key = keySelector.call(t);
+                    value = valueSelector.call(t);
+                } catch (Throwable e) {
+                    onError(e);
+                    return;
+                }
+                
+                GroupSubject<K, R> gs;
+                boolean newGroup = false;
+                synchronized (guard) {
+                    if (groups == null) {
+                        return;
+                    }
+                    gs = groups.get(key);
+                    if (gs == null) {
+                        gs = GroupSubject.create(key);
+                        groups.put(key, gs);
+                        newGroup = true;
+                    }
+                }
+                
+                if (newGroup) {
+                    final GroupedObservable<K, R> groupObs = gs.toObservable();
+                    
+                    Observable<? extends D> durationObs;
+                    try {
+                        durationObs = durationSelector.call(groupObs);
+                    } catch (Throwable e) {
+                        onError(e);
+                        return;
+                    }
+                    
+                    s.onNext(groupObs);
+                    
+                    final K fKey = key;
+                    Subscriber<D> durationSub = new Subscriber<D>() {
+                        boolean once = true;
+                        @Override
+                        public void onNext(D t) {
+                            onCompleted();
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            self.onError(e);
+                        }
+
+                        @Override
+                        public void onCompleted() {
+                            if (once) {
+                                once = false;
+                                expire(fKey, this);
+                            }
+                        }
+                    };
+                    csub.add(durationSub);
+                    
+                    durationObs.unsafeSubscribe(durationSub);
+                }
+                
+                gs.onNext(value);
+            }
+
+            void expire(K key, Subscription subscription) {
+                GroupSubject<K, R> g;
+                synchronized (guard) {
+                    if (groups == null) {
+                        return;
+                    }
+                    g = groups.remove(key);
+                }
+                if (g != null) {
+                    g.onCompleted();
+                }
+                csub.remove(subscription);
+            } 
+            
+            @Override
+            public void onError(Throwable e) {
+                List<GroupSubject<K, R>> localGroups;
+                synchronized (guard) {
+                    if (groups == null) {
+                        return;
+                    }
+                    localGroups = new ArrayList<GroupSubject<K, R>>(groups.values());
+                    groups = null;
+                }
+                for (GroupSubject<K, R> g : localGroups) {
+                    g.onError(e);
+                }
+                s.onError(e);
+                unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                List<GroupSubject<K, R>> localGroups;
+                synchronized (guard) {
+                    if (groups == null) {
+                        return;
+                    }
+                    localGroups = new ArrayList<GroupSubject<K, R>>(groups.values());
+                    groups = null;
+                }
+                for (GroupSubject<K, R> g : localGroups) {
+                    g.onCompleted();
+                }
+                s.onCompleted();
+                unsubscribe();
+            }
+            
+        };
+    }
+
+    /** 
+     * A grouped observable with subject-like behavior. 
+     * @param <K> the key type
+     * @param <R> the value type
+     */
+    public static final class GroupSubject<K, R> extends Subscriber<R> {
+        
+        static <K, R> GroupSubject<K, R> create(K key) {
+            PublishSubject<R> publish = PublishSubject.create();
+            return new GroupSubject<K, R>(key, publish);
+        }
+        
+        final Observable<R> publishObservable;
+        final SerializedObserver<R> publishSerial;
+        final K key;
+
+        public GroupSubject(K key, final Subject<R, R> publish) {
+            this.key = key;
+            this.publishObservable = publish;
+            this.publishSerial = new SerializedObserver<R>(publish);
+        }
+
+        public GroupedObservable<K, R> toObservable() {
+            return new GroupedObservable<K, R>(key, new OnSubscribe<R>() {
+                @Override
+                public void call(Subscriber<? super R> o) {
+                    publishObservable.unsafeSubscribe(o);
+                }
+            });
+        }
+
+        @Override
+        public void onNext(R args) {
+            publishSerial.onNext(args);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            publishSerial.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            publishSerial.onCompleted();
+        }
+
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByUntilTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorGroupByUntilTest.java
index 1d384e7ea0..b21121ecb6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupByUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByUntilTest.java
@@ -42,7 +42,7 @@
 import rx.functions.Functions;
 import rx.observables.GroupedObservable;
 
-public class OperationGroupByUntilTest {
+public class OperatorGroupByUntilTest {
     @Mock
     Observer<Object> observer;
 

From 79c07ee6c8ed9a6a06b21fba8835d067b597dd09 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 25 Apr 2014 11:59:01 +0200
Subject: [PATCH 284/422] OperatorGroupJoin

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 ...nGroupJoin.java => OperatorGroupJoin.java} | 262 ++++++++++--------
 ...inTest.java => OperatorGroupJoinTest.java} |   2 +-
 3 files changed, 147 insertions(+), 121 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationGroupJoin.java => OperatorGroupJoin.java} (54%)
 rename rxjava-core/src/test/java/rx/operators/{OperationGroupJoinTest.java => OperatorGroupJoinTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..b65de8fd67 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.OperationDebounce;
 import rx.operators.OperationDelay;
 import rx.operators.OperationGroupByUntil;
-import rx.operators.OperationGroupJoin;
+import rx.operators.OperatorGroupJoin;
 import rx.operators.OperationInterval;
 import rx.operators.OperationJoin;
 import rx.operators.OperationMergeDelayError;
@@ -4108,7 +4108,7 @@ public final <TKey, TValue, TDuration> Observable<GroupedObservable<TKey, TValue
     public final <T2, D1, D2, R> Observable<R> groupJoin(Observable<T2> right, Func1<? super T, ? extends Observable<D1>> leftDuration,
             Func1<? super T2, ? extends Observable<D2>> rightDuration,
             Func2<? super T, ? super Observable<T2>, ? extends R> resultSelector) {
-        return create(new OperationGroupJoin<T, T2, D1, D2, R>(this, right, leftDuration, rightDuration, resultSelector));
+        return create(new OperatorGroupJoin<T, T2, D1, D2, R>(this, right, leftDuration, rightDuration, resultSelector));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupJoin.java
similarity index 54%
rename from rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
rename to rxjava-core/src/main/java/rx/operators/OperatorGroupJoin.java
index 0abd6e12dd..a2a068f6b3 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationGroupJoin.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupJoin.java
@@ -21,31 +21,37 @@
 import java.util.Map;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.functions.Func2;
+import rx.observers.SerializedObserver;
+import rx.observers.SerializedSubscriber;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.RefCountSubscription;
-import rx.subscriptions.SerialSubscription;
 
 /**
  * Corrrelates two sequences when they overlap and groups the results.
  * 
  * @see <a href="http://msdn.microsoft.com/en-us/library/hh244235.aspx">MSDN: Observable.GroupJoin</a>
+ * @param <T1> the left value type
+ * @param <T2> the right value type
+ * @param <D1> the value type of the left duration
+ * @param <D2> the value type of the right duration
+ * @param <R> the result value type
  */
-public class OperationGroupJoin<T1, T2, D1, D2, R> implements OnSubscribeFunc<R> {
+public final class OperatorGroupJoin<T1, T2, D1, D2, R> implements OnSubscribe<R> {
     protected final Observable<T1> left;
     protected final Observable<T2> right;
     protected final Func1<? super T1, ? extends Observable<D1>> leftDuration;
     protected final Func1<? super T2, ? extends Observable<D2>> rightDuration;
     protected final Func2<? super T1, ? super Observable<T2>, ? extends R> resultSelector;
 
-    public OperationGroupJoin(
+    public OperatorGroupJoin(
             Observable<T1> left,
             Observable<T2> right,
             Func1<? super T1, ? extends Observable<D1>> leftDuration,
@@ -59,41 +65,47 @@ public OperationGroupJoin(
     }
 
     @Override
-    public Subscription onSubscribe(Observer<? super R> t1) {
-        ResultManager ro = new ResultManager(t1);
+    public void call(Subscriber<? super R> child) {
+        ResultManager ro = new ResultManager(new SerializedSubscriber<R>(child));
+        child.add(ro);
         ro.init();
-        return ro;
     }
 
     /** Manages sub-observers and subscriptions. */
-    class ResultManager implements Subscription {
+    final class ResultManager implements Subscription {
         final RefCountSubscription cancel;
-        final Observer<? super R> observer;
+        final Subscriber<? super R> subscriber;
         final CompositeSubscription group;
         final Object guard = new Object();
+        /** Guarded by guard. */
         int leftIds;
+        /** Guarded by guard. */
         int rightIds;
+        /** Guarded by guard. */
         final Map<Integer, Observer<T2>> leftMap = new HashMap<Integer, Observer<T2>>();
+        /** Guarded by guard. */
         final Map<Integer, T2> rightMap = new HashMap<Integer, T2>();
+        /** Guarded by guard. */
         boolean leftDone;
+        /** Guarded by guard. */
         boolean rightDone;
 
-        public ResultManager(Observer<? super R> observer) {
-            this.observer = observer;
+        public ResultManager(Subscriber<? super R> subscriber) {
+            this.subscriber = subscriber;
             this.group = new CompositeSubscription();
             this.cancel = new RefCountSubscription(group);
         }
 
         public void init() {
-            SerialSubscription s1 = new SerialSubscription();
-            SerialSubscription s2 = new SerialSubscription();
 
+            Subscriber<T1> s1 = new LeftObserver();
+            Subscriber<T2> s2 = new RightObserver();
+            
             group.add(s1);
             group.add(s2);
 
-            s1.set(left.unsafeSubscribe(new LeftObserver(s1)));
-            s2.set(right.unsafeSubscribe(new RightObserver(s2)));
-
+            left.unsafeSubscribe(s1);
+            right.unsafeSubscribe(s2);
         }
 
         @Override
@@ -105,51 +117,80 @@ public void unsubscribe() {
         public boolean isUnsubscribed() {
             return cancel.isUnsubscribed();
         }
-
-        void groupsOnCompleted() {
-            List<Observer<T2>> list = new ArrayList<Observer<T2>>(leftMap.values());
-            leftMap.clear();
-            rightMap.clear();
+        /**
+         * Notify everyone and cleanup.
+         * @param e the exception
+         */
+        void errorAll(Throwable e) {
+            List<Observer<T2>> list;
+            synchronized (guard) {
+                list = new ArrayList<Observer<T2>>(leftMap.values());
+                leftMap.clear();
+                rightMap.clear();
+            }
             for (Observer<T2> o : list) {
-                o.onCompleted();
+                o.onError(e);
             }
+            subscriber.onError(e);
+            cancel.unsubscribe();
         }
-
-        /** Observe the left source. */
-        class LeftObserver extends Subscriber<T1> {
-            final Subscription tosource;
-
-            public LeftObserver(Subscription tosource) {
-                this.tosource = tosource;
+        /**
+         * Notify only the main subscriber and cleanup.
+         * @param e  the exception
+         */
+        void errorMain(Throwable e) {
+            synchronized (guard) {
+                leftMap.clear();
+                rightMap.clear();
+            }            
+            subscriber.onError(e);
+            cancel.unsubscribe();
+        }
+        void complete(List<Observer<T2>> list) {
+            if (list != null) {
+                for (Observer<T2> o : list) {
+                    o.onCompleted();
+                }
+                subscriber.onCompleted();
+                cancel.unsubscribe();
             }
-
+        }
+        
+        /** Observe the left source. */
+        final class LeftObserver extends Subscriber<T1> {
             @Override
             public void onNext(T1 args) {
                 try {
                     int id;
                     Subject<T2, T2> subj = PublishSubject.create();
+                    Observer<T2> subjSerial = new SerializedObserver<T2>(subj);
+                    
                     synchronized (guard) {
                         id = leftIds++;
-                        leftMap.put(id, subj);
+                        leftMap.put(id, subjSerial);
                     }
 
                     Observable<T2> window = Observable.create(new WindowObservableFunc<T2>(subj, cancel));
 
                     Observable<D1> duration = leftDuration.call(args);
 
-                    SerialSubscription sduration = new SerialSubscription();
-                    group.add(sduration);
-                    sduration.set(duration.unsafeSubscribe(new LeftDurationObserver(id, sduration, subj)));
+                    Subscriber<D1> d1 = new LeftDurationObserver(id);
+                    group.add(d1);
+                    duration.unsafeSubscribe(d1);
 
                     R result = resultSelector.call(args, window);
 
+                    List<T2> rightMapValues;
                     synchronized (guard) {
-                        observer.onNext(result);
-                        for (T2 t2 : rightMap.values()) {
-                            subj.onNext(t2);
-
-                        }
+                        rightMapValues = new ArrayList<T2>(rightMap.values());
                     }
+                    
+                    subscriber.onNext(result);
+                    for (T2 t2 : rightMapValues) {
+                        subjSerial.onNext(t2);
+                    }
+                    
+                    
                 } catch (Throwable t) {
                     onError(t);
                 }
@@ -157,37 +198,27 @@ public void onNext(T1 args) {
 
             @Override
             public void onCompleted() {
+                List<Observer<T2>> list = null;
                 synchronized (guard) {
                     leftDone = true;
                     if (rightDone) {
-                        groupsOnCompleted();
-                        observer.onCompleted();
-                        cancel.unsubscribe();
+                        list = new ArrayList<Observer<T2>>(leftMap.values());
+                        leftMap.clear();
+                        rightMap.clear();
                     }
                 }
+                complete(list);
             }
 
             @Override
             public void onError(Throwable e) {
-                synchronized (guard) {
-                    for (Observer<T2> o : leftMap.values()) {
-                        o.onError(e);
-                    }
-                    observer.onError(e);
-                    cancel.unsubscribe();
-                }
+                errorAll(e);
             }
 
         }
 
         /** Observe the right source. */
-        class RightObserver extends Subscriber<T2> {
-            final Subscription tosource;
-
-            public RightObserver(Subscription tosource) {
-                this.tosource = tosource;
-            }
-
+        final class RightObserver extends Subscriber<T2> {
             @Override
             public void onNext(T2 args) {
                 try {
@@ -198,14 +229,17 @@ public void onNext(T2 args) {
                     }
                     Observable<D2> duration = rightDuration.call(args);
 
-                    SerialSubscription sduration = new SerialSubscription();
-                    group.add(sduration);
-                    sduration.set(duration.unsafeSubscribe(new RightDurationObserver(id, sduration)));
+                    Subscriber<D2> d2 = new RightDurationObserver(id);
+                    
+                    group.add(d2);
+                    duration.unsafeSubscribe(d2);
 
+                    List<Observer<T2>> list;
                     synchronized (guard) {
-                        for (Observer<T2> o : leftMap.values()) {
-                            o.onNext(args);
-                        }
+                        list = new ArrayList<Observer<T2>>(leftMap.values());
+                    }
+                    for (Observer<T2> o : list) {
+                        o.onNext(args);
                     }
                 } catch (Throwable t) {
                     onError(t);
@@ -214,58 +248,51 @@ public void onNext(T2 args) {
 
             @Override
             public void onCompleted() {
-                //                tosource.unsubscribe();
+                List<Observer<T2>> list = null;
                 synchronized (guard) {
                     rightDone = true;
                     if (leftDone) {
-                        groupsOnCompleted();
-                        observer.onCompleted();
-                        cancel.unsubscribe();
+                        list = new ArrayList<Observer<T2>>(leftMap.values());
+                        leftMap.clear();
+                        rightMap.clear();
                     }
                 }
+                complete(list);
             }
 
             @Override
             public void onError(Throwable e) {
-                synchronized (guard) {
-                    for (Observer<T2> o : leftMap.values()) {
-                        o.onError(e);
-                    }
-
-                    observer.onError(e);
-                    cancel.unsubscribe();
-                }
+                errorAll(e);
             }
         }
 
         /** Observe left duration and apply termination. */
-        class LeftDurationObserver extends Subscriber<D1> {
+        final class LeftDurationObserver extends Subscriber<D1> {
             final int id;
-            final Subscription sduration;
-            final Observer<T2> gr;
+            boolean once = true;
 
-            public LeftDurationObserver(int id, Subscription sduration, Observer<T2> gr) {
+            public LeftDurationObserver(int id) {
                 this.id = id;
-                this.sduration = sduration;
-                this.gr = gr;
             }
 
             @Override
             public void onCompleted() {
-                synchronized (guard) {
-                    if (leftMap.remove(id) != null) {
+                if (once) {
+                    once = false;
+                    Observer<T2> gr;
+                    synchronized (guard) {
+                        gr = leftMap.remove(id);
+                    }
+                    if (gr != null) {
                         gr.onCompleted();
                     }
+                    group.remove(this);
                 }
-                group.remove(sduration);
             }
 
             @Override
             public void onError(Throwable e) {
-                synchronized (guard) {
-                    observer.onError(e);
-                }
-                cancel.unsubscribe();
+                errorMain(e);
             }
 
             @Override
@@ -275,29 +302,27 @@ public void onNext(D1 args) {
         }
 
         /** Observe right duration and apply termination. */
-        class RightDurationObserver extends Subscriber<D2> {
+        final class RightDurationObserver extends Subscriber<D2> {
             final int id;
-            final Subscription sduration;
-
-            public RightDurationObserver(int id, Subscription sduration) {
+            boolean once = true;
+            public RightDurationObserver(int id) {
                 this.id = id;
-                this.sduration = sduration;
             }
 
             @Override
             public void onCompleted() {
-                synchronized (guard) {
-                    rightMap.remove(id);
+                if (once) {
+                    once = false;
+                    synchronized (guard) {
+                        rightMap.remove(id);
+                    }
+                    group.remove(this);
                 }
-                group.remove(sduration);
             }
 
             @Override
             public void onError(Throwable e) {
-                synchronized (guard) {
-                    observer.onError(e);
-                }
-                cancel.unsubscribe();
+                errorMain(e);
             }
 
             @Override
@@ -313,7 +338,7 @@ public void onNext(D2 args) {
      * Subscribes to the underlying Observable by using a reference-counted
      * subscription.
      */
-    static class WindowObservableFunc<T> implements OnSubscribeFunc<T> {
+    final static class WindowObservableFunc<T> implements OnSubscribe<T> {
         final RefCountSubscription refCount;
         final Observable<T> underlying;
 
@@ -323,39 +348,40 @@ public WindowObservableFunc(Observable<T> underlying, RefCountSubscription refCo
         }
 
         @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
-            CompositeSubscription cs = new CompositeSubscription();
-            cs.add(refCount.get());
-            WindowObserver wo = new WindowObserver(t1, cs);
-            cs.add(underlying.unsafeSubscribe(wo));
-            return cs;
+        public void call(Subscriber<? super T> t1) {
+            Subscription ref = refCount.get();
+            WindowSubscriber wo = new WindowSubscriber(t1, ref);
+            wo.add(ref);
+            
+            underlying.unsafeSubscribe(wo);
         }
 
         /** Observe activities on the window. */
-        class WindowObserver extends Subscriber<T> {
-            final Observer<? super T> observer;
-            final Subscription self;
-
-            public WindowObserver(Observer<? super T> observer, Subscription self) {
-                this.observer = observer;
-                this.self = self;
+        final class WindowSubscriber extends Subscriber<T> {
+            final Subscriber<? super T> subscriber;
+            private final Subscription ref;
+
+            public WindowSubscriber(Subscriber<? super T> subscriber, Subscription ref) {
+                super(subscriber);
+                this.subscriber = subscriber;
+                this.ref = ref;
             }
 
             @Override
             public void onNext(T args) {
-                observer.onNext(args);
+                subscriber.onNext(args);
             }
 
             @Override
             public void onError(Throwable e) {
-                observer.onError(e);
-                self.unsubscribe();
+                subscriber.onError(e);
+                ref.unsubscribe();
             }
 
             @Override
             public void onCompleted() {
-                observer.onCompleted();
-                self.unsubscribe();
+                subscriber.onCompleted();
+                ref.unsubscribe();
             }
         }
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupJoinTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorGroupJoinTest.java
index 31d2fa1577..a515f78058 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationGroupJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupJoinTest.java
@@ -35,7 +35,7 @@
 import rx.functions.Func2;
 import rx.subjects.PublishSubject;
 
-public class OperationGroupJoinTest {
+public class OperatorGroupJoinTest {
     @Mock
     Observer<Object> observer;
 

From af02fd73ed373a705412514af9f45d69539d759a Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 25 Apr 2014 15:42:25 +0200
Subject: [PATCH 285/422] OperatorTimerAndSample

---
 rxjava-core/src/main/java/rx/Observable.java  |  24 +-
 .../java/rx/operators/OperationInterval.java  |  80 -------
 .../java/rx/operators/OperationSample.java    | 216 ------------------
 .../java/rx/operators/OperationTimer.java     |  94 --------
 .../OperatorSampleWithObservable.java         |  95 ++++++++
 .../rx/operators/OperatorSampleWithTime.java  |  99 ++++++++
 .../java/rx/operators/OperatorTimerOnce.java  |  58 +++++
 .../operators/OperatorTimerPeriodically.java  |  63 +++++
 .../java/rx/operators/OperationTimerTest.java |  82 -------
 ...ampleTest.java => OperatorSampleTest.java} |  18 +-
 ...tervalTest.java => OperatorTimerTest.java} | 138 +++++++++--
 11 files changed, 454 insertions(+), 513 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationInterval.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSample.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationTimer.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSampleWithObservable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTimerOnce.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTimerPeriodically.java
 delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
 rename rxjava-core/src/test/java/rx/operators/{OperationSampleTest.java => OperatorSampleTest.java} (94%)
 rename rxjava-core/src/test/java/rx/operators/{OperationIntervalTest.java => OperatorTimerTest.java} (62%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..b64c7affdf 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -52,7 +52,6 @@
 import rx.operators.OperationDelay;
 import rx.operators.OperationGroupByUntil;
 import rx.operators.OperationGroupJoin;
-import rx.operators.OperationInterval;
 import rx.operators.OperationJoin;
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
@@ -62,7 +61,6 @@
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
 import rx.operators.OperationParallelMerge;
 import rx.operators.OperationReplay;
-import rx.operators.OperationSample;
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSkip;
 import rx.operators.OperationSkipUntil;
@@ -73,7 +71,6 @@
 import rx.operators.OperationTakeWhile;
 import rx.operators.OperationThrottleFirst;
 import rx.operators.OperationTimeInterval;
-import rx.operators.OperationTimer;
 import rx.operators.OperationToMap;
 import rx.operators.OperationToMultimap;
 import rx.operators.OperationUsing;
@@ -112,6 +109,8 @@
 import rx.operators.OperatorPivot;
 import rx.operators.OperatorRepeat;
 import rx.operators.OperatorRetry;
+import rx.operators.OperatorSampleWithObservable;
+import rx.operators.OperatorSampleWithTime;
 import rx.operators.OperatorScan;
 import rx.operators.OperatorSerialize;
 import rx.operators.OperatorSingle;
@@ -123,6 +122,8 @@
 import rx.operators.OperatorTake;
 import rx.operators.OperatorTimeout;
 import rx.operators.OperatorTimeoutWithSelector;
+import rx.operators.OperatorTimerOnce;
+import rx.operators.OperatorTimerPeriodically;
 import rx.operators.OperatorTimestamp;
 import rx.operators.OperatorToObservableFuture;
 import rx.operators.OperatorToObservableList;
@@ -1505,7 +1506,7 @@ public final static <T> Observable<T> from(T[] items, Scheduler scheduler) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229027.aspx">MSDN: Observable.Interval</a>
      */
     public final static Observable<Long> interval(long interval, TimeUnit unit) {
-        return create(OperationInterval.interval(interval, unit));
+        return create(new OperatorTimerPeriodically(interval, interval, unit, Schedulers.computation()));
     }
 
     /**
@@ -1525,7 +1526,7 @@ public final static Observable<Long> interval(long interval, TimeUnit unit) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh228911.aspx">MSDN: Observable.Interval</a>
      */
     public final static Observable<Long> interval(long interval, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationInterval.interval(interval, unit, scheduler));
+        return create(new OperatorTimerPeriodically(interval, interval, unit, scheduler));
     }
 
     /**
@@ -2540,7 +2541,7 @@ public final static Observable<Long> timer(long initialDelay, long period, TimeU
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229652.aspx">MSDN: Observable.Timer</a>
      */
     public final static Observable<Long> timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationTimer.TimerPeriodically(initialDelay, period, unit, scheduler));
+        return create(new OperatorTimerPeriodically(initialDelay, period, unit, scheduler));
     }
 
     /**
@@ -2552,6 +2553,7 @@ public final static Observable<Long> timer(long initialDelay, long period, TimeU
      *            the initial delay before emitting a single 0L
      * @param unit
      *            time units to use for {@code delay}
+     * @return an Observable that emits one item after a specified delay, and then completes
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava wiki: timer()</a>
      */
     public final static Observable<Long> timer(long delay, TimeUnit unit) {
@@ -2570,10 +2572,12 @@ public final static Observable<Long> timer(long delay, TimeUnit unit) {
      *            time units to use for {@code delay}
      * @param scheduler
      *            the Scheduler to use for scheduling the item
+     * @return Observable that emits one item after a specified delay, on a specified Scheduler, and then
+     * completes
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava wiki: timer()</a>
      */
     public final static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationTimer.TimerOnce(delay, unit, scheduler));
+        return create(new OperatorTimerOnce(delay, unit, scheduler));
     }
 
     /**
@@ -5322,7 +5326,7 @@ public final Observable<T> retry(int retryCount) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
      */
     public final Observable<T> sample(long period, TimeUnit unit) {
-        return create(OperationSample.sample(this, period, unit));
+        return lift(new OperatorSampleWithTime<T>(period, unit, Schedulers.computation()));
     }
 
     /**
@@ -5342,7 +5346,7 @@ public final Observable<T> sample(long period, TimeUnit unit) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
      */
     public final Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationSample.sample(this, period, unit, scheduler));
+        return lift(new OperatorSampleWithTime<T>(period, unit, scheduler));
     }
 
     /**
@@ -5359,7 +5363,7 @@ public final Observable<T> sample(long period, TimeUnit unit, Scheduler schedule
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
      */
     public final <U> Observable<T> sample(Observable<U> sampler) {
-        return create(new OperationSample.SampleWithObservable<T, U>(this, sampler));
+        return lift(new OperatorSampleWithObservable<T, U>(sampler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationInterval.java b/rxjava-core/src/main/java/rx/operators/OperationInterval.java
deleted file mode 100644
index ef036984b6..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationInterval.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 java.util.concurrent.TimeUnit;
-
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Worker;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.schedulers.Schedulers;
-
-/**
- * Returns an observable sequence that produces a value after each period.
- * The value starts at 0 and counts up each period.
- */
-public final class OperationInterval {
-
-    /**
-     * Creates an event each time interval.
-     */
-    public static OnSubscribeFunc<Long> interval(long interval, TimeUnit unit) {
-        return interval(interval, unit, Schedulers.computation());
-    }
-
-    /**
-     * Creates an event each time interval.
-     */
-    public static OnSubscribeFunc<Long> interval(final long interval, final TimeUnit unit, final Scheduler scheduler) {
-        // wrapped in order to work with multiple subscribers
-        return new OnSubscribeFunc<Long>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super Long> observer) {
-                return new Interval(interval, unit, scheduler).onSubscribe(observer);
-            }
-        };
-    }
-
-    private static class Interval implements OnSubscribeFunc<Long> {
-        private final long period;
-        private final TimeUnit unit;
-        private final Scheduler scheduler;
-
-        private long currentValue;
-
-        private Interval(long period, TimeUnit unit, Scheduler scheduler) {
-            this.period = period;
-            this.unit = unit;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super Long> observer) {
-            Worker inner = scheduler.createWorker();
-            inner.schedulePeriodically(new Action0() {
-                @Override
-                public void call() {
-                    observer.onNext(currentValue);
-                    currentValue++;
-                }
-            }, period, period, unit);
-            return inner;
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSample.java b/rxjava-core/src/main/java/rx/operators/OperationSample.java
deleted file mode 100644
index bd199000dc..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSample.java
+++ /dev/null
@@ -1,216 +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.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.schedulers.Schedulers;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Returns an Observable that emits the results of sampling the items emitted by the source
- * Observable at a specified time interval.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/sample.png">
- */
-public final class OperationSample {
-
-    /**
-     * Samples the observable sequence at each interval.
-     */
-    public static <T> OnSubscribeFunc<T> sample(final Observable<? extends T> source, long period, TimeUnit unit) {
-        return new Sample<T>(source, period, unit, Schedulers.computation());
-    }
-
-    /**
-     * Samples the observable sequence at each interval.
-     */
-    public static <T> OnSubscribeFunc<T> sample(final Observable<? extends T> source, long period, TimeUnit unit, Scheduler scheduler) {
-        return new Sample<T>(source, period, unit, scheduler);
-    }
-
-    private static class Sample<T> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> source;
-        private final long period;
-        private final TimeUnit unit;
-        private final Scheduler scheduler;
-
-        private final AtomicBoolean hasValue = new AtomicBoolean();
-        private final AtomicReference<T> latestValue = new AtomicReference<T>();
-
-        private Sample(Observable<? extends T> source, long interval, TimeUnit unit, Scheduler scheduler) {
-            this.source = source;
-            this.period = interval;
-            this.unit = unit;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            Observable<Long> clock = Observable.create(OperationInterval.interval(period, unit, scheduler));
-            final Subscription clockSubscription = clock.unsafeSubscribe(new Subscriber<Long>() {
-                @Override
-                public void onCompleted() { /* the clock never completes */
-                }
-
-                @Override
-                public void onError(Throwable e) { /* the clock has no errors */
-                }
-
-                @Override
-                public void onNext(Long tick) {
-                    if (hasValue.get()) {
-                        observer.onNext(latestValue.get());
-                    }
-                }
-            });
-
-            final Subscription sourceSubscription = source.unsafeSubscribe(new Subscriber<T>() {
-                @Override
-                public void onCompleted() {
-                    clockSubscription.unsubscribe();
-                    observer.onCompleted();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    clockSubscription.unsubscribe();
-                    observer.onError(e);
-                }
-
-                @Override
-                public void onNext(T value) {
-                    latestValue.set(value);
-                    hasValue.set(true);
-                }
-            });
-
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    clockSubscription.unsubscribe();
-                    sourceSubscription.unsubscribe();
-                }
-            });
-        }
-    }
-
-    /**
-     * Sample with the help of another observable.
-     * 
-     * @see <a href='http://msdn.microsoft.com/en-us/library/hh229742.aspx'>MSDN: Observable.Sample</a>
-     */
-    public static class SampleWithObservable<T, U> implements OnSubscribeFunc<T> {
-        final Observable<T> source;
-        final Observable<U> sampler;
-
-        public SampleWithObservable(Observable<T> source, Observable<U> sampler) {
-            this.source = source;
-            this.sampler = sampler;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
-            return new ResultManager(t1).init();
-        }
-
-        /** Observe source values. */
-        class ResultManager extends Subscriber<T> {
-            final Observer<? super T> observer;
-            final CompositeSubscription cancel;
-            T value;
-            boolean valueTaken = true;
-            boolean done;
-            final Object guard;
-
-            public ResultManager(Observer<? super T> observer) {
-                this.observer = observer;
-                cancel = new CompositeSubscription();
-                guard = new Object();
-            }
-
-            public Subscription init() {
-                cancel.add(source.unsafeSubscribe(this));
-                cancel.add(sampler.unsafeSubscribe(new Sampler()));
-
-                return cancel;
-            }
-
-            @Override
-            public void onNext(T args) {
-                synchronized (guard) {
-                    valueTaken = false;
-                    value = args;
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                synchronized (guard) {
-                    if (!done) {
-                        done = true;
-                        observer.onError(e);
-                        cancel.unsubscribe();
-                    }
-                }
-            }
-
-            @Override
-            public void onCompleted() {
-                synchronized (guard) {
-                    if (!done) {
-                        done = true;
-                        observer.onCompleted();
-                        cancel.unsubscribe();
-                    }
-                }
-            }
-
-            /** Take the latest value, but only once. */
-            class Sampler extends Subscriber<U> {
-                @Override
-                public void onNext(U args) {
-                    synchronized (guard) {
-                        if (!valueTaken && !done) {
-                            valueTaken = true;
-                            observer.onNext(value);
-                        }
-                    }
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    ResultManager.this.onError(e);
-                }
-
-                @Override
-                public void onCompleted() {
-                    ResultManager.this.onCompleted();
-                }
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimer.java b/rxjava-core/src/main/java/rx/operators/OperationTimer.java
deleted file mode 100644
index e950cb07a8..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationTimer.java
+++ /dev/null
@@ -1,94 +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 rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Worker;
-import rx.Subscription;
-import rx.functions.Action0;
-
-/**
- * Operation Timer with several overloads.
- * 
- * @see <a href='http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.timer.aspx'>MSDN Observable.Timer</a>
- */
-public final class OperationTimer {
-    private OperationTimer() {
-        throw new IllegalStateException("No instances!");
-    }
-
-    /**
-     * Emit a single 0L after the specified time elapses.
-     */
-    public static class TimerOnce implements OnSubscribeFunc<Long> {
-        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<? super Long> t1) {
-            return scheduler.createWorker().schedule(new Action0() {
-                @Override
-                public void call() {
-                    t1.onNext(0L);
-                    t1.onCompleted();
-                }
-
-            }, dueTime, dueUnit);
-        }
-    }
-
-    /**
-     * Emit 0L after the initial period and ever increasing number after each period.
-     */
-    public static class TimerPeriodically implements OnSubscribeFunc<Long> {
-        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<? super Long> t1) {
-            Worker inner = scheduler.createWorker();
-            inner.schedulePeriodically(new Action0() {
-                long count;
-
-                @Override
-                public void call() {
-                    t1.onNext(count++);
-                }
-            }, initialDelay, period, unit);
-            return inner;
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSampleWithObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorSampleWithObservable.java
new file mode 100644
index 0000000000..9795171218
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSampleWithObservable.java
@@ -0,0 +1,95 @@
+/**
+ * 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.Operator;
+import rx.Subscriber;
+import rx.observers.SerializedSubscriber;
+
+/**
+ * Sample with the help of another observable.
+ * 
+ * @see <a href='http://msdn.microsoft.com/en-us/library/hh229742.aspx'>MSDN: Observable.Sample</a>
+ * 
+ * @param <T> the source and result value type
+ * @param <U> the element type of the sampler Observable
+ */
+public final class OperatorSampleWithObservable<T, U> implements Operator<T, T> {
+    final Observable<U> sampler;
+    /** Indicates that no value is available. */
+    static final Object EMPTY_TOKEN = new Object();
+
+    public OperatorSampleWithObservable(Observable<U> sampler) {
+        this.sampler = sampler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+    
+        final AtomicReference<Object> value = new AtomicReference<Object>(EMPTY_TOKEN);
+        
+        Subscriber<U> samplerSub = new Subscriber<U>(child) {
+            @Override
+            public void onNext(U t) {
+                Object localValue = value.getAndSet(EMPTY_TOKEN);
+                if (localValue != EMPTY_TOKEN) {
+                    @SuppressWarnings("unchecked")
+                    T v = (T)localValue;
+                    s.onNext(v);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                s.onCompleted();
+                unsubscribe();
+            }
+            
+        };
+        
+        Subscriber<T> result = new Subscriber<T>(child) {
+            @Override
+            public void onNext(T t) {
+                value.set(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                s.onCompleted();
+                unsubscribe();
+            }
+        };
+        
+        sampler.unsafeSubscribe(samplerSub);
+        
+        return result;
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java b/rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java
new file mode 100644
index 0000000000..2b92b9792e
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java
@@ -0,0 +1,99 @@
+/**
+ * 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.atomic.AtomicReference;
+import rx.Observable.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observers.SerializedSubscriber;
+
+/**
+ * Returns an Observable that emits the results of sampling the items emitted by the source
+ * Observable at a specified time interval.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/sample.png">
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorSampleWithTime<T> implements Operator<T, T> {
+    final long time;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+
+    public OperatorSampleWithTime(long time, TimeUnit unit, Scheduler scheduler) {
+        this.time = time;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final Worker worker = scheduler.createWorker();
+        child.add(worker);
+        
+        SamplerSubscriber<T> sampler = new SamplerSubscriber<T>(s);
+        worker.schedulePeriodically(sampler, time, time, unit);
+
+        return sampler;
+    }
+    /**
+     * The source subscriber and sampler.
+     */
+    static final class SamplerSubscriber<T> extends Subscriber<T> implements Action0 {
+        private final Subscriber<? super T> subscriber;
+        /** Indicates that no value is available. */
+        private static final Object EMPTY_TOKEN = new Object();
+        final AtomicReference<Object> value;
+        public SamplerSubscriber(Subscriber<? super T> subscriber) {
+            this.subscriber = subscriber;
+            this.value = new AtomicReference<Object>(EMPTY_TOKEN);
+        }
+        @Override
+        public void onNext(T t) {
+            value.set(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            subscriber.onError(e);
+            unsubscribe();
+        }
+
+        @Override
+        public void onCompleted() {
+            subscriber.onCompleted();
+        }
+
+        @Override
+        public void call() {
+            Object localValue = value.getAndSet(EMPTY_TOKEN);
+            if (localValue != EMPTY_TOKEN) {
+                try {
+                    @SuppressWarnings("unchecked")
+                    T v = (T)localValue;
+                    subscriber.onNext(v);
+                } catch (Throwable e) {
+                    onError(e);
+                }
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimerOnce.java b/rxjava-core/src/main/java/rx/operators/OperatorTimerOnce.java
new file mode 100644
index 0000000000..69d2498eb3
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimerOnce.java
@@ -0,0 +1,58 @@
+/**
+ * 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.OnSubscribe;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+
+/**
+ * Timer that emits a single 0L and completes after the specified time.
+ * @see <a href='http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.timer.aspx'>MSDN Observable.Timer</a>
+ */
+public final class OperatorTimerOnce implements OnSubscribe<Long> {
+    final long time;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+
+    public OperatorTimerOnce(long time, TimeUnit unit, Scheduler scheduler) {
+        this.time = time;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void call(final Subscriber<? super Long> child) {
+        Worker worker = scheduler.createWorker();
+        child.add(worker);
+        worker.schedule(new Action0() {
+            @Override
+            public void call() {
+                try {
+                    child.onNext(0L);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            }
+        }, time, unit);
+    }
+    
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimerPeriodically.java b/rxjava-core/src/main/java/rx/operators/OperatorTimerPeriodically.java
new file mode 100644
index 0000000000..65d9440a25
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimerPeriodically.java
@@ -0,0 +1,63 @@
+/**
+ * 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.OnSubscribe;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+
+/**
+ * Emit 0L after the initial period and ever increasing number after each period.
+ * @see <a href='http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.timer.aspx'>MSDN Observable.Timer</a>
+ */
+public final class OperatorTimerPeriodically implements OnSubscribe<Long> {
+    final long initialDelay;
+    final long period;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+
+    public OperatorTimerPeriodically(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
+        this.initialDelay = initialDelay;
+        this.period = period;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void call(final Subscriber<? super Long> child) {
+        final Worker worker = scheduler.createWorker();
+        child.add(worker);
+        worker.schedulePeriodically(new Action0() {
+            long counter;
+            @Override
+            public void call() {
+                try {
+                    child.onNext(counter++);
+                } catch (Throwable e) {
+                    try {
+                        child.onError(e);
+                    } finally {
+                        worker.unsubscribe();
+                    }
+                }
+            }
+            
+        }, 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
deleted file mode 100644
index 59c3983dc5..0000000000
--- a/rxjava-core/src/test/java/rx/operators/OperationTimerTest.java
+++ /dev/null
@@ -1,82 +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.any;
-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 java.util.concurrent.TimeUnit;
-
-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.Subscription;
-import rx.schedulers.TestScheduler;
-
-public class OperationTimerTest {
-    @Mock
-    Observer<Object> 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
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSampleTest.java
similarity index 94%
rename from rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSampleTest.java
index 7e4a39b2cd..41deae520c 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSampleTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSampleTest.java
@@ -29,15 +29,15 @@
 import org.mockito.InOrder;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
 
-public class OperationSampleTest {
+public class OperatorSampleTest {
     private TestScheduler scheduler;
     private Scheduler.Worker innerScheduler;
     private Observer<Long> observer;
@@ -55,9 +55,9 @@ public void before() {
 
     @Test
     public void testSample() {
-        Observable<Long> source = Observable.create(new Observable.OnSubscribeFunc<Long>() {
+        Observable<Long> source = Observable.create(new OnSubscribe<Long>() {
             @Override
-            public Subscription onSubscribe(final Observer<? super Long> observer1) {
+            public void call(final Subscriber<? super Long> observer1) {
                 innerScheduler.schedule(new Action0() {
                     @Override
                     public void call() {
@@ -76,12 +76,10 @@ public void call() {
                         observer1.onCompleted();
                     }
                 }, 3, TimeUnit.SECONDS);
-
-                return Subscriptions.empty();
             }
         });
 
-        Observable<Long> sampled = Observable.create(OperationSample.sample(source, 400L, TimeUnit.MILLISECONDS, scheduler));
+        Observable<Long> sampled = source.sample(400L, TimeUnit.MILLISECONDS, scheduler);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -98,7 +96,7 @@ public void call() {
         verify(observer, never()).onError(any(Throwable.class));
 
         scheduler.advanceTimeTo(1600L, TimeUnit.MILLISECONDS);
-        inOrder.verify(observer, times(1)).onNext(1L);
+        inOrder.verify(observer, never()).onNext(1L);
         verify(observer, never()).onNext(2L);
         verify(observer, never()).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
@@ -111,7 +109,7 @@ public void call() {
 
         scheduler.advanceTimeTo(3000L, TimeUnit.MILLISECONDS);
         inOrder.verify(observer, never()).onNext(1L);
-        inOrder.verify(observer, times(2)).onNext(2L);
+        inOrder.verify(observer, never()).onNext(2L);
         verify(observer, times(1)).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimerTest.java
similarity index 62%
rename from rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTimerTest.java
index 19224c1be7..eadf4b274a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationIntervalTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimerTest.java
@@ -15,44 +15,78 @@
  */
 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.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
 
 import java.util.concurrent.TimeUnit;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
+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.Subscriber;
 import rx.Subscription;
 import rx.observables.ConnectableObservable;
 import rx.schedulers.TestScheduler;
 
-public class OperationIntervalTest {
-
-    private TestScheduler scheduler;
-    private Observer<Long> observer;
-    private Observer<Long> observer2;
+public class OperatorTimerTest {
+    @Mock
+    Observer<Object> observer;
+    @Mock
+    Observer<Long> observer2;
+    TestScheduler scheduler;
 
     @Before
-    @SuppressWarnings("unchecked")
-    // due to mocking
     public void before() {
+        MockitoAnnotations.initMocks(this);
         scheduler = new TestScheduler();
-        observer = mock(Observer.class);
-        observer2 = mock(Observer.class);
     }
 
+    @Test
+    public void testTimerOnce() {
+        Observable.timer(100, TimeUnit.MILLISECONDS, scheduler).subscribe(observer);
+        scheduler.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, scheduler).subscribe(observer);
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer, times(1)).onNext(0L);
+
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        inOrder.verify(observer, times(1)).onNext(1L);
+
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        inOrder.verify(observer, times(1)).onNext(2L);
+
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        inOrder.verify(observer, times(1)).onNext(3L);
+
+        c.unsubscribe();
+        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
+        inOrder.verify(observer, never()).onNext(any());
+
+        verify(observer, never()).onCompleted();
+        verify(observer, never()).onError(any(Throwable.class));
+    }
     @Test
     public void testInterval() {
-        Observable<Long> w = Observable.create(OperationInterval.interval(1, TimeUnit.SECONDS, scheduler));
+        Observable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler);
         Subscription sub = w.subscribe(observer);
 
         verify(observer, never()).onNext(0L);
@@ -77,7 +111,7 @@ public void testInterval() {
 
     @Test
     public void testWithMultipleSubscribersStartingAtSameTime() {
-        Observable<Long> w = Observable.create(OperationInterval.interval(1, TimeUnit.SECONDS, scheduler));
+        Observable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler);
         Subscription sub1 = w.subscribe(observer);
         Subscription sub2 = w.subscribe(observer2);
 
@@ -116,7 +150,7 @@ public void testWithMultipleSubscribersStartingAtSameTime() {
 
     @Test
     public void testWithMultipleStaggeredSubscribers() {
-        Observable<Long> w = Observable.create(OperationInterval.interval(1, TimeUnit.SECONDS, scheduler));
+        Observable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler);
         Subscription sub1 = w.subscribe(observer);
 
         verify(observer, never()).onNext(anyLong());
@@ -156,7 +190,7 @@ public void testWithMultipleStaggeredSubscribers() {
 
     @Test
     public void testWithMultipleStaggeredSubscribersAndPublish() {
-        ConnectableObservable<Long> w = Observable.create(OperationInterval.interval(1, TimeUnit.SECONDS, scheduler)).publish();
+        ConnectableObservable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler).publish();
         Subscription sub1 = w.subscribe(observer);
         w.connect();
 
@@ -194,4 +228,66 @@ public void testWithMultipleStaggeredSubscribersAndPublish() {
         inOrder2.verify(observer2, never()).onCompleted();
         verify(observer2, never()).onError(any(Throwable.class));
     }
-}
+    @Test
+    public void testOnceObserverThrows() {
+        Observable<Long> source = Observable.timer(100, TimeUnit.MILLISECONDS, scheduler);
+        
+        source.subscribe(new Subscriber<Long>() {
+
+            @Override
+            public void onNext(Long t) {
+                throw new OperationReduceTest.CustomException();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                observer.onCompleted();
+            }
+        });
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        verify(observer).onError(any(OperationReduceTest.CustomException.class));
+        verify(observer, never()).onNext(anyLong());
+        verify(observer, never()).onCompleted();
+    }
+    @Test
+    public void testPeriodicObserverThrows() {
+        Observable<Long> source = Observable.timer(100, 100, TimeUnit.MILLISECONDS, scheduler);
+        
+        InOrder inOrder = inOrder(observer);
+        
+        source.subscribe(new Subscriber<Long>() {
+
+            @Override
+            public void onNext(Long t) {
+                if (t > 0) {
+                    throw new OperationReduceTest.CustomException();
+                }
+                observer.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                observer.onCompleted();
+            }
+        });
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        inOrder.verify(observer).onNext(0L);
+        inOrder.verify(observer).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verifyNoMoreInteractions();
+        verify(observer, never()).onCompleted();
+    }
+}
\ No newline at end of file

From 96b64b15173f37e79475ec240abf02bfe63156f1 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Fri, 25 Apr 2014 17:27:30 +0800
Subject: [PATCH 286/422] OperatorToMultimap

---
 rxjava-core/src/main/java/rx/Observable.java  |  10 +-
 .../rx/operators/OperationToMultimap.java     | 214 ------------------
 .../java/rx/operators/OperatorToMultimap.java | 137 +++++++++++
 ...pTest.java => OperatorToMultimapTest.java} |  35 ++-
 4 files changed, 157 insertions(+), 239 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorToMultimap.java
 rename rxjava-core/src/test/java/rx/operators/{OperationToMultimapTest.java => OperatorToMultimapTest.java} (82%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..d3c10fb37c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -75,7 +75,6 @@
 import rx.operators.OperationTimeInterval;
 import rx.operators.OperationTimer;
 import rx.operators.OperationToMap;
-import rx.operators.OperationToMultimap;
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
 import rx.operators.OperatorAll;
@@ -124,6 +123,7 @@
 import rx.operators.OperatorTimeout;
 import rx.operators.OperatorTimeoutWithSelector;
 import rx.operators.OperatorTimestamp;
+import rx.operators.OperatorToMultimap;
 import rx.operators.OperatorToObservableFuture;
 import rx.operators.OperatorToObservableList;
 import rx.operators.OperatorToObservableSortedList;
@@ -7234,7 +7234,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212098.aspx">MSDN: Observable.ToLookup</a>
      */
     public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ? extends K> keySelector) {
-        return create(OperationToMultimap.toMultimap(this, keySelector));
+        return lift(new OperatorToMultimap<T, K, T>(keySelector, Functions.<T>identity()));
     }
 
     /**
@@ -7254,7 +7254,7 @@ public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ?
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229101.aspx">MSDN: Observable.ToLookup</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector));
+        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector));
     }
 
     /**
@@ -7275,7 +7275,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory) {
-        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory));
+        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory));
     }
 
     /**
@@ -7298,7 +7298,7 @@ public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
      */
     public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory, Func1<? super K, ? extends Collection<V>> collectionFactory) {
-        return create(OperationToMultimap.toMultimap(this, keySelector, valueSelector, mapFactory, collectionFactory));
+        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory, collectionFactory));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java b/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
deleted file mode 100644
index 416c16acaf..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationToMultimap.java
+++ /dev/null
@@ -1,214 +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.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func0;
-import rx.functions.Func1;
-import rx.functions.Functions;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Maps the elements of the source observable into a multimap
- * (Map&lt;K, Collection&lt;V>>) where each
- * key entry has a collection of the source's values.
- * 
- * @see <a href='https://github.com/Netflix/RxJava/issues/97'>Issue #97</a>
- */
-public class OperationToMultimap {
-    /**
-     * ToMultimap with key selector, identitiy value selector,
-     * default HashMap factory and default ArrayList collection factory.
-     */
-    public static <T, K> OnSubscribeFunc<Map<K, Collection<T>>> toMultimap(
-            Observable<T> source,
-            Func1<? super T, ? extends K> keySelector
-            ) {
-        return new ToMultimap<T, K, T>(
-                source, keySelector, Functions.<T> identity(),
-                new DefaultToMultimapFactory<K, T>(),
-                new DefaultMultimapCollectionFactory<K, T>());
-    }
-
-    /**
-     * ToMultimap with key selector, custom value selector,
-     * default HashMap factory and default ArrayList collection factory.
-     */
-    public static <T, K, V> OnSubscribeFunc<Map<K, Collection<V>>> toMultimap(
-            Observable<T> source,
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector
-            ) {
-        return new ToMultimap<T, K, V>(
-                source, keySelector, valueSelector,
-                new DefaultToMultimapFactory<K, V>(),
-                new DefaultMultimapCollectionFactory<K, V>());
-    }
-
-    /**
-     * ToMultimap with key selector, custom value selector,
-     * custom Map factory and default ArrayList collection factory.
-     */
-    public static <T, K, V> OnSubscribeFunc<Map<K, Collection<V>>> toMultimap(
-            Observable<T> source,
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector,
-            Func0<? extends Map<K, Collection<V>>> mapFactory
-            ) {
-        return new ToMultimap<T, K, V>(
-                source, keySelector, valueSelector,
-                mapFactory,
-                new DefaultMultimapCollectionFactory<K, V>());
-    }
-
-    /**
-     * ToMultimap with key selector, custom value selector,
-     * custom Map factory and custom collection factory.
-     */
-    public static <T, K, V> OnSubscribeFunc<Map<K, Collection<V>>> toMultimap(
-            Observable<T> source,
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector,
-            Func0<? extends Map<K, Collection<V>>> mapFactory,
-            Func1<? super K, ? extends Collection<V>> collectionFactory
-            ) {
-        return new ToMultimap<T, K, V>(
-                source, keySelector, valueSelector,
-                mapFactory,
-                collectionFactory);
-    }
-
-    /**
-     * The default multimap factory returning a HashMap.
-     */
-    public static class DefaultToMultimapFactory<K, V> implements Func0<Map<K, Collection<V>>> {
-        @Override
-        public Map<K, Collection<V>> call() {
-            return new HashMap<K, Collection<V>>();
-        }
-    }
-
-    /**
-     * The default collection factory for a key in the multimap returning
-     * an ArrayList independent of the key.
-     */
-    public static class DefaultMultimapCollectionFactory<K, V>
-            implements Func1<K, Collection<V>> {
-        @Override
-        public Collection<V> call(K t1) {
-            return new ArrayList<V>();
-        }
-    }
-
-    /**
-     * Maps the elements of the source observable int a multimap customized
-     * by various selectors and factories.
-     */
-    public static class ToMultimap<T, K, V> implements OnSubscribeFunc<Map<K, Collection<V>>> {
-        private final Observable<T> source;
-        private final Func1<? super T, ? extends K> keySelector;
-        private final Func1<? super T, ? extends V> valueSelector;
-        private final Func0<? extends Map<K, Collection<V>>> mapFactory;
-        private final Func1<? super K, ? extends Collection<V>> collectionFactory;
-
-        public ToMultimap(
-                Observable<T> source,
-                Func1<? super T, ? extends K> keySelector,
-                Func1<? super T, ? extends V> valueSelector,
-                Func0<? extends Map<K, Collection<V>>> mapFactory,
-                Func1<? super K, ? extends Collection<V>> collectionFactory) {
-            this.source = source;
-            this.keySelector = keySelector;
-            this.valueSelector = valueSelector;
-            this.mapFactory = mapFactory;
-            this.collectionFactory = collectionFactory;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Map<K, Collection<V>>> t1) {
-            Map<K, Collection<V>> map;
-            try {
-                map = mapFactory.call();
-            } catch (Throwable t) {
-                t1.onError(t);
-                return Subscriptions.empty();
-            }
-            return source.unsafeSubscribe(new ToMultimapObserver<T, K, V>(
-                    t1, keySelector, valueSelector, map, collectionFactory
-                    ));
-        }
-
-        /**
-         * Observer that collects the source values of Ts into a multimap.
-         */
-        public static class ToMultimapObserver<T, K, V> extends Subscriber<T> {
-            private final Func1<? super T, ? extends K> keySelector;
-            private final Func1<? super T, ? extends V> valueSelector;
-            private final Func1<? super K, ? extends Collection<V>> collectionFactory;
-            private Map<K, Collection<V>> map;
-            private Observer<? super Map<K, Collection<V>>> t1;
-
-            public ToMultimapObserver(
-                    Observer<? super Map<K, Collection<V>>> t1,
-                    Func1<? super T, ? extends K> keySelector,
-                    Func1<? super T, ? extends V> valueSelector,
-                    Map<K, Collection<V>> map,
-                    Func1<? super K, ? extends Collection<V>> 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);
-                V value = valueSelector.call(args);
-                Collection<V> collection = map.get(key);
-                if (collection == null) {
-                    collection = collectionFactory.call(key);
-                    map.put(key, collection);
-                }
-                collection.add(value);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                map = null;
-                t1.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                Map<K, Collection<V>> map0 = map;
-                map = null;
-                t1.onNext(map0);
-                t1.onCompleted();
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorToMultimap.java b/rxjava-core/src/main/java/rx/operators/OperatorToMultimap.java
new file mode 100644
index 0000000000..f0643dcd93
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorToMultimap.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.operators;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func0;
+import rx.functions.Func1;
+
+/**
+ * Maps the elements of the source observable into a multimap
+ * (Map&lt;K, Collection&lt;V>>) where each
+ * key entry has a collection of the source's values.
+ *
+ * @see <a href='https://github.com/Netflix/RxJava/issues/97'>Issue #97</a>
+ */
+public final class OperatorToMultimap<T, K, V> implements Operator<Map<K, Collection<V>>, T> {
+    /**
+     * The default multimap factory returning a HashMap.
+     */
+    public static final class DefaultToMultimapFactory<K, V> implements Func0<Map<K, Collection<V>>> {
+        @Override
+        public Map<K, Collection<V>> call() {
+            return new HashMap<K, Collection<V>>();
+        }
+    }
+
+    /**
+     * The default collection factory for a key in the multimap returning
+     * an ArrayList independent of the key.
+     */
+    public static final class DefaultMultimapCollectionFactory<K, V>
+            implements Func1<K, Collection<V>> {
+        @Override
+        public Collection<V> call(K t1) {
+            return new ArrayList<V>();
+        }
+    }
+
+    private final Func1<? super T, ? extends K> keySelector;
+    private final Func1<? super T, ? extends V> valueSelector;
+    private final Func0<? extends Map<K, Collection<V>>> mapFactory;
+    private final Func1<? super K, ? extends Collection<V>> collectionFactory;
+
+    /**
+     * ToMultimap with key selector, custom value selector,
+     * default HashMap factory and default ArrayList collection factory.
+     */
+    public OperatorToMultimap(
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector) {
+        this(keySelector, valueSelector,
+                new DefaultToMultimapFactory<K, V>(),
+                new DefaultMultimapCollectionFactory<K, V>());
+    }
+
+    /**
+     * ToMultimap with key selector, custom value selector,
+     * custom Map factory and default ArrayList collection factory.
+     */
+    public OperatorToMultimap(
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector,
+            Func0<? extends Map<K, Collection<V>>> mapFactory) {
+        this(keySelector, valueSelector,
+                mapFactory,
+                new DefaultMultimapCollectionFactory<K, V>());
+    }
+
+    /**
+     * ToMultimap with key selector, custom value selector,
+     * custom Map factory and custom collection factory.
+     */
+    public OperatorToMultimap(
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector,
+            Func0<? extends Map<K, Collection<V>>> mapFactory,
+            Func1<? super K, ? extends Collection<V>> collectionFactory) {
+        this.keySelector = keySelector;
+        this.valueSelector = valueSelector;
+        this.mapFactory = mapFactory;
+        this.collectionFactory = collectionFactory;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super Map<K, Collection<V>>> subscriber) {
+        return new Subscriber<T>(subscriber) {
+            private Map<K, Collection<V>> map = mapFactory.call();
+
+            @Override
+            public void onNext(T v) {
+                K key = keySelector.call(v);
+                V value = valueSelector.call(v);
+                Collection<V> collection = map.get(key);
+                if (collection == null) {
+                    collection = collectionFactory.call(key);
+                    map.put(key, collection);
+                }
+                collection.add(value);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                map = null;
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                Map<K, Collection<V>> map0 = map;
+                map = null;
+                subscriber.onNext(map0);
+                subscriber.onCompleted();
+            }
+
+        };
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToMultimapTest.java
similarity index 82%
rename from rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorToMultimapTest.java
index 2eb608d851..42dfb16fb4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMultimapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToMultimapTest.java
@@ -39,10 +39,10 @@
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.functions.Functions;
-import rx.operators.OperationToMultimap.DefaultMultimapCollectionFactory;
-import rx.operators.OperationToMultimap.DefaultToMultimapFactory;
+import rx.operators.OperatorToMultimap.DefaultMultimapCollectionFactory;
+import rx.operators.OperatorToMultimap.DefaultToMultimapFactory;
 
-public class OperationToMultimapTest {
+public class OperatorToMultimapTest {
     @Mock
     Observer<Object> objectObserver;
 
@@ -68,7 +68,7 @@ public String call(String t1) {
     public void testToMultimap() {
         Observable<String> source = Observable.from("a", "b", "cc", "dd");
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFunc));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(1, Arrays.asList("a", "b"));
@@ -85,7 +85,7 @@ public void testToMultimap() {
     public void testToMultimapWithValueSelector() {
         Observable<String> source = Observable.from("a", "b", "cc", "dd");
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFunc, duplicate));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, duplicate);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(1, Arrays.asList("aa", "bb"));
@@ -114,10 +114,9 @@ protected boolean removeEldestEntry(Map.Entry<Integer, Collection<String>> eldes
             }
         };
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(
-                OperationToMultimap.toMultimap(source,
-                        lengthFunc, Functions.<String> identity(),
-                        mapFactory, new DefaultMultimapCollectionFactory<Integer, String>()));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(
+                lengthFunc, Functions.<String>identity(),
+                mapFactory, new DefaultMultimapCollectionFactory<Integer, String>());
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -146,10 +145,9 @@ public Collection<String> call(Integer t1) {
             }
         };
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(
-                OperationToMultimap.toMultimap(
-                        source, lengthFunc, Functions.<String> identity(),
-                        new DefaultToMultimapFactory<Integer, String>(), collectionFactory));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(
+                lengthFunc, Functions.<String>identity(),
+                new DefaultToMultimapFactory<Integer, String>(), collectionFactory);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -176,7 +174,7 @@ public Integer call(String t1) {
             }
         };
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFuncErr));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFuncErr);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(1, Arrays.asList("a", "b"));
@@ -203,7 +201,7 @@ public String call(String t1) {
             }
         };
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(OperationToMultimap.toMultimap(source, lengthFunc, duplicateErr));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, duplicateErr);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(1, Arrays.asList("aa", "bb"));
@@ -227,8 +225,7 @@ public Map<Integer, Collection<String>> call() {
             }
         };
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(
-                OperationToMultimap.toMultimap(source, lengthFunc, Functions.<String> identity(), mapFactory));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, Functions.<String>identity(), mapFactory);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(2, Arrays.asList("cc", "dd"));
@@ -257,9 +254,7 @@ public Collection<String> call(Integer t1) {
             }
         };
 
-        Observable<Map<Integer, Collection<String>>> mapped = Observable.create(
-                OperationToMultimap.toMultimap(
-                        source, lengthFunc, Functions.<String> identity(), new DefaultToMultimapFactory(), collectionFactory));
+        Observable<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc, Functions.<String>identity(), new DefaultToMultimapFactory<Integer, String>(), collectionFactory);
 
         Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>();
         expected.put(2, Arrays.asList("cc", "dd"));

From 483662fe550364d8f525f9e665e3d37b3a848412 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Fri, 25 Apr 2014 22:16:51 +0800
Subject: [PATCH 287/422] OperatorToMap

---
 rxjava-core/src/main/java/rx/Observable.java  |   8 +-
 .../java/rx/operators/OperationToMap.java     | 171 ------------------
 .../main/java/rx/operators/OperatorToMap.java | 104 +++++++++++
 ...nToMapTest.java => OperatorToMapTest.java} |  14 +-
 4 files changed, 115 insertions(+), 182 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationToMap.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorToMap.java
 rename rxjava-core/src/test/java/rx/operators/{OperationToMapTest.java => OperatorToMapTest.java} (89%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..de7ed22a83 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -74,7 +74,7 @@
 import rx.operators.OperationThrottleFirst;
 import rx.operators.OperationTimeInterval;
 import rx.operators.OperationTimer;
-import rx.operators.OperationToMap;
+import rx.operators.OperatorToMap;
 import rx.operators.OperationToMultimap;
 import rx.operators.OperationUsing;
 import rx.operators.OperationWindow;
@@ -7175,7 +7175,7 @@ public final Observable<List<T>> toList() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229137.aspx">MSDN: Observable.ToDictionary</a>
      */
     public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySelector) {
-        return create(OperationToMap.toMap(this, keySelector));
+        return lift(new OperatorToMap<T, K, T>(keySelector, Functions.<T>identity()));
     }
 
     /**
@@ -7197,7 +7197,7 @@ public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySe
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212075.aspx">MSDN: Observable.ToDictionary</a>
      */
     public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return create(OperationToMap.toMap(this, keySelector, valueSelector));
+        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector));
     }
 
     /**
@@ -7217,7 +7217,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
      */
     public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, V>> mapFactory) {
-        return create(OperationToMap.toMap(this, keySelector, valueSelector, mapFactory));
+        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector, mapFactory));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationToMap.java b/rxjava-core/src/main/java/rx/operators/OperationToMap.java
deleted file mode 100644
index cd3a08e62e..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationToMap.java
+++ /dev/null
@@ -1,171 +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.HashMap;
-import java.util.Map;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func0;
-import rx.functions.Func1;
-import rx.functions.Functions;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Maps the elements of the source observable into a java.util.Map instance and
- * emits that once the source observable completes.
- * 
- * @see <a href='https://github.com/Netflix/RxJava/issues/96'>Issue #96</a>
- */
-public class OperationToMap {
-    /**
-     * ToMap with key selector, identity value selector and default HashMap factory.
-     */
-    public static <T, K> OnSubscribeFunc<Map<K, T>> toMap(Observable<T> source,
-            Func1<? super T, ? extends K> keySelector) {
-        return new ToMap<T, K, T>(source, keySelector,
-                Functions.<T> identity(), new DefaultToMapFactory<K, T>());
-    }
-
-    /**
-     * ToMap with key selector, value selector and default HashMap factory.
-     */
-    public static <T, K, V> OnSubscribeFunc<Map<K, V>> toMap(Observable<T> source,
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector) {
-        return new ToMap<T, K, V>(source, keySelector,
-                valueSelector, new DefaultToMapFactory<K, V>());
-    }
-
-    /**
-     * ToMap with key selector, value selector and custom Map factory.
-     */
-    public static <T, K, V> OnSubscribeFunc<Map<K, V>> toMap(Observable<T> source,
-            Func1<? super T, ? extends K> keySelector,
-            Func1<? super T, ? extends V> valueSelector,
-            Func0<? extends Map<K, V>> mapFactory) {
-        return new ToMap<T, K, V>(source, keySelector,
-                valueSelector, mapFactory);
-    }
-
-    /** The default map factory. */
-    public static class DefaultToMapFactory<K, V> implements Func0<Map<K, V>> {
-        @Override
-        public Map<K, V> call() {
-            return new HashMap<K, V>();
-        }
-    }
-
-    /**
-     * 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 <T>
-     *            the source's value type
-     * @param <K>
-     *            the key type
-     * @param <V>
-     *            the value type
-     */
-    public static class ToMap<T, K, V> implements OnSubscribeFunc<Map<K, V>> {
-        /** The source. */
-        private final Observable<T> source;
-        /** Key extractor. */
-        private final Func1<? super T, ? extends K> keySelector;
-        /** Value extractor. */
-        private final Func1<? super T, ? extends V> valueSelector;
-        /** Map factory. */
-        private final Func0<? extends Map<K, V>> mapFactory;
-
-        public ToMap(
-                Observable<T> source,
-                Func1<? super T, ? extends K> keySelector,
-                Func1<? super T, ? extends V> valueSelector,
-                Func0<? extends Map<K, V>> mapFactory) {
-            this.source = source;
-            this.keySelector = keySelector;
-            this.valueSelector = valueSelector;
-            this.mapFactory = mapFactory;
-
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Map<K, V>> t1) {
-            Map<K, V> map;
-            try {
-                map = mapFactory.call();
-            } catch (Throwable t) {
-                t1.onError(t);
-                return Subscriptions.empty();
-            }
-            return source.unsafeSubscribe(new ToMapObserver<K, V, T>(
-                    t1, keySelector, valueSelector, map));
-        }
-
-        /**
-         * Observer that collects the source values of T into
-         * a map.
-         */
-        public static class ToMapObserver<K, V, T> extends Subscriber<T> {
-            /** The map. */
-            Map<K, V> map;
-            /** Key extractor. */
-            private final Func1<? super T, ? extends K> keySelector;
-            /** Value extractor. */
-            private final Func1<? super T, ? extends V> valueSelector;
-            /** The observer who is receiving the completed map. */
-            private final Observer<? super Map<K, V>> t1;
-
-            public ToMapObserver(
-                    Observer<? super Map<K, V>> t1,
-                    Func1<? super T, ? extends K> keySelector,
-                    Func1<? super T, ? extends V> valueSelector,
-                    Map<K, V> map) {
-                this.map = map;
-                this.t1 = t1;
-                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<K, V> map0 = map;
-                map = null;
-                t1.onNext(map0);
-                t1.onCompleted();
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorToMap.java b/rxjava-core/src/main/java/rx/operators/OperatorToMap.java
new file mode 100644
index 0000000000..f446fbe4e8
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorToMap.java
@@ -0,0 +1,104 @@
+/**
+ * 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.HashMap;
+import java.util.Map;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func0;
+import rx.functions.Func1;
+
+/**
+ * Maps the elements of the source observable into a java.util.Map instance and
+ * emits that once the source observable completes.
+ * 
+ * @see <a href='https://github.com/Netflix/RxJava/issues/96'>Issue #96</a>
+ */
+public final class OperatorToMap<T, K, V> implements Operator<Map<K, V>, T> {
+
+    /**
+     * The default map factory.
+     */
+    public static final class DefaultToMapFactory<K, V> implements Func0<Map<K, V>> {
+        @Override
+        public Map<K, V> call() {
+            return new HashMap<K, V>();
+        }
+    }
+
+
+    private final Func1<? super T, ? extends K> keySelector;
+
+    private final Func1<? super T, ? extends V> valueSelector;
+
+    private final Func0<? extends Map<K, V>> mapFactory;
+
+
+    /**
+     * ToMap with key selector, value selector and default HashMap factory.
+     */
+    public OperatorToMap(
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector) {
+        this(keySelector, valueSelector, new DefaultToMapFactory<K, V>());
+    }
+
+
+    /**
+     * ToMap with key selector, value selector and custom Map factory.
+     */
+    public OperatorToMap(
+            Func1<? super T, ? extends K> keySelector,
+            Func1<? super T, ? extends V> valueSelector,
+            Func0<? extends Map<K, V>> mapFactory) {
+        this.keySelector = keySelector;
+        this.valueSelector = valueSelector;
+        this.mapFactory = mapFactory;
+
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super Map<K, V>> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            private Map<K, V> map = mapFactory.call();
+
+            @Override
+            public void onNext(T v) {
+                K key = keySelector.call(v);
+                V value = valueSelector.call(v);
+                map.put(key, value);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                map = null;
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                Map<K, V> map0 = map;
+                map = null;
+                subscriber.onNext(map0);
+                subscriber.onCompleted();
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToMapTest.java
similarity index 89%
rename from rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorToMapTest.java
index da6b316133..db3c9cd1b9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationToMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToMapTest.java
@@ -35,7 +35,7 @@
 import rx.functions.Func1;
 import rx.functions.Functions;
 
-public class OperationToMapTest {
+public class OperatorToMapTest {
     @Mock
     Observer<Object> objectObserver;
 
@@ -61,7 +61,7 @@ public String call(String t1) {
     public void testToMap() {
         Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
 
-        Observable<Map<Integer, String>> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc));
+        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc);
 
         Map<Integer, String> expected = new HashMap<Integer, String>();
         expected.put(1, "a");
@@ -80,7 +80,7 @@ public void testToMap() {
     public void testToMapWithValueSelector() {
         Observable<String> source = Observable.from("a", "bb", "ccc", "dddd");
 
-        Observable<Map<Integer, String>> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, duplicate));
+        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicate);
 
         Map<Integer, String> expected = new HashMap<Integer, String>();
         expected.put(1, "aa");
@@ -108,7 +108,7 @@ public Integer call(String t1) {
                 return t1.length();
             }
         };
-        Observable<Map<Integer, String>> mapped = Observable.create(OperationToMap.toMap(source, lengthFuncErr));
+        Observable<Map<Integer, String>> mapped = source.toMap(lengthFuncErr);
 
         Map<Integer, String> expected = new HashMap<Integer, String>();
         expected.put(1, "a");
@@ -138,7 +138,7 @@ public String call(String t1) {
             }
         };
 
-        Observable<Map<Integer, String>> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, duplicateErr));
+        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicateErr);
 
         Map<Integer, String> expected = new HashMap<Integer, String>();
         expected.put(1, "aa");
@@ -176,7 +176,7 @@ public Integer call(String t1) {
                 return t1.length();
             }
         };
-        Observable<Map<Integer, String>> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, Functions.<String> identity(), mapFactory));
+        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, Functions.<String>identity(), mapFactory);
 
         Map<Integer, String> expected = new LinkedHashMap<Integer, String>();
         expected.put(2, "bb");
@@ -207,7 +207,7 @@ public Integer call(String t1) {
                 return t1.length();
             }
         };
-        Observable<Map<Integer, String>> mapped = Observable.create(OperationToMap.toMap(source, lengthFunc, Functions.<String> identity(), mapFactory));
+        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, Functions.<String>identity(), mapFactory);
 
         Map<Integer, String> expected = new LinkedHashMap<Integer, String>();
         expected.put(2, "bb");

From 3da91351e5b24d3738661672ce2a3cfa2fa9e588 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 25 Apr 2014 16:44:01 +0200
Subject: [PATCH 288/422] OperatorAsync

---
 .../src/main/java/rx/util/async/Async.java    | 42 ++++++------
 .../rx/util/async/operators/Functionals.java  |  2 +-
 .../util/async/operators/LatchedObserver.java |  2 +-
 ...erFuture.java => OperatorDeferFuture.java} | 10 +--
 ...Future.java => OperatorForEachFuture.java} |  6 +-
 ...nals.java => OperatorFromFunctionals.java} | 37 ++++-------
 ...rtFuture.java => OperatorStartFuture.java} | 19 +-----
 .../test/java/rx/util/async/AsyncTest.java    |  2 +-
 ...Test.java => OperatorDeferFutureTest.java} | 10 +--
 ...st.java => OperatorForEachFutureTest.java} |  2 +-
 ....java => OperatorFromFunctionalsTest.java} | 65 ++-----------------
 ...Test.java => OperatorStartFutureTest.java} |  4 +-
 12 files changed, 59 insertions(+), 142 deletions(-)
 rename rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/{OperationDeferFuture.java => OperatorDeferFuture.java} (90%)
 rename rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/{OperationForEachFuture.java => OperatorForEachFuture.java} (96%)
 rename rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/{OperationFromFunctionals.java => OperatorFromFunctionals.java} (64%)
 rename rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/{OperationStartFuture.java => OperatorStartFuture.java} (75%)
 rename rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/{OperationDeferFutureTest.java => OperatorDeferFutureTest.java} (91%)
 rename rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/{OperationForEachFutureTest.java => OperatorForEachFutureTest.java} (99%)
 rename rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/{OperationFromFunctionalsTest.java => OperatorFromFunctionalsTest.java} (76%)
 rename rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/{OperationStartFutureTest.java => OperatorStartFutureTest.java} (98%)

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 159bf97bd5..80ba5f3ea3 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,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
@@ -54,10 +54,10 @@
 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;
-import rx.util.async.operators.OperationFromFunctionals;
-import rx.util.async.operators.OperationStartFuture;
+import rx.util.async.operators.OperatorDeferFuture;
+import rx.util.async.operators.OperatorForEachFuture;
+import rx.util.async.operators.OperatorFromFunctionals;
+import rx.util.async.operators.OperatorStartFuture;
 
 /**
  * Utility methods to convert functions and actions into asynchronous operations
@@ -1377,7 +1377,7 @@ public static <R> FuncN<Observable<R>> asyncFunc(final FuncN<? extends R> func,
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#startfuture">RxJava Wiki: startFuture()</a>
      */
     public static <T> Observable<T> startFuture(Func0<? extends Future<? extends T>> functionAsync) {
-        return OperationStartFuture.startFuture(functionAsync);
+        return OperatorStartFuture.startFuture(functionAsync);
     }
     
     /**
@@ -1395,7 +1395,7 @@ public static <T> Observable<T> startFuture(Func0<? extends Future<? extends T>>
      */
     public static <T> Observable<T> startFuture(Func0<? extends Future<? extends T>> functionAsync,
         Scheduler scheduler) {
-        return OperationStartFuture.startFuture(functionAsync, scheduler);
+        return OperatorStartFuture.startFuture(functionAsync, scheduler);
     }
     
     /**
@@ -1416,7 +1416,7 @@ public static <T> Observable<T> startFuture(Func0<? extends Future<? extends T>>
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#deferfuture">RxJava Wiki: deferFuture()</a>
      */
     public static <T> Observable<T> deferFuture(Func0<? extends Future<? extends Observable<? extends T>>> observableFactoryAsync) {
-        return OperationDeferFuture.deferFuture(observableFactoryAsync);
+        return OperatorDeferFuture.deferFuture(observableFactoryAsync);
     }
     
     /**
@@ -1437,7 +1437,7 @@ public static <T> Observable<T> deferFuture(Func0<? extends Future<? extends Obs
     public static <T> Observable<T> deferFuture(
         Func0<? extends Future<? extends Observable<? extends T>>> observableFactoryAsync,
         Scheduler scheduler) {
-        return OperationDeferFuture.deferFuture(observableFactoryAsync, scheduler);
+        return OperatorDeferFuture.deferFuture(observableFactoryAsync, scheduler);
     }
     
     /**
@@ -1453,13 +1453,13 @@ public static <T> Observable<T> 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.functions.Action1, rx.Scheduler)
+     * @see #forEachFuture(rx.Observable, rx.functions.Action1, rx.Scheduler)
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
         Observable<? extends T> source,
         Action1<? super T> onNext) {
-        return OperationForEachFuture.forEachFuture(source, onNext);
+        return OperatorForEachFuture.forEachFuture(source, onNext);
     }
     
     
@@ -1477,14 +1477,14 @@ public static <T> FutureTask<Void> 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.functions.Action1, rx.functions.Action1, rx.Scheduler)
+     * @see #forEachFuture(rx.Observable, rx.functions.Action1, rx.functions.Action1, rx.Scheduler)
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
         Observable<? extends T> source,
         Action1<? super T> onNext,
         Action1<? super Throwable> onError) {
-        return OperationForEachFuture.forEachFuture(source, onNext, onError);
+        return OperatorForEachFuture.forEachFuture(source, onNext, onError);
     }
     
     
@@ -1503,7 +1503,7 @@ public static <T> FutureTask<Void> 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.functions.Action1, rx.functions.Action1, rx.functions.Action0, rx.Scheduler)
+     * @see #forEachFuture(rx.Observable, rx.functions.Action1, rx.functions.Action1, rx.functions.Action0, rx.Scheduler)
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
@@ -1511,7 +1511,7 @@ public static <T> FutureTask<Void> forEachFuture(
         Action1<? super T> onNext,
         Action1<? super Throwable> onError,
         Action0 onCompleted) {
-        return OperationForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
+        return OperatorForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
     }
     
     
@@ -1534,7 +1534,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Observable<? extends T> source,
             Action1<? super T> onNext,
             Scheduler scheduler) {
-        FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext);
+        FutureTask<Void> task = OperatorForEachFuture.forEachFuture(source, onNext);
         final Worker inner = scheduler.createWorker();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
@@ -1562,7 +1562,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action1<? super T> onNext,
             Action1<? super Throwable> onError,
             Scheduler scheduler) {
-        FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError);
+        FutureTask<Void> task = OperatorForEachFuture.forEachFuture(source, onNext, onError);
         final Worker inner = scheduler.createWorker();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
@@ -1592,7 +1592,7 @@ public static <T> FutureTask<Void> forEachFuture(
             Action1<? super Throwable> onError,
             Action0 onCompleted,
             Scheduler scheduler) {
-        FutureTask<Void> task = OperationForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
+        FutureTask<Void> task = OperatorForEachFuture.forEachFuture(source, onNext, onError, onCompleted);
         final Worker inner = scheduler.createWorker();
         inner.schedule(Functionals.fromRunnable(task, inner));
         return task;
@@ -1696,7 +1696,7 @@ public static <R> Observable<R> fromRunnable(final Runnable run, final R result)
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromaction">RxJava Wiki: fromAction()</a>
      */
     public static <R> Observable<R> fromAction(Action0 action, R result, Scheduler scheduler) {
-        return Observable.create(OperationFromFunctionals.fromAction(action, result)).subscribeOn(scheduler);
+        return Observable.create(OperatorFromFunctionals.fromAction(action, result)).subscribeOn(scheduler);
     }
     
     /**
@@ -1740,7 +1740,7 @@ public static <R> Observable<R> fromFunc0(Func0<? extends R> function, Scheduler
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromcallable">RxJava Wiki: fromCallable()</a>
      */
     public static <R> Observable<R> fromCallable(Callable<? extends R> callable, Scheduler scheduler) {
-        return Observable.create(OperationFromFunctionals.fromCallable(callable)).subscribeOn(scheduler);
+        return Observable.create(OperatorFromFunctionals.fromCallable(callable)).subscribeOn(scheduler);
     }
     
     /**
@@ -1759,7 +1759,7 @@ public static <R> Observable<R> fromCallable(Callable<? extends R> callable, Sch
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromrunnable">RxJava Wiki: fromRunnable()</a>
      */
     public static <R> Observable<R> fromRunnable(final Runnable run, final R result, Scheduler scheduler) {
-        return Observable.create(OperationFromFunctionals.fromRunnable(run, result)).subscribeOn(scheduler);
+        return Observable.create(OperatorFromFunctionals.fromRunnable(run, result)).subscribeOn(scheduler);
     }
     /**
      * Runs the provided action on the given scheduler and allows propagation
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 3dc96d0477..a197e183c7 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
@@ -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-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 e06dc97cfd..e8e062bb43 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
@@ -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-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/OperatorDeferFuture.java
similarity index 90%
rename from rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationDeferFuture.java
rename to rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperatorDeferFuture.java
index a4fde509d9..4e8c524243 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/OperatorDeferFuture.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.
@@ -24,9 +24,9 @@
 /**
  * Defer the execution of a factory method which produces an observable sequence.
  */
-public final class OperationDeferFuture {
+public final class OperatorDeferFuture {
     /** Utility class. */
-    private OperationDeferFuture() { throw new IllegalStateException("No instances!"); }
+    private OperatorDeferFuture() { throw new IllegalStateException("No instances!"); }
     
     /**
      * Returns an observable sequence that starts the specified asynchronous 
@@ -49,7 +49,7 @@ public DeferFutureFunc0(Func0<? extends Future<? extends Observable<? extends T>
         
         @Override
         public Observable<T> call() {
-            return Observable.merge(OperationStartFuture.startFuture(observableFactoryAsync));
+            return Observable.merge(OperatorStartFuture.startFuture(observableFactoryAsync));
         }
         
     }
@@ -81,7 +81,7 @@ public DeferFutureFunc0Scheduled(Func0<? extends Future<? extends Observable<? e
         
         @Override
         public Observable<T> call() {
-            return Observable.merge(OperationStartFuture.startFuture(observableFactoryAsync, scheduler));
+            return Observable.merge(OperatorStartFuture.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/OperatorForEachFuture.java
similarity index 96%
rename from rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationForEachFuture.java
rename to rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperatorForEachFuture.java
index 42be310d36..098aa41aaf 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/OperatorForEachFuture.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.
@@ -29,9 +29,9 @@
  * <p>
  * Remark: the cancellation token version's behavior is in doubt, so left out.
  */
-public final class OperationForEachFuture {
+public final class OperatorForEachFuture {
     /** Utility class. */
-    private OperationForEachFuture() { throw new IllegalStateException("No instances!"); }
+    private OperatorForEachFuture() { throw new IllegalStateException("No instances!"); }
     
     /**
      * Subscribes to the given source and calls the callback for each emitted item,
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/OperatorFromFunctionals.java
similarity index 64%
rename from rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationFromFunctionals.java
rename to rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperatorFromFunctionals.java
index 57ef639a26..e1e337ae5a 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/OperatorFromFunctionals.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.
@@ -17,48 +17,35 @@
 
 import java.util.concurrent.Callable;
 
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
 import rx.functions.Action0;
 import rx.functions.Actions;
 import rx.functions.Func0;
-import rx.subscriptions.Subscriptions;
 
 /**
  * Operators that invoke a function or action if
  * an observer subscribes.
  * Asynchrony can be achieved by using subscribeOn or observeOn.
  */
-public final class OperationFromFunctionals {
+public final class OperatorFromFunctionals {
     /** Utility class. */
-    private OperationFromFunctionals() { throw new IllegalStateException("No instances!"); }
+    private OperatorFromFunctionals() { throw new IllegalStateException("No instances!"); }
     
     /** Subscriber function that invokes an action and returns the given result. */
-    public static <R> OnSubscribeFunc<R> fromAction(Action0 action, R result) {
+    public static <R> OnSubscribe<R> fromAction(Action0 action, R result) {
         return new InvokeAsync<R>(Actions.toFunc(action, result));
     }
 
-    /**
-     * Subscriber function that invokes a function and returns its value.
-     *
-     * @deprecated  Unnecessary now that Func0 extends Callable. Just call
-     *              {@link #fromCallable(Callable)} instead.
-     */
-    @Deprecated
-    public static <R> OnSubscribeFunc<R> fromFunc0(Func0<? extends R> function) {
-        return fromCallable(function);
-    }
-    
     /** 
      * Subscriber function that invokes the callable and returns its value or
      * propagates its checked exception.
      */
-    public static <R> OnSubscribeFunc<R> fromCallable(Callable<? extends R> callable) {
+    public static <R> OnSubscribe<R> fromCallable(Callable<? extends R> callable) {
         return new InvokeAsync<R>(callable);
     }
     /** Subscriber function that invokes a runnable and returns the given result. */
-    public static <R> OnSubscribeFunc<R> fromRunnable(final Runnable run, final R result) {
+    public static <R> OnSubscribe<R> fromRunnable(final Runnable run, final R result) {
         return new InvokeAsync<R>(new Func0<R>() {
             @Override
             public R call() {
@@ -72,7 +59,7 @@ public R call() {
      * Invokes a java.util.concurrent.Callable when an observer subscribes.
      * @param <R> the return type
      */
-    static final class InvokeAsync<R> implements OnSubscribeFunc<R> {
+    static final class InvokeAsync<R> implements OnSubscribe<R> {
         final Callable<? extends R> callable;
         public InvokeAsync(Callable<? extends R> callable) {
             if (callable == null) {
@@ -81,16 +68,14 @@ public InvokeAsync(Callable<? extends R> callable) {
             this.callable = callable;
         }
         @Override
-        public Subscription onSubscribe(Observer<? super R> t1) {
-            Subscription s = Subscriptions.empty();
+        public void call(Subscriber<? super R> t1) {
             try {
                 t1.onNext(callable.call());
             } catch (Throwable t) {
                 t1.onError(t);
-                return s;
+                return;
             }
             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/OperatorStartFuture.java
similarity index 75%
rename from rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperationStartFuture.java
rename to rxjava-contrib/rxjava-async-util/src/main/java/rx/util/async/operators/OperatorStartFuture.java
index 3cb0e434f9..25ce2c62f4 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/OperatorStartFuture.java
@@ -13,21 +13,6 @@
  * 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.util.async.operators;
 
 import java.util.concurrent.Future;
@@ -40,9 +25,9 @@
  * Start an asynchronous Future immediately and observe its result through
  * an observable.
  */
-public final class OperationStartFuture {
+public final class OperatorStartFuture {
     /** Utility class. */
-    private OperationStartFuture() { throw new IllegalStateException("No instances!"); }
+    private OperatorStartFuture() { throw new IllegalStateException("No instances!"); }
     /**
      * Invokes the asynchronous function, surfacing the result through an observable sequence.
      * <p>
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 aead8ef078..d156ca4ab4 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
@@ -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-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/OperatorDeferFutureTest.java
similarity index 91%
rename from rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationDeferFutureTest.java
rename to rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorDeferFutureTest.java
index 8eddc63820..16a703e2d6 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/OperatorDeferFutureTest.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.
@@ -35,7 +35,7 @@
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
 
-public class OperationDeferFutureTest {
+public class OperatorDeferFutureTest {
     @Test
     @SuppressWarnings("unchecked")
     public void testSimple() throws InterruptedException {
@@ -64,7 +64,7 @@ public Observable<Integer> call() throws Exception {
 
             final CountDownLatch done = new CountDownLatch(1);
 
-            result.subscribe(new OperationStartFutureTest.MockHelper<Integer>(observer, done));
+            result.subscribe(new OperatorStartFutureTest.MockHelper<Integer>(observer, done));
 
             ready.countDown();
 
@@ -89,7 +89,7 @@ public void testSimpleFactoryThrows() {
 
             @Override
             public Future<Observable<Integer>> call() {
-                throw new OperationStartFutureTest.CustomException();
+                throw new OperatorStartFutureTest.CustomException();
             }
         };
         
@@ -100,6 +100,6 @@ public Future<Observable<Integer>> call() {
         
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        verify(observer).onError(any(OperationStartFutureTest.CustomException.class));
+        verify(observer).onError(any(OperatorStartFutureTest.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/OperatorForEachFutureTest.java
similarity index 99%
rename from rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationForEachFutureTest.java
rename to rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorForEachFutureTest.java
index 75e6ff074a..0d8a60c85b 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/OperatorForEachFutureTest.java
@@ -47,7 +47,7 @@
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
 
-public class OperationForEachFutureTest {
+public class OperatorForEachFutureTest {
     @Test
     public void testSimple() {
         final ExecutorService exec = Executors.newCachedThreadPool();
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/OperatorFromFunctionalsTest.java
similarity index 76%
rename from rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationFromFunctionalsTest.java
rename to rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorFromFunctionalsTest.java
index f89d58ccc5..ce31712175 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/OperatorFromFunctionalsTest.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.
@@ -16,7 +16,6 @@
 
 package rx.util.async.operators;
 
-import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
 
 import java.io.IOException;
@@ -38,7 +37,7 @@
 import rx.schedulers.TestScheduler;
 import rx.util.async.Async;
 
-public class OperationFromFunctionalsTest {
+public class OperatorFromFunctionalsTest {
     TestScheduler scheduler;
     @Before
     public void before() {
@@ -47,6 +46,7 @@ public void before() {
     private void testRunShouldThrow(Observable<Integer> source, Class<? extends Throwable> exception) {
         for (int i = 0; i < 3; i++) {
             
+            @SuppressWarnings("unchecked")
             Observer<Object> observer = mock(Observer.class);
             source.subscribe(new TestObserver<Object>(observer));
 
@@ -79,6 +79,7 @@ public void call() {
             
             value.set(0);
             
+            @SuppressWarnings("unchecked")
             Observer<Object> observer = mock(Observer.class);
             source.subscribe(new TestObserver<Object>(observer));
 
@@ -111,62 +112,6 @@ public void call() {
         testRunShouldThrow(source, RuntimeException.class);
     }
 
-    /**
-     * @deprecated  {@link Func0} now extends {@link Callable}, so
-     *              {@link Async#fromFunc0(Func0)} is unnecessary. Once it's
-     *              removed, this test can be removed as well.
-     */
-    @Deprecated
-    @Test
-    public void testFromFunc0() {
-        Func0<Integer> func = new Func0<Integer>() {
-            @Override
-            public Integer call() {
-                return 1;
-            }
-        };
-        
-        Observable<Integer> source = Async.fromFunc0(func, scheduler);
-        
-        for (int i = 0; i < 3; i++) {
-            
-            Observer<Object> observer = mock(Observer.class);
-            source.subscribe(new TestObserver<Object>(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));
-        }
-    }
-
-    /**
-     * @deprecated  {@link Func0} now extends {@link Callable}, so
-     *              {@link Async#fromFunc0(Func0, rx.Scheduler)} is
-     *              unnecessary. Once it's removed, this test can be removed
-     *              as well.
-     */
-    @Deprecated
-    @Test
-    public void testFromFunc0Throws() {
-        Func0<Integer> func = new Func0<Integer>() {
-            @Override
-            public Integer call() {
-                throw new RuntimeException("Forced failure!");
-            }
-        };
-        
-        Observable<Integer> source = Async.fromFunc0(func, scheduler);
-        
-        testRunShouldThrow(source, RuntimeException.class);
-    }
     @Test
     public void testFromRunnable() {
         final AtomicInteger value = new AtomicInteger();
@@ -184,6 +129,7 @@ public void run() {
             
             value.set(0);
             
+            @SuppressWarnings("unchecked")
             Observer<Object> observer = mock(Observer.class);
             source.subscribe(new TestObserver<Object>(observer));
 
@@ -228,6 +174,7 @@ public Integer call() throws Exception {
         
         for (int i = 0; i < 3; i++) {
             
+            @SuppressWarnings("unchecked")
             Observer<Object> observer = mock(Observer.class);
             source.subscribe(new TestObserver<Object>(observer));
 
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/OperatorStartFutureTest.java
similarity index 98%
rename from rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperationStartFutureTest.java
rename to rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorStartFutureTest.java
index 42856ba2d7..66948f906f 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/OperatorStartFutureTest.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.
@@ -35,7 +35,7 @@
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
 
-public class OperationStartFutureTest {
+public class OperatorStartFutureTest {
     /** Custom exception to distinguish from any other RuntimeException. */
     static class CustomException extends RuntimeException {}
     /** 

From 943c5448752b374e74cc2faccd56b779417eb4f2 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 25 Apr 2014 16:47:28 +0200
Subject: [PATCH 289/422] Removed deprecated API

---
 .../src/main/java/rx/util/async/Async.java    | 50 -------------------
 1 file changed, 50 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 80ba5f3ea3..ce6962837a 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
@@ -1617,30 +1617,6 @@ public static <R> Observable<R> fromAction(Action0 action, R result) {
         return fromAction(action, result, Schedulers.computation());
     }
     
-    /**
-     * Return an Observable that calls the given function and emits its
-     * result when an Observer subscribes.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromFunc0.png">
-     * <p>
-     * The function is called on the default thread pool for computation.
-     * 
-     * @param <R> the return type
-     * @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.functions.Func0) 
-     * @see #fromCallable(java.util.concurrent.Callable) 
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromfunc0">RxJava Wiki: fromFunc0()</a>
-     *
-     * @deprecated  Unnecessary now that Func0 extends Callable. Just call
-     *              {@link #fromCallable(Callable)} instead.
-     */
-    @Deprecated
-    public static <R> Observable<R> fromFunc0(Func0<? extends R> function) {
-        return fromCallable(function);
-    }
-
     /**
      * Return an Observable that calls the given Callable and emits its
      * result or Exception when an Observer subscribes.
@@ -1654,7 +1630,6 @@ public static <R> Observable<R> fromFunc0(Func0<? extends R> function) {
      * @return an Observable that calls the given Callable and emits its
      *         result or Exception when an Observer subscribes
      * @see #start(rx.functions.Func0) 
-     * @see #fromFunc0(rx.functions.Func0) 
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromcallable">RxJava Wiki: fromCallable()</a>
      */
     public static <R> Observable<R> fromCallable(Callable<? extends R> callable) {
@@ -1699,30 +1674,6 @@ public static <R> Observable<R> fromAction(Action0 action, R result, Scheduler s
         return Observable.create(OperatorFromFunctionals.fromAction(action, result)).subscribeOn(scheduler);
     }
     
-    /**
-     * Return an Observable that calls the given function and emits its
-     * result when an Observer subscribes.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromFunc0.s.png">
-     * 
-     * @param <R> 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 that calls the given function and emits its
-     *         result when an Observer subscribes
-     * @see #start(rx.functions.Func0) 
-     * @see #fromCallable(java.util.concurrent.Callable) 
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromfunc0">RxJava Wiki: fromFunc0()</a>
-     *
-     * @deprecated  Unnecessary now that Func0 extends Callable. Just call
-     *              {@link #fromCallable(Callable, Scheduler)} instead.
-     */
-    @Deprecated
-    public static <R> Observable<R> fromFunc0(Func0<? extends R> function, Scheduler scheduler) {
-        return fromCallable(function, scheduler);
-    }
-
     /**
      * Return an Observable that calls the given Callable and emits its
      * result or Exception when an Observer subscribes.
@@ -1736,7 +1687,6 @@ public static <R> Observable<R> fromFunc0(Func0<? extends R> function, Scheduler
      * @return an Observable that calls the given Callable and emits its
      *         result or Exception when an Observer subscribes
      * @see #start(rx.functions.Func0) 
-     * @see #fromFunc0(rx.functions.Func0) 
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromcallable">RxJava Wiki: fromCallable()</a>
      */
     public static <R> Observable<R> fromCallable(Callable<? extends R> callable, Scheduler scheduler) {

From cc1776de75dc18e8280f6c88b78e1898df311520 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 25 Apr 2014 18:52:52 +0200
Subject: [PATCH 290/422] OperatorJoin

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../main/java/rx/operators/OperationJoin.java | 308 -----------------
 .../main/java/rx/operators/OperatorJoin.java  | 326 ++++++++++++++++++
 ...ionJoinTest.java => OperatorJoinTest.java} |   2 +-
 4 files changed, 329 insertions(+), 311 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationJoin.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorJoin.java
 rename rxjava-core/src/test/java/rx/operators/{OperationJoinTest.java => OperatorJoinTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..624e34ee36 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -53,7 +53,6 @@
 import rx.operators.OperationGroupByUntil;
 import rx.operators.OperationGroupJoin;
 import rx.operators.OperationInterval;
-import rx.operators.OperationJoin;
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMulticast;
@@ -100,6 +99,7 @@
 import rx.operators.OperatorFilter;
 import rx.operators.OperatorFinally;
 import rx.operators.OperatorGroupBy;
+import rx.operators.OperatorJoin;
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMaterialize;
 import rx.operators.OperatorMerge;
@@ -4165,7 +4165,7 @@ public final Observable<Boolean> isEmpty() {
     public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> join(Observable<TRight> right, Func1<T, Observable<TLeftDuration>> leftDurationSelector,
             Func1<TRight, Observable<TRightDuration>> rightDurationSelector,
             Func2<T, TRight, R> resultSelector) {
-        return create(new OperationJoin<T, TRight, TLeftDuration, TRightDuration, R>(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
+        return create(new OperatorJoin<T, TRight, TLeftDuration, TRightDuration, R>(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationJoin.java b/rxjava-core/src/main/java/rx/operators/OperationJoin.java
deleted file mode 100644
index 21f667bbe3..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationJoin.java
+++ /dev/null
@@ -1,308 +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.HashMap;
-import java.util.Map;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func1;
-import rx.functions.Func2;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-
-/**
- * Correlates the elements of two sequences based on overlapping durations.
- */
-public class OperationJoin<TLeft, TRight, TLeftDuration, TRightDuration, R> implements OnSubscribeFunc<R> {
-    final Observable<TLeft> left;
-    final Observable<TRight> right;
-    final Func1<TLeft, Observable<TLeftDuration>> leftDurationSelector;
-    final Func1<TRight, Observable<TRightDuration>> rightDurationSelector;
-    final Func2<TLeft, TRight, R> resultSelector;
-
-    public OperationJoin(
-            Observable<TLeft> left,
-            Observable<TRight> right,
-            Func1<TLeft, Observable<TLeftDuration>> leftDurationSelector,
-            Func1<TRight, Observable<TRightDuration>> rightDurationSelector,
-            Func2<TLeft, TRight, R> resultSelector) {
-        this.left = left;
-        this.right = right;
-        this.leftDurationSelector = leftDurationSelector;
-        this.rightDurationSelector = rightDurationSelector;
-        this.resultSelector = resultSelector;
-    }
-
-    @Override
-    public Subscription onSubscribe(Observer<? super R> t1) {
-        SerialSubscription cancel = new SerialSubscription();
-        ResultSink result = new ResultSink(t1, cancel);
-        cancel.set(result.run());
-        return cancel;
-    }
-
-    /** Manage the left and right sources. */
-    class ResultSink {
-        final Object gate = new Object();
-        final CompositeSubscription group = new CompositeSubscription();
-        boolean leftDone;
-        int leftId;
-        final Map<Integer, TLeft> leftMap = new HashMap<Integer, TLeft>();
-        boolean rightDone;
-        int rightId;
-        final Map<Integer, TRight> rightMap = new HashMap<Integer, TRight>();
-        final Observer<? super R> observer;
-        final Subscription cancel;
-
-        public ResultSink(Observer<? super R> 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.set(left.unsafeSubscribe(new LeftObserver(leftCancel)));
-            rightCancel.set(right.unsafeSubscribe(new RightObserver(rightCancel)));
-
-            return group;
-        }
-
-        /** Observes the left values. */
-        class LeftObserver extends Subscriber<TLeft> {
-            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) {
-                        observer.onCompleted();
-                        cancel.unsubscribe();
-                    }
-                }
-                group.remove(resource);
-            }
-
-            @Override
-            public void onNext(TLeft args) {
-                int id, highRightId;
-
-                synchronized (gate) {
-                    id = leftId++;
-                    leftMap.put(id, args);
-                    highRightId = rightId;
-                }
-                SerialSubscription md = new SerialSubscription();
-                group.add(md);
-
-                Observable<TLeftDuration> duration;
-                try {
-                    duration = leftDurationSelector.call(args);
-                } catch (Throwable t) {
-                    observer.onError(t);
-                    cancel.unsubscribe();
-                    return;
-                }
-
-                md.set(duration.unsafeSubscribe(new LeftDurationObserver(id, md)));
-
-                synchronized (gate) {
-                    for (Map.Entry<Integer, TRight> 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);
-                        }
-                    }
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                synchronized (gate) {
-                    observer.onError(e);
-                    cancel.unsubscribe();
-                }
-            }
-
-            @Override
-            public void onCompleted() {
-                synchronized (gate) {
-                    leftDone = true;
-                    if (rightDone || leftMap.isEmpty()) {
-                        observer.onCompleted();
-                        cancel.unsubscribe();
-                    } else {
-                        self.unsubscribe();
-                    }
-                }
-            }
-
-            /** Observes the left duration. */
-            class LeftDurationObserver extends Subscriber<TLeftDuration> {
-                final int id;
-                final Subscription handle;
-
-                public LeftDurationObserver(int id, Subscription handle) {
-                    this.id = id;
-                    this.handle = handle;
-                }
-
-                @Override
-                public void onNext(TLeftDuration args) {
-                    expire(id, handle);
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    LeftObserver.this.onError(e);
-                }
-
-                @Override
-                public void onCompleted() {
-                    expire(id, handle);
-                }
-
-            }
-        }
-
-        /** Observes the right values. */
-        class RightObserver extends Subscriber<TRight> {
-            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) {
-                        observer.onCompleted();
-                        cancel.unsubscribe();
-                    }
-                }
-                group.remove(resource);
-            }
-
-            @Override
-            public void onNext(TRight args) {
-                int id = 0, highLeftId;
-                synchronized (gate) {
-                    id = rightId++;
-                    rightMap.put(id, args);
-                    highLeftId = leftId;
-                }
-                SerialSubscription md = new SerialSubscription();
-                group.add(md);
-
-                Observable<TRightDuration> duration;
-                try {
-                    duration = rightDurationSelector.call(args);
-                } catch (Throwable t) {
-                    observer.onError(t);
-                    cancel.unsubscribe();
-                    return;
-                }
-
-                md.set(duration.unsafeSubscribe(new RightDurationObserver(id, md)));
-
-                synchronized (gate) {
-                    for (Map.Entry<Integer, TLeft> 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);
-                        }
-                    }
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                synchronized (gate) {
-                    observer.onError(e);
-                    cancel.unsubscribe();
-                }
-            }
-
-            @Override
-            public void onCompleted() {
-                synchronized (gate) {
-                    rightDone = true;
-                    if (leftDone || rightMap.isEmpty()) {
-                        observer.onCompleted();
-                        cancel.unsubscribe();
-                    } else {
-                        self.unsubscribe();
-                    }
-                }
-            }
-
-            /** Observe the right duration. */
-            class RightDurationObserver extends Subscriber<TRightDuration> {
-                final int id;
-                final Subscription handle;
-
-                public RightDurationObserver(int id, Subscription handle) {
-                    this.id = id;
-                    this.handle = handle;
-                }
-
-                @Override
-                public void onNext(TRightDuration args) {
-                    expire(id, handle);
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    RightObserver.this.onError(e);
-                }
-
-                @Override
-                public void onCompleted() {
-                    expire(id, handle);
-                }
-
-            }
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorJoin.java b/rxjava-core/src/main/java/rx/operators/OperatorJoin.java
new file mode 100644
index 0000000000..8cf140b3ae
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorJoin.java
@@ -0,0 +1,326 @@
+/**
+ * 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.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.SerialSubscription;
+
+/**
+ * Correlates the elements of two sequences based on overlapping durations.
+ * 
+ * @param <TLeft> the left value type
+ * @param <TRight> the right value type
+ * @param <TLeftDuration> the left duration value type
+ * @param <TRightDuration> the right duration type
+ * @param <R> the result type
+ */
+public final class OperatorJoin<TLeft, TRight, TLeftDuration, TRightDuration, R> implements OnSubscribe<R> {
+    final Observable<TLeft> left;
+    final Observable<TRight> right;
+    final Func1<TLeft, Observable<TLeftDuration>> leftDurationSelector;
+    final Func1<TRight, Observable<TRightDuration>> rightDurationSelector;
+    final Func2<TLeft, TRight, R> resultSelector;
+
+    public OperatorJoin(
+            Observable<TLeft> left,
+            Observable<TRight> right,
+            Func1<TLeft, Observable<TLeftDuration>> leftDurationSelector,
+            Func1<TRight, Observable<TRightDuration>> rightDurationSelector,
+            Func2<TLeft, TRight, R> resultSelector) {
+        this.left = left;
+        this.right = right;
+        this.leftDurationSelector = leftDurationSelector;
+        this.rightDurationSelector = rightDurationSelector;
+        this.resultSelector = resultSelector;
+    }
+
+    @Override
+    public void call(Subscriber<? super R> t1) {
+        ResultSink result = new ResultSink(new SerializedSubscriber<R>(t1));
+        result.run();
+    }
+
+    /** Manage the left and right sources. */
+    final class ResultSink {
+        final CompositeSubscription group;
+        final Subscriber<? super R> subscriber;
+        final Object guard = new Object();
+        /** Guarded by guard. */
+        boolean leftDone;
+        /** Guarded by guard. */
+        int leftId;
+        /** Guarded by guard. */
+        final Map<Integer, TLeft> leftMap;
+        /** Guarded by guard. */
+        boolean rightDone;
+        /** Guarded by guard. */
+        int rightId;
+        /** Guarded by guard. */
+        final Map<Integer, TRight> rightMap;
+
+        public ResultSink(Subscriber<? super R> subscriber) {
+            this.subscriber = subscriber;
+            this.group = new CompositeSubscription();
+            this.leftMap = new HashMap<Integer, TLeft>();
+            this.rightMap = new HashMap<Integer, TRight>();
+        }
+
+        public void run() {
+            subscriber.add(group);
+            
+            Subscriber<TLeft> s1 = new LeftSubscriber();
+            Subscriber<TRight> s2 = new RightSubscriber();
+            
+            group.add(s1);
+            group.add(s2);
+
+            left.unsafeSubscribe(s1);
+            right.unsafeSubscribe(s2);
+        }
+
+        /** Observes the left values. */
+        final class LeftSubscriber extends Subscriber<TLeft> {
+
+            protected void expire(int id, Subscription resource) {
+                boolean complete = false;
+                synchronized (guard) {
+                    if (leftMap.remove(id) != null && leftMap.isEmpty() && leftDone) {
+                        complete = true;
+                    }
+                }
+                if (complete) {
+                    subscriber.onCompleted();
+                    subscriber.unsubscribe();
+                } else {
+                    group.remove(resource);
+                }
+            }
+
+            @Override
+            public void onNext(TLeft args) {
+                int id;
+                int highRightId;
+
+                synchronized (guard) {
+                    id = leftId++;
+                    leftMap.put(id, args);
+                    highRightId = rightId;
+                }
+
+                Observable<TLeftDuration> duration;
+                try {
+                    duration = leftDurationSelector.call(args);
+
+                    Subscriber<TLeftDuration> d1 = new LeftDurationSubscriber(id);
+                    group.add(d1);
+
+                    duration.unsafeSubscribe(d1);
+
+                    List<TRight> rightValues = new ArrayList<TRight>();
+                    synchronized (guard) {
+                        for (Map.Entry<Integer, TRight> entry : rightMap.entrySet()) {
+                            if (entry.getKey() < highRightId) {
+                                rightValues.add(entry.getValue());
+                            }
+                        }
+                    }
+                    for (TRight r : rightValues) {
+                        R result = resultSelector.call(args, r);
+                        subscriber.onNext(result);
+                    }
+                } catch (Throwable t) {
+                    onError(t);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+                subscriber.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                boolean complete = false;
+                synchronized (guard) {
+                    leftDone = true;
+                    if (rightDone || leftMap.isEmpty()) {
+                        complete = true;
+                    }
+                }
+                if (complete) {
+                    subscriber.onCompleted();
+                    subscriber.unsubscribe();
+                } else {
+                    group.remove(this);
+                }
+            }
+
+            /** Observes the left duration. */
+            final class LeftDurationSubscriber extends Subscriber<TLeftDuration> {
+                final int id;
+                boolean once = true;
+
+                public LeftDurationSubscriber(int id) {
+                    this.id = id;
+                }
+
+                @Override
+                public void onNext(TLeftDuration args) {
+                    onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    LeftSubscriber.this.onError(e);
+                }
+
+                @Override
+                public void onCompleted() {
+                    if (once) {
+                        once = false;
+                        expire(id, this);
+                    }
+                }
+
+            }
+        }
+
+        /** Observes the right values. */
+        final class RightSubscriber extends Subscriber<TRight> {
+
+            void expire(int id, Subscription resource) {
+                boolean complete = false;
+                synchronized (guard) {
+                    if (rightMap.remove(id) != null && rightMap.isEmpty() && rightDone) {
+                        complete = true;
+                    }
+                }
+                if (complete) {
+                    subscriber.onCompleted();
+                    subscriber.unsubscribe();
+                } else {
+                    group.remove(resource);
+                }
+            }
+
+            @Override
+            public void onNext(TRight args) {
+                int id; 
+                int highLeftId;
+                synchronized (guard) {
+                    id = rightId++;
+                    rightMap.put(id, args);
+                    highLeftId = leftId;
+                }
+                SerialSubscription md = new SerialSubscription();
+                group.add(md);
+
+                Observable<TRightDuration> duration;
+                try {
+                    duration = rightDurationSelector.call(args);
+
+                    Subscriber<TRightDuration> d2 = new RightDurationSubscriber(id);
+                    group.add(d2);
+                    
+                    duration.unsafeSubscribe(d2);
+                    
+
+                    List<TLeft> leftValues = new ArrayList<TLeft>();
+                    synchronized (guard) {
+                        for (Map.Entry<Integer, TLeft> entry : leftMap.entrySet()) {
+                            if (entry.getKey() < highLeftId) {
+                                leftValues.add(entry.getValue());
+                            }
+                        }
+                    }
+                    
+                    for (TLeft lv : leftValues) {
+                        R result = resultSelector.call(lv, args);
+                        subscriber.onNext(result);
+                    }
+                    
+                } catch (Throwable t) {
+                    onError(t);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+                subscriber.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                boolean complete = false;
+                synchronized (guard) {
+                    rightDone = true;
+                    if (leftDone || rightMap.isEmpty()) {
+                        complete = true;
+                    }
+                }
+                if (complete) {
+                    subscriber.onCompleted();
+                    subscriber.unsubscribe();
+                } else {
+                    group.remove(this);
+                }
+            }
+
+            /** Observe the right duration. */
+            final class RightDurationSubscriber extends Subscriber<TRightDuration> {
+                final int id;
+                boolean once = true;
+
+                public RightDurationSubscriber(int id) {
+                    this.id = id;
+                }
+
+                @Override
+                public void onNext(TRightDuration args) {
+                    onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    RightSubscriber.this.onError(e);
+                }
+
+                @Override
+                public void onCompleted() {
+                    if (once) {
+                        once = false;
+                        expire(id, this);
+                    }
+                }
+
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java b/rxjava-core/src/test/java/rx/operators/OperatorJoinTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorJoinTest.java
index 4dded27527..52952c970a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationJoinTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorJoinTest.java
@@ -31,7 +31,7 @@
 import rx.functions.Func2;
 import rx.subjects.PublishSubject;
 
-public class OperationJoinTest {
+public class OperatorJoinTest {
     @Mock
     Observer<Object> observer;
 

From 96939a7dfd2d07488fabcc36fa95a48a6233604e Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 25 Apr 2014 20:07:32 +0200
Subject: [PATCH 291/422] OperatorMergeDelayError

---
 rxjava-core/src/main/java/rx/Observable.java  |  34 +-
 .../operators/OperationMergeDelayError.java   | 333 ------------------
 .../rx/operators/OperatorMergeDelayError.java | 133 +++++++
 ....java => OperatorMergeDelayErrorTest.java} | 108 ++++--
 4 files changed, 217 insertions(+), 391 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMergeDelayError.java
 rename rxjava-core/src/test/java/rx/operators/{OperationMergeDelayErrorTest.java => OperatorMergeDelayErrorTest.java} (83%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..200e52d606 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -54,7 +54,6 @@
 import rx.operators.OperationGroupJoin;
 import rx.operators.OperationInterval;
 import rx.operators.OperationJoin;
-import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMulticast;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
@@ -103,6 +102,7 @@
 import rx.operators.OperatorMap;
 import rx.operators.OperatorMaterialize;
 import rx.operators.OperatorMerge;
+import rx.operators.OperatorMergeDelayError;
 import rx.operators.OperatorMergeMapPair;
 import rx.operators.OperatorMergeMapTransform;
 import rx.operators.OperatorObserveOn;
@@ -2001,7 +2001,7 @@ public final static <T> Observable<T> merge(Observable<? extends T>[] sequences,
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
     public final static <T> Observable<T> mergeDelayError(Observable<? extends Observable<? extends T>> source) {
-        return create(OperationMergeDelayError.mergeDelayError(source));
+        return source.lift(new OperatorMergeDelayError<T>());
     }
 
     /**
@@ -2025,10 +2025,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends Obser
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2));
+        return mergeDelayError(from(t1, t2));
     }
 
     /**
@@ -2055,10 +2053,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3));
+        return mergeDelayError(from(t1, t2, t3));
     }
 
     /**
@@ -2087,10 +2083,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4));
+        return mergeDelayError(from(t1, t2, t3, t4));
     }
 
     /**
@@ -2120,10 +2114,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5));
+        return mergeDelayError(from(t1, t2, t3, t4, t5));
     }
 
     /**
@@ -2155,10 +2147,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6));
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6));
     }
 
     /**
@@ -2192,10 +2182,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6, t7));
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7));
     }
 
     /**
@@ -2234,7 +2222,7 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
     @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6, t7, t8));
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7, t8));
     }
 
     /**
@@ -2272,10 +2260,8 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
-        return create(OperationMergeDelayError.mergeDelayError(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
deleted file mode 100644
index d5eacf649a..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeDelayError.java
+++ /dev/null
@@ -1,333 +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.List;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.exceptions.CompositeException;
-import rx.observers.SerializedObserver;
-import rx.subscriptions.BooleanSubscription;
-import rx.subscriptions.CompositeSubscription;
-
-/**
- * This behaves like {@link OperatorMerge} except that if any of the merged Observables notify of
- * an error via <code>onError</code>, mergeDelayError will refrain from propagating that error
- * notification until all of the merged Observables have finished emitting items.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/mergeDelayError.png">
- * <p>
- * Even if multiple merged Observables send <code>onError</code> notifications, mergeDelayError will
- * only invoke the <code>onError</code> method of its Observers once.
- * <p>
- * This operation 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.
- * <p>
- * NOTE: If this is used on an Observable that never completes, it will never call
- * <code>onError</code> and will effectively swallow errors.
- */
-public final class OperationMergeDelayError {
-
-    /**
-     * Flattens the observable sequences from the list of Observables into one observable sequence
-     * without any transformation and delays any onError calls until after all sequences have called
-     * onError or onComplete so as to allow all successful onNext calls to be received.
-     * 
-     * @param sequences
-     *            An observable sequence of elements to project.
-     * @return An observable sequence whose elements are the result of flattening the output from the list of Observables.
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099(v=vs.103).aspx">Observable.Merge(TSource) Method (IObservable(TSource)[])</a>
-     */
-    public static <T> OnSubscribeFunc<T> mergeDelayError(final Observable<? extends Observable<? extends T>> sequences) {
-        // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new MergeDelayErrorObservable<T>(sequences).onSubscribe(observer);
-            }
-        };
-    }
-
-    public static <T> OnSubscribeFunc<T> mergeDelayError(final Observable<? extends T>... sequences) {
-        return mergeDelayError(Observable.create(new OnSubscribeFunc<Observable<? extends T>>() {
-            private final BooleanSubscription s = new BooleanSubscription();
-
-            @Override
-            public Subscription onSubscribe(Observer<? super Observable<? extends T>> observer) {
-                for (Observable<? extends T> o : sequences) {
-                    if (!s.isUnsubscribed()) {
-                        observer.onNext(o);
-                    } else {
-                        // break out of the loop if we are unsubscribed
-                        break;
-                    }
-                }
-                if (!s.isUnsubscribed()) {
-                    observer.onCompleted();
-                }
-                return s;
-            }
-        }));
-    }
-
-    public static <T> OnSubscribeFunc<T> mergeDelayError(final List<? extends Observable<? extends T>> sequences) {
-        return mergeDelayError(Observable.create(new OnSubscribeFunc<Observable<? extends T>>() {
-
-            private final BooleanSubscription s = new BooleanSubscription();
-
-            @Override
-            public Subscription onSubscribe(Observer<? super Observable<? extends T>> observer) {
-                for (Observable<? extends T> o : sequences) {
-                    if (!s.isUnsubscribed()) {
-                        observer.onNext(o);
-                    } else {
-                        // break out of the loop if we are unsubscribed
-                        break;
-                    }
-                }
-                if (!s.isUnsubscribed()) {
-                    observer.onCompleted();
-                }
-
-                return s;
-            }
-        }));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * It IS thread-safe from within it while receiving onNext events from multiple threads.
-     * <p>
-     * 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.
-     * <p>
-     * Note how the take() factory method above protects us from a single instance being exposed with the Observable wrapper handling the subscribe flow.
-     * 
-     * @param <T>
-     */
-    private static final class MergeDelayErrorObservable<T> implements OnSubscribeFunc<T> {
-        private final Observable<? extends Observable<? extends T>> sequences;
-        private final MergeSubscription ourSubscription = new MergeSubscription();
-        private AtomicBoolean stopped = new AtomicBoolean(false);
-        private volatile boolean parentCompleted = false;
-        private final ConcurrentHashMap<ChildObserver, ChildObserver> childObservers = new ConcurrentHashMap<ChildObserver, ChildObserver>();
-        private final ConcurrentHashMap<ChildObserver, Subscription> childSubscriptions = new ConcurrentHashMap<ChildObserver, Subscription>();
-        // onErrors we received that will be delayed until everything is completed and then sent
-        private ConcurrentLinkedQueue<Throwable> onErrorReceived = new ConcurrentLinkedQueue<Throwable>();
-
-        private MergeDelayErrorObservable(Observable<? extends Observable<? extends T>> sequences) {
-            this.sequences = sequences;
-        }
-
-        public Subscription onSubscribe(Observer<? super T> actualObserver) {
-            CompositeSubscription completeSubscription = new CompositeSubscription();
-            SerializedObserver<T> synchronizedObserver = new SerializedObserver<T>(actualObserver);
-
-            /**
-             * Subscribe to the parent Observable to get to the children Observables
-             */
-            completeSubscription.add(sequences.unsafeSubscribe(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.
-         * <p>
-         * 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;
-                }
-            }
-
-            @Override
-            public boolean isUnsubscribed() {
-                return stopped.get();
-            }
-        }
-
-        /**
-         * Subscribe to the top level Observable to receive the sequence of Observable<T> children.
-         * 
-         * @param <T>
-         */
-        private class ParentObserver extends Subscriber<Observable<? extends T>> {
-            private final Observer<? super T> actualObserver;
-
-            public ParentObserver(Observer<? super T> actualObserver) {
-                this.actualObserver = actualObserver;
-            }
-
-            @Override
-            public void onCompleted() {
-                parentCompleted = true;
-                // 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()) {
-                            if (onErrorReceived.size() == 1) {
-                                // an onError was received from 1 ChildObserver so we now send it as a delayed error
-                                actualObserver.onError(onErrorReceived.peek());
-                            } else if (onErrorReceived.size() > 1) {
-                                // an onError was received from more than 1 ChildObserver so we now send it as a delayed error
-                                actualObserver.onError(new CompositeException(onErrorReceived));
-                            } else {
-                                // no delayed error so send onCompleted
-                                actualObserver.onCompleted();
-                            }
-                        }
-                    }
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                actualObserver.onError(e);
-            }
-
-            @Override
-            public void onNext(Observable<? extends T> childObservable) {
-                if (stopped.get()) {
-                    // we won't act on any further items
-                    return;
-                }
-
-                if (childObservable == null) {
-                    throw new IllegalArgumentException("Observable<T> 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.
-                 * <p>
-                 * 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.unsafeSubscribe(_w);
-                // remember this Observer and the subscription from it
-                childSubscriptions.put(_w, _subscription);
-            }
-        }
-
-        /**
-         * Subscribe to each child Observable<T> and forward their sequence of data to the actualObserver
-         * 
-         */
-        private class ChildObserver extends Subscriber<T> {
-
-            private final Observer<? super T> actualObserver;
-            private volatile boolean finished = false;
-
-            public ChildObserver(Observer<? super T> actualObserver) {
-                this.actualObserver = actualObserver;
-            }
-
-            @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()) {
-                    finishObserver();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                if (!stopped.get()) {
-                    onErrorReceived.add(e);
-                    // mark this ChildObserver as done
-                    childObservers.remove(this);
-                    // but do NOT forward to actualObserver as we want other ChildObservers to continue until completion
-                    // and we'll delay the sending of onError until all others are done
-
-                    // we mark finished==true as a safety to ensure that if further calls to onNext occur we ignore them
-                    finished = true;
-
-                    // check for whether the parent is completed and if so then perform the 'finishing' actions
-                    finishObserver();
-                }
-            }
-
-            /**
-             * onComplete and onError when called need to check for the parent being complete and if so send the onCompleted or onError to the actualObserver.
-             * <p>
-             * This does NOT get invoked if synchronous execution occurs, but will when asynchronously executing.
-             * <p>
-             * TestCase testErrorDelayed4WithThreading specifically tests this use case.
-             */
-            private void finishObserver() {
-                if (childObservers.size() == 0 && parentCompleted) {
-                    if (ourSubscription.stop()) {
-                        // this thread 'won' the race to unsubscribe/stop so let's send onError or onCompleted
-                        if (onErrorReceived.size() == 1) {
-                            // an onError was received from 1 ChildObserver so we now send it as a delayed error
-                            actualObserver.onError(onErrorReceived.peek());
-                        } else if (onErrorReceived.size() > 1) {
-                            // an onError was received from more than 1 ChildObserver so we now send it as a delayed error
-                            actualObserver.onError(new CompositeException(onErrorReceived));
-                        } else {
-                            // no delayed error so send onCompleted
-                            actualObserver.onCompleted();
-                        }
-                    }
-                }
-            }
-
-            @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 or an onError has been received and delayed
-                if (!stopped.get() && !finished) {
-                    actualObserver.onNext(args);
-                }
-            }
-
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMergeDelayError.java b/rxjava-core/src/main/java/rx/operators/OperatorMergeDelayError.java
new file mode 100644
index 0000000000..fd25aa544f
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMergeDelayError.java
@@ -0,0 +1,133 @@
+/**
+ * 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.AtomicInteger;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.exceptions.CompositeException;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * This behaves like {@link OperatorMerge} except that if any of the merged Observables notify of
+ * an error via <code>onError</code>, mergeDelayError will refrain from propagating that error
+ * notification until all of the merged Observables have finished emitting items.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/mergeDelayError.png">
+ * <p>
+ * Even if multiple merged Observables send <code>onError</code> notifications, mergeDelayError will
+ * only invoke the <code>onError</code> method of its Observers once.
+ * <p>
+ * This operation 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.
+ * <p>
+ * NOTE: If this is used on an Observable that never completes, it will never call
+ * <code>onError</code> and will effectively swallow errors.
+ * 
+ * @param <T> the source and result value type
+ */
+public final class OperatorMergeDelayError<T> implements Operator<T, Observable<? extends T>> {
+
+    @Override
+    public Subscriber<? super Observable<? extends T>> call(Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final CompositeSubscription csub = new CompositeSubscription();
+        child.add(csub);
+        final AtomicInteger wip = new AtomicInteger(1);
+        final ConcurrentLinkedQueue<Throwable> exceptions = new ConcurrentLinkedQueue<Throwable>();
+        
+        return new Subscriber<Observable<? extends T>>() {
+
+            @Override
+            public void onNext(Observable<? extends T> t) {
+                wip.incrementAndGet();
+                
+                Subscriber<T> itemSub = new Subscriber<T>() {
+                    /** Make sure terminal events are handled once to avoid wip problems. */
+                    boolean once = true;
+                    @Override
+                    public void onNext(T t) {
+                        // prevent misbehaving source to emit past the error
+                        if (once) {
+                            try {
+                                s.onNext(t);
+                            } catch (Throwable e) {
+                                // in case the source doesn't properly handle exceptions
+                                onError(e);
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        if (once) {
+                            once = false;
+                            error(e);
+                        }
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        if (once) {
+                            once = false;
+                            try {
+                                complete();
+                            } finally {
+                                csub.remove(this);
+                            }
+                        }
+                    }
+                    
+                };
+                csub.add(itemSub);
+                
+                t.unsafeSubscribe(itemSub);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                error(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                complete();
+            }
+            void error(Throwable e) {
+                exceptions.add(e);
+                complete();
+            }
+            void complete() {
+                if (wip.decrementAndGet() == 0) {
+                    if (exceptions.isEmpty()) {
+                        s.onCompleted();
+                    } else 
+                    if (exceptions.size() > 1) {
+                        s.onError(new CompositeException(exceptions));
+                    } else {
+                        s.onError(exceptions.peek());
+                    }
+                    exceptions.clear();
+                    unsubscribe();
+                }
+            }
+            
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
similarity index 83%
rename from rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
index 5d18afd363..1c340d4deb 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeDelayErrorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
@@ -18,27 +18,26 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static rx.operators.OperationMergeDelayError.mergeDelayError;
+import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
 import java.util.List;
 
 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.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.exceptions.CompositeException;
 import rx.subscriptions.Subscriptions;
 
-public class OperationMergeDelayErrorTest {
+public class OperatorMergeDelayErrorTest {
 
     @Mock
     Observer<String> stringObserver;
@@ -54,7 +53,7 @@ public void testErrorDelayed1() {
         final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", "three"));
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(o1, o2));
+        Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
 
         verify(stringObserver, times(1)).onError(any(NullPointerException.class));
@@ -75,7 +74,7 @@ public void testErrorDelayed2() {
         final Observable<String> o4 = Observable.create(new TestErrorObservable("nine"));
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(o1, o2, o3, o4));
+        Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
 
         verify(stringObserver, times(1)).onError(any(NullPointerException.class));
@@ -99,7 +98,7 @@ public void testErrorDelayed3() {
         final Observable<String> o4 = Observable.create(new TestErrorObservable("nine"));
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(o1, o2, o3, o4));
+        Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
 
         verify(stringObserver, times(1)).onError(any(NullPointerException.class));
@@ -123,7 +122,7 @@ public void testErrorDelayed4() {
         final Observable<String> o4 = Observable.create(new TestErrorObservable("nine", null));
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(o1, o2, o3, o4));
+        Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
 
         verify(stringObserver, times(1)).onError(any(NullPointerException.class));
@@ -148,7 +147,7 @@ public void testErrorDelayed4WithThreading() {
         final TestAsyncErrorObservable o4 = new TestAsyncErrorObservable("nine", null);
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(Observable.create(o1), Observable.create(o2), Observable.create(o3), Observable.create(o4)));
+        Observable<String> m = Observable.mergeDelayError(Observable.create(o1), Observable.create(o2), Observable.create(o3), Observable.create(o4));
         m.subscribe(stringObserver);
 
         try {
@@ -179,7 +178,7 @@ public void testCompositeErrorDelayed1() {
         final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", null));
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(o1, o2));
+        Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
 
         verify(stringObserver, times(1)).onError(any(CompositeException.class));
@@ -198,7 +197,7 @@ public void testCompositeErrorDelayed2() {
         final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", null));
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(o1, o2));
+        Observable<String> m = Observable.mergeDelayError(o1, o2);
         CaptureObserver w = new CaptureObserver();
         m.subscribe(w);
 
@@ -234,7 +233,7 @@ public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
             }
 
         });
-        Observable<String> m = Observable.create(mergeDelayError(observableOfObservables));
+        Observable<String> m = Observable.mergeDelayError(observableOfObservables);
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -248,7 +247,7 @@ public void testMergeArray() {
         final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(o1, o2));
+        Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -264,7 +263,7 @@ public void testMergeList() {
         listOfObservables.add(o1);
         listOfObservables.add(o2);
 
-        Observable<String> m = Observable.create(mergeDelayError(listOfObservables));
+        Observable<String> m = Observable.mergeDelayError(Observable.from(listOfObservables));
         m.subscribe(stringObserver);
 
         verify(stringObserver, never()).onError(any(Throwable.class));
@@ -278,7 +277,7 @@ public void testMergeArrayWithThreading() {
         final TestASynchronousObservable o2 = new TestASynchronousObservable();
 
         @SuppressWarnings("unchecked")
-        Observable<String> m = Observable.create(mergeDelayError(Observable.create(o1), Observable.create(o2)));
+        Observable<String> m = Observable.mergeDelayError(Observable.create(o1), Observable.create(o2));
         m.subscribe(stringObserver);
 
         try {
@@ -293,23 +292,20 @@ public void testMergeArrayWithThreading() {
         verify(stringObserver, times(1)).onCompleted();
     }
 
-    private static class TestSynchronousObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestSynchronousObservable implements Observable.OnSubscribe<String> {
 
         @Override
-        public Subscription onSubscribe(Observer<? super String> observer) {
-
+        public void call(Subscriber<? super String> observer) {
             observer.onNext("hello");
             observer.onCompleted();
-
-            return Subscriptions.empty();
         }
     }
 
-    private static class TestASynchronousObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestASynchronousObservable implements Observable.OnSubscribe<String> {
         Thread t;
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             t = new Thread(new Runnable() {
 
                 @Override
@@ -320,8 +316,6 @@ public void run() {
 
             });
             t.start();
-
-            return Subscriptions.empty();
         }
     }
 
@@ -370,7 +364,7 @@ public Subscription onSubscribe(final Observer<? super String> observer) {
         }
     }
 
-    private static class TestErrorObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestErrorObservable implements Observable.OnSubscribe<String> {
 
         String[] valuesToReturn;
 
@@ -379,7 +373,7 @@ private static class TestErrorObservable implements Observable.OnSubscribeFunc<S
         }
 
         @Override
-        public Subscription onSubscribe(Observer<? super String> observer) {
+        public void call(Subscriber<? super String> observer) {
             boolean errorThrown = false;
             for (String s : valuesToReturn) {
                 if (s == null) {
@@ -395,12 +389,10 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             if (!errorThrown) {
                 observer.onCompleted();
             }
-
-            return Subscriptions.empty();
         }
     }
 
-    private static class TestAsyncErrorObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestAsyncErrorObservable implements Observable.OnSubscribe<String> {
 
         String[] valuesToReturn;
 
@@ -411,7 +403,7 @@ private static class TestAsyncErrorObservable implements Observable.OnSubscribeF
         Thread t;
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             t = new Thread(new Runnable() {
 
                 @Override
@@ -436,8 +428,6 @@ public void run() {
 
             });
             t.start();
-
-            return Subscriptions.empty();
         }
     }
 
@@ -460,4 +450,54 @@ public void onNext(String args) {
         }
 
     }
+    @Test
+    public void testMergeSourceWhichDoesntPropagateExceptionBack() {
+        Observable<Integer> source = Observable.create(new OnSubscribe<Integer>() {
+            @Override
+            public void call(Subscriber<? super Integer> t1) {
+                try {
+                    t1.onNext(0);
+                    t1.onNext(1);
+                } catch (Throwable swallow) {
+                    
+                }
+                t1.onCompleted();
+            }
+        });
+        
+        Observable<Integer> result = Observable.mergeDelayError(source, Observable.just(2));
+        
+        @SuppressWarnings("unchecked")
+        final Observer<Integer> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.unsafeSubscribe(new Subscriber<Integer>() {
+            int calls;
+            @Override
+            public void onNext(Integer t) {
+                if (calls++ == 0) {
+                    throw new OperationReduceTest.CustomException();
+                }
+                o.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+            
+        });
+        
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o, never()).onNext(0);
+        inOrder.verify(o, never()).onNext(1);
+        inOrder.verify(o, never()).onNext(anyInt());
+        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o, never()).onCompleted();
+    }
 }

From 10956f3094cd6d59a207059ed3bca590c9e7acba Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 25 Apr 2014 20:11:19 +0200
Subject: [PATCH 292/422] Fix last test case.

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

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
index 1c340d4deb..87b6ba8144 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
@@ -457,10 +457,10 @@ public void testMergeSourceWhichDoesntPropagateExceptionBack() {
             public void call(Subscriber<? super Integer> t1) {
                 try {
                     t1.onNext(0);
-                    t1.onNext(1);
                 } catch (Throwable swallow) {
                     
                 }
+                t1.onNext(1);
                 t1.onCompleted();
             }
         });

From 91fbba8aea7d7258f6d9ac1cd500928abceeba62 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 25 Apr 2014 21:23:09 +0200
Subject: [PATCH 293/422] OperatorMergeMaxConcurrent

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../OperationMergeMaxConcurrent.java          | 219 ------------------
 .../operators/OperatorMergeMaxConcurrent.java | 127 ++++++++++
 ...va => OperatorMergeMaxConcurrentTest.java} |  33 ++-
 4 files changed, 161 insertions(+), 222 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
 rename rxjava-core/src/test/java/rx/operators/{OperationMergeMaxConcurrentTest.java => OperatorMergeMaxConcurrentTest.java} (80%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..bcfd142900 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -55,7 +55,6 @@
 import rx.operators.OperationInterval;
 import rx.operators.OperationJoin;
 import rx.operators.OperationMergeDelayError;
-import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMulticast;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
@@ -105,6 +104,7 @@
 import rx.operators.OperatorMerge;
 import rx.operators.OperatorMergeMapPair;
 import rx.operators.OperatorMergeMapTransform;
+import rx.operators.OperatorMergeMaxConcurrent;
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
@@ -1714,7 +1714,7 @@ public final static <T> Observable<T> merge(Observable<? extends Observable<? ex
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211914.aspx">MSDN: Observable.Merge</a>
      */
     public final static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source, int maxConcurrent) {
-        return Observable.create(OperationMergeMaxConcurrent.merge(source, maxConcurrent));
+        return source.lift(new OperatorMergeMaxConcurrent<T>(maxConcurrent));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java b/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
deleted file mode 100644
index 420e8a5fa0..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationMergeMaxConcurrent.java
+++ /dev/null
@@ -1,219 +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.LinkedList;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.observers.SerializedObserver;
-import rx.subscriptions.CompositeSubscription;
-
-/**
- * Flattens a list of Observables into one Observable sequence, without any transformation.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/merge.png">
- * <p>
- * 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 <T> OnSubscribeFunc<T> merge(final Observable<? extends Observable<? extends T>> o, final int maxConcurrent) {
-        if (maxConcurrent <= 0) {
-            throw new IllegalArgumentException("maxConcurrent must be positive");
-        }
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new MergeObservable<T>(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.
-     * <p>
-     * It IS thread-safe from within it while receiving onNext events from multiple threads.
-     * <p>
-     * 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.
-     * <p>
-     * Note how the take() factory method above protects us from a single instance being exposed with the Observable wrapper handling the subscribe flow.
-     * 
-     * @param <T>
-     */
-    private static final class MergeObservable<T> implements OnSubscribeFunc<T> {
-        private final Observable<? extends Observable<? extends T>> sequences;
-        private final CompositeSubscription ourSubscription = new CompositeSubscription();
-        private volatile boolean parentCompleted = false;
-        private final LinkedList<Observable<? extends T>> pendingObservables = new LinkedList<Observable<? extends T>>();
-        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<? extends Observable<? extends T>> sequences, int maxConcurrent) {
-            this.sequences = sequences;
-            this.maxConcurrent = maxConcurrent;
-        }
-
-        public Subscription onSubscribe(Observer<? super T> actualObserver) {
-
-            /**
-             * We must synchronize a merge because we subscribe to multiple sequences in parallel that will each be emitting.
-             * <p>
-             * The calls from each sequence must be serialized.
-             * <p>
-             * Bug report: https://github.com/Netflix/RxJava/issues/200
-             */
-            SafeObservableSubscription subscription = new SafeObservableSubscription(ourSubscription);
-            SerializedObserver<T> synchronizedObserver = new SerializedObserver<T>(
-                    new SafeObserver<T>(subscription, actualObserver)); // Create a SafeObserver as SynchronizedObserver does not automatically unsubscribe
-
-            /**
-             * Subscribe to the parent Observable to get to the children Observables
-             */
-            ourSubscription.add(sequences.unsafeSubscribe(new ParentObserver(synchronizedObserver)));
-
-            return subscription;
-        }
-
-        /**
-         * Subscribe to the top level Observable to receive the sequence of Observable<T> children.
-         * 
-         * @param <T>
-         */
-        private class ParentObserver extends Subscriber<Observable<? extends T>> {
-            private final SerializedObserver<T> serializedObserver;
-
-            public ParentObserver(SerializedObserver<T> serializedObserver) {
-                this.serializedObserver = serializedObserver;
-            }
-
-            @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()) {
-                    serializedObserver.onCompleted();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                serializedObserver.onError(e);
-            }
-
-            @Override
-            public void onNext(Observable<? extends T> childObservable) {
-                if (ourSubscription.isUnsubscribed()) {
-                    // we won't act on any further items
-                    return;
-                }
-
-                if (childObservable == null) {
-                    throw new IllegalArgumentException("Observable<T> can not be null.");
-                }
-
-                Observable<? extends T> observable = null;
-                synchronized (gate) {
-                    if (activeObservableCount >= maxConcurrent) {
-                        pendingObservables.add(childObservable);
-                    }
-                    else {
-                        observable = childObservable;
-                        activeObservableCount++;
-                    }
-                }
-                if (observable != null) {
-                    ourSubscription.add(observable.unsafeSubscribe(new ChildObserver(
-                            serializedObserver)));
-                }
-            }
-        }
-
-        /**
-         * Subscribe to each child Observable<T> and forward their sequence of data to the actualObserver
-         * 
-         */
-        private class ChildObserver extends Subscriber<T> {
-
-            private final SerializedObserver<T> serializedObserver;
-
-            public ChildObserver(SerializedObserver<T> serializedObserver) {
-                this.serializedObserver = serializedObserver;
-            }
-
-            @Override
-            public void onCompleted() {
-                if (ourSubscription.isUnsubscribed()) {
-                    return;
-                }
-
-                Observable<? extends T> 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.unsafeSubscribe(this));
-                } else {
-                    // No pending observable. Need to check if it's necessary to emit an onCompleted
-                    if (isStopped()) {
-                        serializedObserver.onCompleted();
-                    }
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                serializedObserver.onError(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                serializedObserver.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
new file mode 100644
index 0000000000..2880125fa5
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMergeMaxConcurrent.java
@@ -0,0 +1,127 @@
+/**
+ * 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 java.util.concurrent.atomic.AtomicInteger;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Flattens a list of Observables into one Observable sequence, without any transformation.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/merge.png">
+ * <p>
+ * You can combine the items emitted by multiple Observables so that they act like a single
+ * Observable, by using the merge operation.
+ * 
+ * @param <T> the emitted value type
+ */
+public final class OperatorMergeMaxConcurrent<T> implements Operator<T, Observable<? extends T>> {
+    final int maxConcurrency;
+
+    public OperatorMergeMaxConcurrent(int maxConcurrency) {
+        this.maxConcurrency = maxConcurrency;
+    }
+    
+    @Override
+    public Subscriber<? super Observable<? extends T>> call(Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final CompositeSubscription csub = new CompositeSubscription();
+        child.add(csub);
+        return new Subscriber<Observable<? extends T>>(child) {
+            final Subscriber<?> self = this;
+            final AtomicInteger wip = new AtomicInteger(1);
+            final Object guard = new Object();
+            /** Guarded by guard. */
+            int active;
+            /** Guarded by guard. */
+            Queue<Observable<? extends T>> queue = new LinkedList<Observable<? extends T>>();
+
+            @Override
+            public void onNext(Observable<? extends T> t) {
+                synchronized (guard) {
+                    queue.add(t);
+                }
+                subscribeNext();
+            }
+
+            void subscribeNext() {
+                Observable<? extends T> t;
+                synchronized (guard) {
+                    t = queue.peek();
+                    if (t == null || active >= maxConcurrency) {
+                        return;
+                    }
+                    active++;
+                    queue.poll();
+                }
+                wip.incrementAndGet();
+
+                Subscriber<T> itemSub = new Subscriber<T>() {
+                    boolean once = true;
+                    @Override
+                    public void onNext(T t) {
+                        s.onNext(t);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        self.onError(e);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        if (once) {
+                            once = false;
+                            synchronized (guard) {
+                                active--;
+                            }
+                            csub.remove(this);
+
+                            subscribeNext();
+
+                            self.onCompleted();
+                        }
+                    }
+
+                };
+                csub.add(itemSub);
+
+                t.unsafeSubscribe(itemSub);
+            }
+            
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                if (wip.decrementAndGet() == 0) {
+                    s.onCompleted();
+                }
+            }
+            
+        };
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
similarity index 80%
rename from rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
index c82b830603..790eb96db2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMergeMaxConcurrentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
@@ -35,7 +35,7 @@
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 
-public class OperationMergeMaxConcurrentTest {
+public class OperatorMergeMaxConcurrentTest {
 
     @Mock
     Observer<String> stringObserver;
@@ -129,4 +129,35 @@ public void run() {
         }
 
     }
+    
+    @Test
+    public void testMergeALotOfSourcesOneByOneSynchronously() {
+        int n = 10000;
+        List<Observable<Integer>> sourceList = new ArrayList<Observable<Integer>>(n);
+        for (int i = 0; i < n; i++) {
+            sourceList.add(Observable.just(i));
+        }
+        Iterator<Integer> it = Observable.merge(Observable.from(sourceList), 1).toBlockingObservable().getIterator();
+        int j = 0;
+        while (it.hasNext()) {
+            assertEquals((Integer)j, it.next());
+            j++;
+        }
+        assertEquals(j, n);
+    }
+    @Test
+    public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() {
+        int n = 10000;
+        List<Observable<Integer>> sourceList = new ArrayList<Observable<Integer>>(n);
+        for (int i = 0; i < n; i++) {
+            sourceList.add(Observable.just(i));
+        }
+        Iterator<Integer> it = Observable.merge(Observable.from(sourceList), 1).take(n / 2).toBlockingObservable().getIterator();
+        int j = 0;
+        while (it.hasNext()) {
+            assertEquals((Integer)j, it.next());
+            j++;
+        }
+        assertEquals(j, n / 2);
+    }
 }

From 18177aef7c56b9dbaa34336c2a97ae76360115f7 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 25 Apr 2014 22:19:56 +0200
Subject: [PATCH 294/422] Fix ReplaySubject's double termination problem.

---
 .../subjects/SubjectSubscriptionManager.java  | 12 +++++--
 .../java/rx/subjects/ReplaySubjectTest.java   | 36 ++++++++++++++++++-
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 7a66ad3cdf..7efbafb64b 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -235,19 +235,25 @@ protected static class SubjectObserver<T> implements Observer<T> {
 
         private final Observer<? super T> actual;
         protected volatile boolean caughtUp = false;
-
+        boolean once = true;
         SubjectObserver(Observer<? super T> actual) {
             this.actual = actual;
         }
 
         @Override
         public void onCompleted() {
-            this.actual.onCompleted();
+            if (once) {
+                once = false;
+                this.actual.onCompleted();
+            }
         }
 
         @Override
         public void onError(Throwable e) {
-            this.actual.onError(e);
+            if (once) {
+                once = false;
+                this.actual.onError(e);
+            }
         }
 
         @Override
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index e0726b33e6..dd018abd72 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -403,4 +403,38 @@ public void onCompleted() {
             inOrder.verify(o).onCompleted();
             verify(o, never()).onError(any(Throwable.class));
         }
-    }}
+    }
+    @Test
+    public void testTerminateOnce() {
+        ReplaySubject<Integer> source = ReplaySubject.create();
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+        
+        @SuppressWarnings("unchecked")
+        final Observer<Integer> o = mock(Observer.class);
+        
+        source.unsafeSubscribe(new Subscriber<Integer>() {
+
+            @Override
+            public void onNext(Integer t) {
+                o.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                o.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                o.onCompleted();
+            }
+        });
+        
+        verify(o).onNext(1);
+        verify(o).onNext(2);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+}

From 96f4b664bdd0a42222bcacd73f7ee618ca006508 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 25 Apr 2014 23:42:45 +0200
Subject: [PATCH 295/422] OperatorMulticastAndReplay

---
 rxjava-core/src/main/java/rx/Observable.java  |  65 ++++----
 .../java/rx/operators/OperationMulticast.java | 148 ------------------
 .../java/rx/operators/OperatorMulticast.java  |  86 ++++++++++
 .../operators/OperatorMulticastSelector.java  |  76 +++++++++
 ...erationReplay.java => OperatorReplay.java} | 112 ++++++-------
 ...stTest.java => OperatorMulticastTest.java} |   8 +-
 ...eplayTest.java => OperatorReplayTest.java} |  18 ++-
 7 files changed, 259 insertions(+), 254 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationMulticast.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java
 rename rxjava-core/src/main/java/rx/operators/{OperationReplay.java => OperatorReplay.java} (90%)
 rename rxjava-core/src/test/java/rx/operators/{OperationMulticastTest.java => OperatorMulticastTest.java} (91%)
 rename rxjava-core/src/test/java/rx/operators/{OperationReplayTest.java => OperatorReplayTest.java} (95%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..4a40fb3909 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -56,12 +56,11 @@
 import rx.operators.OperationJoin;
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
-import rx.operators.OperationMulticast;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
 import rx.operators.OperationParallelMerge;
-import rx.operators.OperationReplay;
+import rx.operators.OperatorReplay;
 import rx.operators.OperationSample;
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSkip;
@@ -105,6 +104,8 @@
 import rx.operators.OperatorMerge;
 import rx.operators.OperatorMergeMapPair;
 import rx.operators.OperatorMergeMapTransform;
+import rx.operators.OperatorMulticast;
+import rx.operators.OperatorMulticastSelector;
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
@@ -4419,7 +4420,7 @@ public final <U, R> Observable<R> mergeMapIterable(Func1<? super T, ? extends It
     public final <TIntermediate, TResult> Observable<TResult> multicast(
             final Func0<? extends Subject<? super T, ? extends TIntermediate>> subjectFactory,
             final Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> selector) {
-        return OperationMulticast.multicast(this, subjectFactory, selector);
+        return create(new OperatorMulticastSelector<T, TIntermediate, TResult>(this, subjectFactory, selector));
     }
 
     /**
@@ -4436,7 +4437,7 @@ public final <TIntermediate, TResult> Observable<TResult> multicast(
      *      Observable.multicast()</a>
      */
     public final <R> ConnectableObservable<R> multicast(Subject<? super T, ? extends R> subject) {
-        return OperationMulticast.multicast(this, subject);
+        return new OperatorMulticast<T, R>(this, subject);
     }
 
     /**
@@ -4641,7 +4642,7 @@ public final <R> Observable<R> parallel(final Func1<Observable<T>, Observable<R>
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: publish()</a>
      */
     public final ConnectableObservable<T> publish() {
-        return OperationMulticast.multicast(this, PublishSubject.<T> create());
+        return new OperatorMulticast<T, T>(this, PublishSubject.<T> create());
     }
 
     /**
@@ -4704,7 +4705,7 @@ public final Subject<T, T> call() {
      *         and starts with {@code initialValue}
      */
     public final ConnectableObservable<T> publish(T initialValue) {
-        return OperationMulticast.multicast(this, BehaviorSubject.<T> create(initialValue));
+        return new OperatorMulticast<T, T>(this, BehaviorSubject.<T> create(initialValue));
     }
 
     /**
@@ -4716,7 +4717,7 @@ public final ConnectableObservable<T> publish(T initialValue) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublishlast">RxJava Wiki: publishLast()</a>
      */
     public final ConnectableObservable<T> publishLast() {
-        return OperationMulticast.multicast(this, AsyncSubject.<T> create());
+        return new OperatorMulticast<T, T>(this, AsyncSubject.<T> create());
     }
 
     /**
@@ -4879,7 +4880,7 @@ public final Observable<T> repeat(long count, Scheduler scheduler) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
      */
     public final ConnectableObservable<T> replay() {
-        return OperationMulticast.multicast(this, ReplaySubject.<T> create());
+        return new OperatorMulticast<T, T>(this, ReplaySubject.<T> create());
     }
 
     /**
@@ -4898,12 +4899,12 @@ public final ConnectableObservable<T> replay() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229653.aspx">MSDN: Observable.Replay</a>
      */
     public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
-        return OperationMulticast.multicast(this, new Func0<Subject<T, T>>() {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
                 return ReplaySubject.create();
             }
-        }, selector);
+        }, selector));
     }
 
     /**
@@ -4927,12 +4928,12 @@ public final Subject<T, T> call() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211675.aspx">MSDN: Observable.Replay</a>
      */
     public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize) {
-        return OperationMulticast.multicast(this, new Func0<Subject<T, T>>() {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperationReplay.replayBuffered(bufferSize);
+                return OperatorReplay.replayBuffered(bufferSize);
             }
-        }, selector);
+        }, selector));
     }
 
     /**
@@ -4995,12 +4996,12 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
         if (bufferSize < 0) {
             throw new IllegalArgumentException("bufferSize < 0");
         }
-        return OperationMulticast.multicast(this, new Func0<Subject<T, T>>() {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperationReplay.replayWindowed(time, unit, bufferSize, scheduler);
+                return OperatorReplay.replayWindowed(time, unit, bufferSize, scheduler);
             }
-        }, selector);
+        }, selector));
     }
 
     /**
@@ -5026,12 +5027,12 @@ public final Subject<T, T> call() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229928.aspx">MSDN: Observable.Replay</a>
      */
     public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize, final Scheduler scheduler) {
-        return OperationMulticast.multicast(this, new Func0<Subject<T, T>>() {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperationReplay.<T> createScheduledSubject(OperationReplay.<T> replayBuffered(bufferSize), scheduler);
+                return OperatorReplay.<T> createScheduledSubject(OperatorReplay.<T> replayBuffered(bufferSize), scheduler);
             }
-        }, selector);
+        }, selector));
     }
 
     /**
@@ -5085,12 +5086,12 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh244327.aspx">MSDN: Observable.Replay</a>
      */
     public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final long time, final TimeUnit unit, final Scheduler scheduler) {
-        return OperationMulticast.multicast(this, new Func0<Subject<T, T>>() {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperationReplay.replayWindowed(time, unit, -1, scheduler);
+                return OperatorReplay.replayWindowed(time, unit, -1, scheduler);
             }
-        }, selector);
+        }, selector));
     }
 
     /**
@@ -5113,12 +5114,12 @@ public final Subject<T, T> call() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211644.aspx">MSDN: Observable.Replay</a>
      */
     public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final Scheduler scheduler) {
-        return OperationMulticast.multicast(this, new Func0<Subject<T, T>>() {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperationReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler);
+                return OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler);
             }
-        }, selector);
+        }, selector));
     }
 
     /**
@@ -5135,7 +5136,7 @@ public final Subject<T, T> call() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211976.aspx">MSDN: Observable.Replay</a>
      */
     public final ConnectableObservable<T> replay(int bufferSize) {
-        return OperationMulticast.multicast(this, OperationReplay.<T> replayBuffered(bufferSize));
+        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayBuffered(bufferSize));
     }
 
     /**
@@ -5184,7 +5185,7 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
         if (bufferSize < 0) {
             throw new IllegalArgumentException("bufferSize < 0");
         }
-        return OperationMulticast.multicast(this, OperationReplay.<T> replayWindowed(time, unit, bufferSize, scheduler));
+        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, bufferSize, scheduler));
     }
 
     /**
@@ -5203,9 +5204,9 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229814.aspx">MSDN: Observable.Replay</a>
      */
     public final ConnectableObservable<T> replay(int bufferSize, Scheduler scheduler) {
-        return OperationMulticast.multicast(this,
-                OperationReplay.createScheduledSubject(
-                        OperationReplay.<T> replayBuffered(bufferSize), scheduler));
+        return new OperatorMulticast<T, T>(this,
+                OperatorReplay.createScheduledSubject(
+                        OperatorReplay.<T> replayBuffered(bufferSize), scheduler));
     }
 
     /**
@@ -5245,7 +5246,7 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211811.aspx">MSDN: Observable.Replay</a>
      */
     public final ConnectableObservable<T> replay(long time, TimeUnit unit, Scheduler scheduler) {
-        return OperationMulticast.multicast(this, OperationReplay.<T> replayWindowed(time, unit, -1, scheduler));
+        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, -1, scheduler));
     }
 
     /**
@@ -5262,7 +5263,7 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit, Scheduler
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211699.aspx">MSDN: Observable.Replay</a>
      */
     public final ConnectableObservable<T> replay(Scheduler scheduler) {
-        return OperationMulticast.multicast(this, OperationReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler));
+        return new OperatorMulticast<T, T>(this, OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java b/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
deleted file mode 100644
index f6760ee052..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationMulticast.java
+++ /dev/null
@@ -1,148 +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.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;
-
-public class OperationMulticast {
-    public static <T, R> ConnectableObservable<R> multicast(Observable<? extends T> source, final Subject<? super T, ? extends R> subject) {
-        return new MulticastConnectableObservable<T, R>(source, subject);
-    }
-
-    private static class MulticastConnectableObservable<T, R> extends ConnectableObservable<R> {
-        private final Object lock = new Object();
-
-        private final Observable<? extends T> source;
-        private final Subject<? super T, ? extends R> subject;
-
-        private Subscription subscription;
-
-        public MulticastConnectableObservable(Observable<? extends T> source, final Subject<? super T, ? extends R> subject) {
-            super(new OnSubscribe<R>() {
-                @Override
-                public void call(Subscriber<? super R> observer) {
-                    subject.unsafeSubscribe(observer);
-                }
-            });
-            this.source = source;
-            this.subject = subject;
-        }
-
-        public Subscription connect() {
-            synchronized (lock) {
-                if (subscription == null) {
-                    subscription = source.unsafeSubscribe(new Subscriber<T>() {
-                        @Override
-                        public void onCompleted() {
-                            subject.onCompleted();
-                        }
-
-                        @Override
-                        public void onError(Throwable e) {
-                            subject.onError(e);
-                        }
-
-                        @Override
-                        public void onNext(T args) {
-                            subject.onNext(args);
-                        }
-                    });
-                }
-            }
-
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    synchronized (lock) {
-                        if (subscription != null) {
-                            subscription.unsubscribe();
-                            subscription = null;
-                        }
-                    }
-                }
-            });
-        }
-
-    }
-
-    /**
-     * 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 <a href='http://msdn.microsoft.com/en-us/library/hh229708(v=vs.103).aspx'>MSDN: Observable.Multicast</a>
-     */
-    public static <TInput, TIntermediate, TResult> Observable<TResult> multicast(
-            final Observable<? extends TInput> source,
-            final Func0<? extends Subject<? super TInput, ? extends TIntermediate>> subjectFactory,
-            final Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> selector) {
-        return Observable.create(new MulticastSubscribeFunc<TInput, TIntermediate, TResult>(source, subjectFactory, selector));
-    }
-
-    /** The multicast subscription function. */
-    private static final class MulticastSubscribeFunc<TInput, TIntermediate, TResult> implements OnSubscribeFunc<TResult> {
-        final Observable<? extends TInput> source;
-        final Func0<? extends Subject<? super TInput, ? extends TIntermediate>> subjectFactory;
-        final Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> resultSelector;
-
-        public MulticastSubscribeFunc(Observable<? extends TInput> source,
-                Func0<? extends Subject<? super TInput, ? extends TIntermediate>> subjectFactory,
-                Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> resultSelector) {
-            this.source = source;
-            this.subjectFactory = subjectFactory;
-            this.resultSelector = resultSelector;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super TResult> t1) {
-            Observable<TResult> observable;
-            ConnectableObservable<TIntermediate> connectable;
-            try {
-                Subject<? super TInput, ? extends TIntermediate> subject = subjectFactory.call();
-
-                connectable = new MulticastConnectableObservable<TInput, TIntermediate>(source, subject);
-
-                observable = resultSelector.call(connectable);
-            } catch (Throwable t) {
-                t1.onError(t);
-                return Subscriptions.empty();
-            }
-
-            CompositeSubscription csub = new CompositeSubscription();
-
-            csub.add(observable.unsafeSubscribe(new SafeObserver<TResult>(
-                    new SafeObservableSubscription(csub), t1)));
-            csub.add(connectable.connect());
-
-            return csub;
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
new file mode 100644
index 0000000000..4a5016b717
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
@@ -0,0 +1,86 @@
+/**
+ * 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.Subscriber;
+import rx.Subscription;
+import rx.functions.Action0;
+import rx.observables.ConnectableObservable;
+import rx.subjects.Subject;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Shares a single subscription to a source through a Subject.
+ * 
+ * @param <T> the source value type
+ * @param <R> the result value type
+ */
+public final class OperatorMulticast<T, R> extends ConnectableObservable<R> {
+    final Observable<? extends T> source;
+    final Subject<? super T, ? extends R> subject;
+    final Object guard = new Object();
+    /** Guarded by guard. */
+    Subscription subscription;
+
+    public OperatorMulticast(Observable<? extends T> source, final Subject<? super T, ? extends R> subject) {
+        super(new OnSubscribe<R>() {
+                @Override
+                public void call(Subscriber<? super R> subscriber) {
+                    subject.unsafeSubscribe(subscriber);
+                }
+            });
+        this.source = source;
+        this.subject = subject;
+    }
+
+    @Override
+    public Subscription connect() {
+        synchronized (guard) {
+            if (subscription == null) {
+                subscription = source.unsafeSubscribe(new Subscriber<T>() {
+                    @Override
+                    public void onCompleted() {
+                        subject.onCompleted();
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        subject.onError(e);
+                    }
+
+                    @Override
+                    public void onNext(T args) {
+                        subject.onNext(args);
+                    }
+                });
+            }
+        }
+
+        return Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                synchronized (guard) {
+                    if (subscription != null) {
+                        subscription.unsubscribe();
+                        subscription = null;
+                    }
+                }
+            }
+        });
+    }
+    
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java
new file mode 100644
index 0000000000..401d8a78ef
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java
@@ -0,0 +1,76 @@
+ /**
+  * 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.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.observables.ConnectableObservable;
+import rx.observers.SafeSubscriber;
+import rx.subjects.Subject;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Returns an observable sequence that contains the elements of a sequence
+ * produced by multicasting the source sequence within a selector function.
+ *
+ * @see <a href='http://msdn.microsoft.com/en-us/library/hh229708(v=vs.103).aspx'>MSDN: Observable.Multicast</a>
+ *
+ * @param <TInput> the input value type
+ * @param <TIntermediate> the intermediate type
+ * @param <TResult> the result type
+ */
+public final class OperatorMulticastSelector<TInput, TIntermediate, TResult> implements OnSubscribe<TResult> {
+    final Observable<? extends TInput> source;
+    final Func0<? extends Subject<? super TInput, ? extends TIntermediate>> subjectFactory;
+    final Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> resultSelector;
+    
+    public OperatorMulticastSelector(Observable<? extends TInput> source,
+            Func0<? extends Subject<? super TInput, ? extends TIntermediate>> subjectFactory,
+            Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> resultSelector) {
+        this.source = source;
+        this.subjectFactory = subjectFactory;
+        this.resultSelector = resultSelector;
+    }
+    
+    @Override
+    public void call(Subscriber<? super TResult> child) {
+        Observable<TResult> observable;
+        ConnectableObservable<TIntermediate> connectable;
+        try {
+            Subject<? super TInput, ? extends TIntermediate> subject = subjectFactory.call();
+            
+            connectable = new OperatorMulticast<TInput, TIntermediate>(source, subject);
+            
+            observable = resultSelector.call(connectable);
+        } catch (Throwable t) {
+            child.onError(t);
+            return;
+        }
+        
+        CompositeSubscription csub = new CompositeSubscription();
+        child.add(csub);
+        
+        SafeSubscriber<TResult> s = new SafeSubscriber<TResult>(child);
+        
+        observable.unsafeSubscribe(s);
+        
+        csub.add(connectable.connect());
+    }
+    
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationReplay.java b/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
similarity index 90%
rename from rxjava-core/src/main/java/rx/operators/OperationReplay.java
rename to rxjava-core/src/main/java/rx/operators/OperatorReplay.java
index e683feb5b2..f07eae0f0c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
@@ -27,18 +27,14 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
 import rx.Scheduler;
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.functions.Functions;
-import rx.observers.Subscribers;
 import rx.schedulers.Timestamped;
 import rx.subjects.Subject;
-import rx.subscriptions.Subscriptions;
 
 /**
  * Replay with limited buffer and/or time constraints.
@@ -46,14 +42,18 @@
  * 
  * @see <a href='http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.replay.aspx'>MSDN: Observable.Replay overloads</a>
  */
-public final class OperationReplay {
+public final class OperatorReplay {
     /** Utility class. */
-    private OperationReplay() {
+    private OperatorReplay() {
         throw new IllegalStateException("No instances!");
     }
 
     /**
-     * Create a BoundedReplaySubject with the given buffer size.
+     * Create a CustomReplaySubject with the given buffer size.
+     * 
+     * @param <T> the element type
+     * @param bufferSize the maximum number of items to keep in the buffer
+     * @return the created subject
      */
     public static <T> Subject<T, T> replayBuffered(int bufferSize) {
         return CustomReplaySubject.create(bufferSize);
@@ -62,6 +62,10 @@ public static <T> Subject<T, T> replayBuffered(int bufferSize) {
     /**
      * Creates a subject whose client observers will observe events
      * propagated through the given wrapped subject.
+     * @param <T> the element type
+     * @param subject the subject to wrap
+     * @param scheduler the target scheduler
+     * @return the created subject
      */
     public static <T> Subject<T, T> createScheduledSubject(Subject<T, T> subject, Scheduler scheduler) {
         final Observable<T> observedOn = subject.observeOn(scheduler);
@@ -69,8 +73,7 @@ public static <T> Subject<T, T> createScheduledSubject(Subject<T, T> subject, Sc
 
             @Override
             public void call(Subscriber<? super T> o) {
-                // TODO HACK between OnSubscribeFunc and Action1
-                subscriberOf(observedOn).onSubscribe(o);
+                subscriberOf(observedOn).call(o);
             }
 
         }, subject);
@@ -147,55 +150,23 @@ public void call() {
 
     /**
      * Return an OnSubscribeFunc which delegates the subscription to the given observable.
+     * 
+     * @param <T> the value type
+     * @param target the target observable
+     * @return the function that delegates the subscription to the target
      */
-    public static <T> OnSubscribeFunc<T> subscriberOf(final Observable<T> target) {
-        return new OnSubscribeFunc<T>() {
+    public static <T> OnSubscribe<T> subscriberOf(final Observable<T> target) {
+        return new OnSubscribe<T>() {
             @Override
-            public Subscription onSubscribe(Observer<? super T> t1) {
-                return target.unsafeSubscribe(Subscribers.from(t1));
+            public void call(Subscriber<? super T> t1) {
+                target.unsafeSubscribe(t1);
             }
         };
     }
 
-//    /**
-//     * Subject that wraps another subject and uses a mapping function
-//     * to transform the received values.
-//     */
-//    public static final class MappingSubject<T, R> extends Subject<T, T> {
-//        private final Subject<T, R> subject;
-//        private final Func1<T, R> selector;
-//        private final OnSubscribe<R> func;
-//
-//        public MappingSubject(OnSubscribe<R> func, Subject<T, R> subject, Func1<T, R> selector) {
-//            this.func = func;
-//            this.subject = subject;
-//            this.selector = selector;
-//        }
-//
-//        @Override
-//        public Observable<R> toObservable() {
-//            return Observable.create(func);
-//        }
-//
-//        @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.
+     * @param <T> the value type
      */
     public static final class SubjectWrapper<T> extends Subject<T, T> {
         /** The wrapped subject. */
@@ -262,7 +233,7 @@ public interface VirtualList<T> {
          * Retrieve an element at the specified logical index.
          * 
          * @param index
-         * @return
+         * @return the element
          */
         T get(int index);
 
@@ -286,14 +257,14 @@ public interface VirtualList<T> {
         /**
          * Returns the current head index of this list.
          * 
-         * @return
+         * @return the head index
          */
         int start();
 
         /**
          * Returns the current tail index of this list (where the next value would appear).
          * 
-         * @return
+         * @return the tail index
          */
         int end();
 
@@ -312,6 +283,7 @@ public interface VirtualList<T> {
 
     /**
      * Behaves like a normal, unbounded ArrayList but with virtual index.
+     * @param <T> the element type
      */
     public static final class VirtualArrayList<T> implements VirtualList<T> {
         /** The backing list . */
@@ -375,6 +347,8 @@ public List<T> toList() {
     /**
      * A bounded list which increases its size up to a maximum capacity, then
      * behaves like a circular buffer with virtual indexes.
+     * 
+     * @param <T> the element type
      */
     public static final class VirtualBoundedList<T> implements VirtualList<T> {
         /** A list that grows up to maxSize. */
@@ -584,7 +558,7 @@ Collection<Replayer> replayers() {
          * @param obs
          * @return
          */
-        Subscription addReplayer(Observer<? super TResult> obs) {
+        Subscription addReplayer(Subscriber<? super TResult> obs) {
             Subscription s = new Subscription() {
                 final AtomicBoolean once = new AtomicBoolean();
 
@@ -601,6 +575,7 @@ public boolean isUnsubscribed() {
                 }
 
             };
+            obs.add(s);
             Replayer rp = new Replayer(obs, s);
             replayers.put(s, rp);
             rp.replayTill(values.start() + values.size());
@@ -609,13 +584,13 @@ public boolean isUnsubscribed() {
 
         /** The replayer that holds a value where the given observer is currently at. */
         final class Replayer {
-            protected final Observer<? super TResult> wrapped;
+            protected final Subscriber<? super TResult> 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<? super TResult> wrapped, Subscription cancel) {
+            protected Replayer(Subscriber<? super TResult> wrapped, Subscription cancel) {
                 this.wrapped = wrapped;
                 this.cancel = cancel;
             }
@@ -699,9 +674,9 @@ void clearValues() {
      */
     public static final class CustomReplaySubject<TInput, TIntermediate, TResult> extends Subject<TInput, TResult> {
         /**
-         * 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.
+         * Return a subject that retains all events and will replay them to an {@link Subscriber} that subscribes.
+         * @param <T> the common value type
+         * @return a subject that retains all events and will replay them to an {@link Subscriber} that subscribes.
          */
         public static <T> CustomReplaySubject<T, T, T> create() {
             ReplayState<T, T> state = new ReplayState<T, T>(new VirtualArrayList<T>(), Functions.<T> identity());
@@ -713,9 +688,10 @@ public static <T> CustomReplaySubject<T, T, T> create() {
         /**
          * Create a bounded replay subject with the given maximum buffer size.
          * 
+         * @param <T> the common value type
          * @param maxSize
          *            the maximum size in number of onNext notifications
-         * @return
+         * @return the custom replay subject
          */
         public static <T> CustomReplaySubject<T, T, T> create(int maxSize) {
             ReplayState<T, T> state = new ReplayState<T, T>(new VirtualBoundedList<T>(maxSize), Functions.<T> identity());
@@ -730,14 +706,14 @@ public static <T> CustomReplaySubject<T, T, T> create(int maxSize) {
         protected final Func1<? super TInput, ? extends TIntermediate> intermediateSelector;
 
         private CustomReplaySubject(
-                final OnSubscribeFunc<TResult> onSubscribe,
+                final OnSubscribe<TResult> onSubscribe,
                 ReplayState<TIntermediate, TResult> state,
                 Func1<? super TInput, ? extends TIntermediate> intermediateSelector) {
             super(new OnSubscribe<TResult>() {
 
                 @Override
                 public void call(Subscriber<? super TResult> sub) {
-                    onSubscribe.onSubscribe(sub);
+                    onSubscribe.call(sub);
                 }
 
             });
@@ -796,7 +772,7 @@ public void onNext(TInput args) {
          */
         protected void replayValues() {
             int s = state.values.start() + state.values.size();
-            for (ReplayState.Replayer rp : state.replayers()) {
+            for (ReplayState<TIntermediate, TResult>.Replayer rp : state.replayers()) {
                 rp.replayTill(s);
             }
         }
@@ -811,7 +787,7 @@ protected void replayValues() {
      *            the value type of the observers subscribing to this subject
      */
     protected static final class CustomReplaySubjectSubscribeFunc<TIntermediate, TResult>
-            implements Observable.OnSubscribeFunc<TResult> {
+            implements Observable.OnSubscribe<TResult> {
 
         private final ReplayState<TIntermediate, TResult> state;
 
@@ -820,14 +796,15 @@ protected CustomReplaySubjectSubscribeFunc(ReplayState<TIntermediate, TResult> s
         }
 
         @Override
-        public Subscription onSubscribe(Observer<? super TResult> t1) {
+        public void call(Subscriber<? super TResult> t1) {
             VirtualList<TIntermediate> values;
             Throwable error;
             state.lock();
             try {
                 if (!state.done) {
                     state.onSubscription.call();
-                    return state.addReplayer(t1);
+                    state.addReplayer(t1);
+                    return;
                 }
                 values = state.values;
                 error = state.error;
@@ -840,7 +817,7 @@ public Subscription onSubscribe(Observer<? super TResult> t1) {
                     t1.onNext(state.resultSelector.call(values.get(i)));
                 } catch (Throwable t) {
                     t1.onError(t);
-                    return Subscriptions.empty();
+                    return;
                 }
             }
             if (error != null) {
@@ -848,7 +825,6 @@ public Subscription onSubscribe(Observer<? super TResult> t1) {
             } else {
                 t1.onCompleted();
             }
-            return Subscriptions.empty();
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMulticastTest.java
similarity index 91%
rename from rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorMulticastTest.java
index 5440d1f282..74cfd01c77 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationMulticastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMulticastTest.java
@@ -28,13 +28,13 @@
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
 
-public class OperationMulticastTest {
+public class OperatorMulticastTest {
 
     @Test
     public void testMulticast() {
         Subject<String, String> source = PublishSubject.create();
 
-        ConnectableObservable<String> multicasted = OperationMulticast.multicast(source,
+        ConnectableObservable<String> multicasted = source.multicast(
                 PublishSubject.<String> create());
 
         @SuppressWarnings("unchecked")
@@ -62,7 +62,7 @@ public void testMulticast() {
     public void testMulticastConnectTwice() {
         Subject<String, String> source = PublishSubject.create();
 
-        ConnectableObservable<String> multicasted = OperationMulticast.multicast(source,
+        ConnectableObservable<String> multicasted = source.multicast(
                 PublishSubject.<String> create());
 
         @SuppressWarnings("unchecked")
@@ -87,7 +87,7 @@ public void testMulticastConnectTwice() {
     public void testMulticastDisconnect() {
         Subject<String, String> source = PublishSubject.create();
 
-        ConnectableObservable<String> multicasted = OperationMulticast.multicast(source,
+        ConnectableObservable<String> multicasted = source.multicast(
                 PublishSubject.<String> create());
 
         @SuppressWarnings("unchecked")
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
similarity index 95%
rename from rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
index 10ebf8cc5f..96a8645fe9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReplayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
@@ -33,11 +33,11 @@
 import rx.Observer;
 import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
-import rx.operators.OperationReplay.VirtualBoundedList;
+import rx.operators.OperatorReplay.VirtualBoundedList;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class OperationReplayTest {
+public class OperatorReplayTest {
     @Test
     public void testBoundedList() {
         VirtualBoundedList<Integer> list = new VirtualBoundedList<Integer>(3);
@@ -98,6 +98,7 @@ public void testBufferedReplay() {
         co.connect();
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -121,6 +122,7 @@ public void testBufferedReplay() {
         }
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -145,6 +147,7 @@ public void testWindowedReplay() {
         co.connect();
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -169,6 +172,7 @@ public void testWindowedReplay() {
 
         }
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -206,6 +210,7 @@ public Observable<Integer> call(Observable<Integer> t1) {
         Observable<Integer> co = source.replay(selector);
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -229,6 +234,7 @@ public Observable<Integer> call(Observable<Integer> t1) {
         }
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -268,6 +274,7 @@ public Observable<Integer> call(Observable<Integer> t1) {
         Observable<Integer> co = source.replay(selector, 3);
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -291,6 +298,7 @@ public Observable<Integer> call(Observable<Integer> t1) {
         }
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -330,6 +338,7 @@ public Observable<Integer> call(Observable<Integer> t1) {
         Observable<Integer> co = source.replay(selector, 100, TimeUnit.MILLISECONDS, scheduler);
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -354,6 +363,7 @@ public Observable<Integer> call(Observable<Integer> t1) {
 
         }
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -373,6 +383,7 @@ public void testBufferedReplayError() {
         co.connect();
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -397,6 +408,7 @@ public void testBufferedReplayError() {
         }
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -421,6 +433,7 @@ public void testWindowedReplayError() {
         co.connect();
 
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 
@@ -445,6 +458,7 @@ public void testWindowedReplayError() {
 
         }
         {
+            @SuppressWarnings("unchecked")
             Observer<Object> observer1 = mock(Observer.class);
             InOrder inOrder = inOrder(observer1);
 

From b3e7b7beea199260d57d77f019476306a6e825e4 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Sat, 26 Apr 2014 00:23:33 +0200
Subject: [PATCH 296/422] OperatorOnErrorResumeNextViaObservable

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 ...erationOnErrorResumeNextViaObservable.java | 115 ------------------
 ...peratorOnErrorResumeNextViaObservable.java |  77 ++++++++++++
 ...orOnErrorResumeNextViaObservableTest.java} |   8 +-
 4 files changed, 83 insertions(+), 121 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaObservable.java
 rename rxjava-core/src/test/java/rx/operators/{OperationOnErrorResumeNextViaObservableTest.java => OperatorOnErrorResumeNextViaObservableTest.java} (93%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..5795439b25 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -57,7 +57,6 @@
 import rx.operators.OperationMergeDelayError;
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMulticast;
-import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
 import rx.operators.OperationParallelMerge;
@@ -108,6 +107,7 @@
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
+import rx.operators.OperatorOnErrorResumeNextViaObservable;
 import rx.operators.OperatorParallel;
 import rx.operators.OperatorPivot;
 import rx.operators.OperatorRepeat;
@@ -4523,7 +4523,7 @@ public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Ob
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorresumenext">RxJava Wiki: onErrorResumeNext()</a>
      */
     public final Observable<T> onErrorResumeNext(final Observable<? extends T> resumeSequence) {
-        return create(OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable(this, resumeSequence));
+        return lift(new OperatorOnErrorResumeNextViaObservable<T>(resumeSequence));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
deleted file mode 100644
index dd6e662918..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorResumeNextViaObservable.java
+++ /dev/null
@@ -1,115 +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.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.observers.Subscribers;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Instruct an Observable to pass control to another Observable rather than invoking
- * <code>onError</code> if it encounters an error.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/onErrorResumeNext.png">
- * <p>
- * By default, when an Observable encounters an error that prevents it from emitting the expected
- * item to its Observer, the Observable invokes its Observer's <code>onError</code> method, and
- * then quits without invoking any more of its Observer's methods. The onErrorResumeNext operation
- * changes this behavior. If you pass an Observable (resumeSequence) to onErrorResumeNext, if the
- * source Observable encounters an error, instead of invoking its Observer's <code>onError</code>
- * method, it will instead relinquish control to this new Observable, which will invoke the
- * Observer's <code>onNext</code> method if it is able to do so. In such a case, because no
- * Observable necessarily invokes <code>onError</code>, the Observer may never know that an error
- * happened.
- * <p>
- * You can use this to prevent errors from propagating or to supply fallback data should errors be
- * encountered.
- */
-public final class OperationOnErrorResumeNextViaObservable<T> {
-
-    public static <T> OnSubscribeFunc<T> onErrorResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
-        return new OnErrorResumeNextViaObservable<T>(originalSequence, resumeSequence);
-    }
-
-    private static class OnErrorResumeNextViaObservable<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<? extends T> resumeSequence;
-        private final Observable<? extends T> originalSequence;
-
-        public OnErrorResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
-            this.resumeSequence = resumeSequence;
-            this.originalSequence = originalSequence;
-        }
-
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-            // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
-            final AtomicReference<SafeObservableSubscription> subscriptionRef = new AtomicReference<SafeObservableSubscription>(subscription);
-
-            // subscribe to the original Observable and remember the subscription
-            subscription.wrap(originalSequence.unsafeSubscribe(new Subscriber<T>() {
-                public void onNext(T value) {
-                    // forward the successful calls unless resumed
-                    if (subscriptionRef.get() == subscription)
-                        observer.onNext(value);
-                }
-
-                /**
-                 * 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 and not already resumed before we can process the error
-                    if (currentSubscription == subscription) {
-                        /* error occurred, so switch subscription to the 'resumeSequence' */
-                        SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.unsafeSubscribe(Subscribers.from(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();
-                        }
-                    }
-                }
-
-                public void onCompleted() {
-                    // forward the successful calls unless resumed
-                    if (subscriptionRef.get() == subscription)
-                        observer.onCompleted();
-                }
-            }));
-
-            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/OperatorOnErrorResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaObservable.java
new file mode 100644
index 0000000000..4ef61927a0
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaObservable.java
@@ -0,0 +1,77 @@
+/**
+ * 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.subscriptions.SerialSubscription;
+
+/**
+ * Instruct an Observable to pass control to another Observable rather than invoking
+ * <code>onError</code> if it encounters an error.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/onErrorResumeNext.png">
+ * <p>
+ * By default, when an Observable encounters an error that prevents it from emitting the expected
+ * item to its Observer, the Observable invokes its Observer's <code>onError</code> method, and
+ * then quits without invoking any more of its Observer's methods. The onErrorResumeNext operation
+ * changes this behavior. If you pass an Observable (resumeSequence) to onErrorResumeNext, if the
+ * source Observable encounters an error, instead of invoking its Observer's <code>onError</code>
+ * method, it will instead relinquish control to this new Observable, which will invoke the
+ * Observer's <code>onNext</code> method if it is able to do so. In such a case, because no
+ * Observable necessarily invokes <code>onError</code>, the Observer may never know that an error
+ * happened.
+ * <p>
+ * You can use this to prevent errors from propagating or to supply fallback data should errors be
+ * encountered.
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorOnErrorResumeNextViaObservable<T> implements Operator<T, T> {
+    final Observable<? extends T> resumeSequence;
+
+    public OperatorOnErrorResumeNextViaObservable(Observable<? extends T> resumeSequence) {
+        this.resumeSequence = resumeSequence;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        // shared subscription won't work here
+        Subscriber<T> s = new Subscriber<T>() {
+            @Override
+            public void onNext(T t) {
+                child.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                unsubscribe();
+                resumeSequence.unsafeSubscribe(child);
+            }
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+            
+        };
+        child.add(s);
+        
+        return s;
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaObservableTest.java
similarity index 93%
rename from rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaObservableTest.java
index 193b9c9b5a..600add9cee 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaObservableTest.java
@@ -20,7 +20,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationOnErrorResumeNextViaObservable.onErrorResumeNextViaObservable;
 
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -30,7 +29,7 @@
 import rx.Subscription;
 import rx.functions.Func1;
 
-public class OperationOnErrorResumeNextViaObservableTest {
+public class OperatorOnErrorResumeNextViaObservableTest {
 
     @Test
     public void testResumeNext() {
@@ -39,7 +38,7 @@ public void testResumeNext() {
         TestObservable f = new TestObservable(s, "one", "fail", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
-        Observable<String> observable = Observable.create(onErrorResumeNextViaObservable(w, resume));
+        Observable<String> observable = w.onErrorResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -72,6 +71,7 @@ public void testMapResumeAsyncNext() {
         // Introduce map function that fails intermittently (Map does not prevent this when the observer is a
         //  rx.operator incl onErrorResumeNextViaObservable)
         w = w.map(new Func1<String, String>() {
+            @Override
             public String call(String s) {
                 if ("fail".equals(s))
                     throw new RuntimeException("Forced Failure");
@@ -80,7 +80,7 @@ public String call(String s) {
             }
         });
 
-        Observable<String> observable = Observable.create(onErrorResumeNextViaObservable(w, resume));
+        Observable<String> observable = w.onErrorResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);

From 7484fc9af70bea89181782d2d4a8428e72f731fa Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Sat, 26 Apr 2014 00:42:51 +0200
Subject: [PATCH 297/422] OperatorOnErrorReturn

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../rx/operators/OperationOnErrorReturn.java  | 124 ------------------
 .../rx/operators/OperatorOnErrorReturn.java   |  79 +++++++++++
 ...st.java => OperatorOnErrorReturnTest.java} |  21 ++-
 4 files changed, 91 insertions(+), 137 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorOnErrorReturn.java
 rename rxjava-core/src/test/java/rx/operators/{OperationOnErrorReturnTest.java => OperatorOnErrorReturnTest.java} (88%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..dcda7c0e80 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -58,7 +58,6 @@
 import rx.operators.OperationMergeMaxConcurrent;
 import rx.operators.OperationMulticast;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
-import rx.operators.OperationOnErrorReturn;
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
 import rx.operators.OperationParallelMerge;
 import rx.operators.OperationReplay;
@@ -108,6 +107,7 @@
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
+import rx.operators.OperatorOnErrorReturn;
 import rx.operators.OperatorParallel;
 import rx.operators.OperatorPivot;
 import rx.operators.OperatorRepeat;
@@ -4547,7 +4547,7 @@ public final Observable<T> onErrorResumeNext(final Observable<? extends T> resum
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorreturn">RxJava Wiki: onErrorReturn()</a>
      */
     public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
-        return create(OperationOnErrorReturn.onErrorReturn(this, resumeFunction));
+        return lift(new OperatorOnErrorReturn<T>(resumeFunction));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java b/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
deleted file mode 100644
index 785775f064..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationOnErrorReturn.java
+++ /dev/null
@@ -1,124 +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.Arrays;
-import java.util.concurrent.atomic.AtomicReference;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-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 emit a particular item to its Observer's <code>onNext</code> method
- * rather than invoking <code>onError</code> if it encounters an error.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/onErrorReturn.png">
- * <p>
- * By default, when an Observable encounters an error that prevents it from emitting the expected
- * item to its Observer, the Observable invokes its Observer's <code>onError</code> method, and then
- * quits without invoking any more of its Observer's methods. The onErrorReturn operation changes
- * this behavior. If you pass a function (resumeFunction) to onErrorReturn, if the original
- * Observable encounters an error, instead of invoking its Observer's <code>onError</code> method,
- * it will instead pass the return value of resumeFunction to the Observer's <code>onNext</code>
- * method.
- * <p>
- * You can use this to prevent errors from propagating or to supply fallback data should errors be
- * encountered.
- */
-public final class OperationOnErrorReturn<T> {
-
-    public static <T> OnSubscribeFunc<T> onErrorReturn(Observable<? extends T> originalSequence, Func1<Throwable, ? extends T> resumeFunction) {
-        return new OnErrorReturn<T>(originalSequence, resumeFunction);
-    }
-
-    private static class OnErrorReturn<T> implements OnSubscribeFunc<T> {
-        private final Func1<Throwable, ? extends T> resumeFunction;
-        private final Observable<? extends T> originalSequence;
-
-        public OnErrorReturn(Observable<? extends T> originalSequence, Func1<Throwable, ? extends T> resumeFunction) {
-            this.resumeFunction = resumeFunction;
-            this.originalSequence = originalSequence;
-        }
-
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-            // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
-            final AtomicReference<SafeObservableSubscription> subscriptionRef = new AtomicReference<SafeObservableSubscription>(subscription);
-
-            // subscribe to the original Observable and remember the subscription
-            subscription.wrap(originalSequence.unsafeSubscribe(new Subscriber<T>() {
-                public void onNext(T value) {
-                    // forward the successful calls
-                    observer.onNext(value);
-                }
-
-                /**
-                 * 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 {
-                            /* error occurred, so execute the function, give it the exception and call onNext with the response */
-                            onNext(resumeFunction.call(ex));
-                            /*
-                             * we are not handling an exception thrown from this function ... should we do something?
-                             * error handling within an error handler is a weird one to determine what we should do
-                             * right now I'm going to just let it throw whatever exceptions occur (such as NPE)
-                             * but I'm considering calling the original Observer.onError to act as if this OnErrorReturn operator didn't happen
-                             */
-
-                            /* we are now completed */
-                            onCompleted();
-
-                            /* unsubscribe since it blew up */
-                            currentSubscription.unsubscribe();
-                        } catch (Throwable e) {
-                            // the return function failed so we need to call onError
-                            // I am using CompositeException so that both exceptions can be seen
-                            observer.onError(new CompositeException("OnErrorReturn function failed", Arrays.asList(ex, e)));
-                        }
-                    }
-                }
-
-                public void onCompleted() {
-                    // forward the successful calls
-                    observer.onCompleted();
-                }
-            }));
-
-            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/OperatorOnErrorReturn.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorReturn.java
new file mode 100644
index 0000000000..c86c36032c
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorReturn.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 java.util.Arrays;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.exceptions.CompositeException;
+import rx.functions.Func1;
+
+/**
+ * Instruct an Observable to emit a particular item to its Observer's <code>onNext</code> method
+ * rather than invoking <code>onError</code> if it encounters an error.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/onErrorReturn.png">
+ * <p>
+ * By default, when an Observable encounters an error that prevents it from emitting the expected
+ * item to its Observer, the Observable invokes its Observer's <code>onError</code> method, and then
+ * quits without invoking any more of its Observer's methods. The onErrorReturn operation changes
+ * this behavior. If you pass a function (resumeFunction) to onErrorReturn, if the original
+ * Observable encounters an error, instead of invoking its Observer's <code>onError</code> method,
+ * it will instead pass the return value of resumeFunction to the Observer's <code>onNext</code>
+ * method.
+ * <p>
+ * You can use this to prevent errors from propagating or to supply fallback data should errors be
+ * encountered.
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorOnErrorReturn<T> implements Operator<T, T> {
+    final Func1<Throwable, ? extends T> resultFunction;
+
+    public OperatorOnErrorReturn(Func1<Throwable, ? extends T> resultFunction) {
+        this.resultFunction = resultFunction;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        return new Subscriber<T>(child) {
+
+            @Override
+            public void onNext(T t) {
+                child.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                try {
+                    T result = resultFunction.call(e);
+                    
+                    child.onNext(result);
+                } catch (Throwable x) {
+                    child.onError(new CompositeException(Arrays.asList(e, x)));
+                    return;
+                }
+                child.onCompleted();
+            }
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+            
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorReturnTest.java
similarity index 88%
rename from rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorOnErrorReturnTest.java
index 32e75a3a48..a73d972025 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnErrorReturnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorReturnTest.java
@@ -21,7 +21,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationOnErrorReturn.onErrorReturn;
 
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -30,10 +29,11 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 
-public class OperationOnErrorReturnTest {
+public class OperatorOnErrorReturnTest {
 
     @Test
     public void testResumeNext() {
@@ -42,7 +42,7 @@ public void testResumeNext() {
         Observable<String> w = Observable.create(f);
         final AtomicReference<Throwable> capturedException = new AtomicReference<Throwable>();
 
-        Observable<String> observable = Observable.create(onErrorReturn(w, new Func1<Throwable, String>() {
+        Observable<String> observable = w.onErrorReturn(new Func1<Throwable, String>() {
 
             @Override
             public String call(Throwable e) {
@@ -50,7 +50,7 @@ public String call(Throwable e) {
                 return "failure";
             }
 
-        }));
+        });
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -79,7 +79,7 @@ public void testFunctionThrowsError() {
         Observable<String> w = Observable.create(f);
         final AtomicReference<Throwable> capturedException = new AtomicReference<Throwable>();
 
-        Observable<String> observable = Observable.create(onErrorReturn(w, new Func1<Throwable, String>() {
+        Observable<String> observable = w.onErrorReturn(new Func1<Throwable, String>() {
 
             @Override
             public String call(Throwable e) {
@@ -87,7 +87,7 @@ public String call(Throwable e) {
                 throw new RuntimeException("exception from function");
             }
 
-        }));
+        });
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -108,7 +108,7 @@ public String call(Throwable e) {
         assertNotNull(capturedException.get());
     }
 
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final Subscription s;
         final String[] values;
@@ -120,7 +120,7 @@ public TestObservable(Subscription s, String... values) {
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> subscriber) {
             System.out.println("TestObservable subscribed to ...");
             t = new Thread(new Runnable() {
 
@@ -130,11 +130,11 @@ public void run() {
                         System.out.println("running TestObservable thread");
                         for (String s : values) {
                             System.out.println("TestObservable onNext: " + s);
-                            observer.onNext(s);
+                            subscriber.onNext(s);
                         }
                         throw new RuntimeException("Forced Failure");
                     } catch (Throwable e) {
-                        observer.onError(e);
+                        subscriber.onError(e);
                     }
                 }
 
@@ -142,7 +142,6 @@ public void run() {
             System.out.println("starting TestObservable thread");
             t.start();
             System.out.println("done starting TestObservable thread");
-            return s;
         }
     }
 }

From af07b19a760a87932877888aa1b2e6ffc7809e08 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Fri, 25 Apr 2014 22:46:44 +0800
Subject: [PATCH 298/422] OperatorUsing

---
 rxjava-core/src/main/java/rx/Observable.java  |  6 +-
 .../java/rx/operators/OperationUsing.java     | 60 -------------------
 .../main/java/rx/operators/OperatorUsing.java | 53 ++++++++++++++++
 ...nUsingTest.java => OperatorUsingTest.java} | 18 ++----
 4 files changed, 62 insertions(+), 75 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationUsing.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorUsing.java
 rename rxjava-core/src/test/java/rx/operators/{OperationUsingTest.java => OperatorUsingTest.java} (91%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..ddea5a3876 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -76,7 +76,7 @@
 import rx.operators.OperationTimer;
 import rx.operators.OperationToMap;
 import rx.operators.OperationToMultimap;
-import rx.operators.OperationUsing;
+import rx.operators.OperatorUsing;
 import rx.operators.OperationWindow;
 import rx.operators.OperatorAll;
 import rx.operators.OperatorAmb;
@@ -2589,8 +2589,8 @@ public final static Observable<Long> timer(long delay, TimeUnit unit, Scheduler
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-using">RxJava Wiki: using()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229585.aspx">MSDN: Observable.Using</a>
      */
-    public final static <T, RESOURCE extends Subscription> Observable<T> using(Func0<RESOURCE> resourceFactory, Func1<RESOURCE, Observable<T>> observableFactory) {
-        return create(OperationUsing.using(resourceFactory, observableFactory));
+    public final static <T, Resource extends Subscription> Observable<T> using(Func0<Resource> resourceFactory, Func1<Resource, ? extends Observable<? extends T>> observableFactory) {
+        return create(new OperatorUsing<T, Resource>(resourceFactory, observableFactory));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationUsing.java b/rxjava-core/src/main/java/rx/operators/OperationUsing.java
deleted file mode 100644
index 2beb3bda95..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationUsing.java
+++ /dev/null
@@ -1,60 +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.functions.Func0;
-import rx.functions.Func1;
-import rx.observers.Subscribers;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Constructs an observable sequence that depends on a resource object.
- */
-public class OperationUsing {
-
-    public static <T, RESOURCE extends Subscription> OnSubscribeFunc<T> using(
-            final Func0<RESOURCE> resourceFactory,
-            final Func1<RESOURCE, Observable<T>> observableFactory) {
-        return new OnSubscribeFunc<T>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                Subscription resourceSubscription = Subscriptions.empty();
-                try {
-                    RESOURCE resource = resourceFactory.call();
-                    if (resource != null) {
-                        resourceSubscription = resource;
-                    }
-                    Observable<T> observable = observableFactory.call(resource);
-                    SafeObservableSubscription subscription = new SafeObservableSubscription();
-                    // Use SafeObserver to guarantee resourceSubscription will
-                    // be unsubscribed.
-                    return subscription.wrap(new CompositeSubscription(
-                            observable.unsafeSubscribe(new SafeObserver<T>(
-                                    subscription, observer)),
-                            resourceSubscription));
-                } catch (Throwable e) {
-                    resourceSubscription.unsubscribe();
-                    return Observable.<T> error(e).unsafeSubscribe(Subscribers.from(observer));
-                }
-            }
-        };
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorUsing.java b/rxjava-core/src/main/java/rx/operators/OperatorUsing.java
new file mode 100644
index 0000000000..c2fce225eb
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorUsing.java
@@ -0,0 +1,53 @@
+/**
+ * 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.OnSubscribe;
+import rx.Subscriber;
+import rx.Subscription;
+import rx.functions.Func0;
+import rx.functions.Func1;
+
+/**
+ * Constructs an observable sequence that depends on a resource object.
+ */
+public final class OperatorUsing<T, Resource extends Subscription> implements OnSubscribe<T> {
+
+    private final Func0<Resource> resourceFactory;
+    private final Func1<Resource, ? extends Observable<? extends T>> observableFactory;
+
+    public OperatorUsing(Func0<Resource> resourceFactory, Func1<Resource, ? extends Observable<? extends T>> observableFactory) {
+        this.resourceFactory = resourceFactory;
+        this.observableFactory = observableFactory;
+    }
+
+    public void call(Subscriber<? super T> subscriber) {
+        Resource resource = null;
+        try {
+            resource = resourceFactory.call();
+            subscriber.add(resource);
+            Observable<? extends T> observable = observableFactory.call(resource);
+            observable.subscribe(subscriber);
+        } catch (Throwable e) {
+            if (resource != null) {
+                resource.unsubscribe();
+            }
+            subscriber.onError(e);
+        }
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
similarity index 91%
rename from rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
index dc3b83deb0..570d0a2440 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationUsingTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
@@ -21,7 +21,6 @@
 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 org.junit.Test;
 import org.mockito.InOrder;
@@ -35,7 +34,7 @@
 import rx.functions.Func1;
 import rx.subscriptions.Subscriptions;
 
-public class OperationUsingTest {
+public class OperatorUsingTest {
 
     @SuppressWarnings("serial")
     private static class TestException extends RuntimeException {
@@ -69,8 +68,7 @@ public Observable<String> call(Resource resource) {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = (Observer<String>) mock(Observer.class);
-        Observable<String> observable = Observable.create(using(
-                resourceFactory, observableFactory));
+        Observable<String> observable = Observable.using(resourceFactory, observableFactory);
         observable.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -124,8 +122,7 @@ public Observable<String> call(Resource resource) {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = (Observer<String>) mock(Observer.class);
-        Observable<String> observable = Observable.create(using(
-                resourceFactory, observableFactory));
+        Observable<String> observable = Observable.using(resourceFactory, observableFactory);
         observable.subscribe(observer);
         observable.subscribe(observer);
 
@@ -157,8 +154,7 @@ public Observable<Integer> call(Subscription subscription) {
             }
         };
 
-        Observable.create(using(resourceFactory, observableFactory))
-                .toBlockingObservable().last();
+        Observable.using(resourceFactory, observableFactory).toBlockingObservable().last();
     }
 
     @Test
@@ -179,8 +175,7 @@ public Observable<Integer> call(Subscription subscription) {
         };
 
         try {
-            Observable.create(using(resourceFactory, observableFactory))
-                    .toBlockingObservable().last();
+            Observable.using(resourceFactory, observableFactory).toBlockingObservable().last();
             fail("Should throw a TestException when the observableFactory throws it");
         } catch (TestException e) {
             // Make sure that unsubscribe is called so that users can close
@@ -212,8 +207,7 @@ public Subscription onSubscribe(Observer<? super Integer> t1) {
         };
 
         try {
-            Observable.create(using(resourceFactory, observableFactory))
-                    .toBlockingObservable().last();
+            Observable.using(resourceFactory, observableFactory).toBlockingObservable().last();
             fail("Should throw a TestException when the observableFactory throws it");
         } catch (TestException e) {
             // Make sure that unsubscribe is called so that users can close

From 56fde611fadbf08a095d3353230ee4acc269a8f8 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 27 Apr 2014 09:59:53 +0800
Subject: [PATCH 299/422] OperatorTimeInterval

---
 rxjava-core/src/main/java/rx/Observable.java  |  6 +-
 .../rx/operators/OperationTimeInterval.java   | 84 -------------------
 .../rx/operators/OperatorTimeInterval.java    | 60 +++++++++++++
 ...est.java => OperatorTimeIntervalTest.java} |  2 +-
 4 files changed, 64 insertions(+), 88 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTimeInterval.java
 rename rxjava-core/src/test/java/rx/operators/{OperationTimeIntervalTest.java => OperatorTimeIntervalTest.java} (98%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..65cf194515 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.OperationTakeUntil;
 import rx.operators.OperationTakeWhile;
 import rx.operators.OperationThrottleFirst;
-import rx.operators.OperationTimeInterval;
+import rx.operators.OperatorTimeInterval;
 import rx.operators.OperationTimer;
 import rx.operators.OperationToMap;
 import rx.operators.OperationToMultimap;
@@ -6880,7 +6880,7 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Sche
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
      */
     public final Observable<TimeInterval<T>> timeInterval() {
-        return create(OperationTimeInterval.timeInterval(this));
+        return lift(new OperatorTimeInterval(Schedulers.immediate()));
     }
 
     /**
@@ -6896,7 +6896,7 @@ public final Observable<TimeInterval<T>> timeInterval() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
      */
     public final Observable<TimeInterval<T>> timeInterval(Scheduler scheduler) {
-        return create(OperationTimeInterval.timeInterval(this, scheduler));
+        return lift(new OperatorTimeInterval(scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java b/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
deleted file mode 100644
index 9fd0ae490c..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationTimeInterval.java
+++ /dev/null
@@ -1,84 +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.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.schedulers.Schedulers;
-import rx.schedulers.TimeInterval;
-
-/**
- * Records the time interval between consecutive elements in an observable sequence.
- */
-public class OperationTimeInterval {
-
-    public static <T> OnSubscribeFunc<TimeInterval<T>> timeInterval(
-            Observable<? extends T> source) {
-        return timeInterval(source, Schedulers.immediate());
-    }
-
-    public static <T> OnSubscribeFunc<TimeInterval<T>> timeInterval(
-            final Observable<? extends T> source, final Scheduler scheduler) {
-        return new OnSubscribeFunc<TimeInterval<T>>() {
-            @Override
-            public Subscription onSubscribe(
-                    Observer<? super TimeInterval<T>> observer) {
-                return source.unsafeSubscribe(new TimeIntervalObserver<T>(observer,
-                        scheduler));
-            }
-        };
-    }
-
-    private static class TimeIntervalObserver<T> extends Subscriber<T> {
-
-        private final Observer<? super TimeInterval<T>> observer;
-        /**
-         * Only used to compute time intervals.
-         */
-        private final Scheduler scheduler;
-        private long lastTimestamp;
-
-        public TimeIntervalObserver(Observer<? super TimeInterval<T>> observer,
-                Scheduler scheduler) {
-            this.observer = observer;
-            this.scheduler = scheduler;
-            // The beginning time is the time when the observer subscribes.
-            lastTimestamp = scheduler.now();
-        }
-
-        @Override
-        public void onNext(T args) {
-            long nowTimestamp = scheduler.now();
-            observer.onNext(new TimeInterval<T>(nowTimestamp - lastTimestamp,
-                    args));
-            lastTimestamp = nowTimestamp;
-        }
-
-        @Override
-        public void onCompleted() {
-            observer.onCompleted();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            observer.onCompleted();
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTimeInterval.java b/rxjava-core/src/main/java/rx/operators/OperatorTimeInterval.java
new file mode 100644
index 0000000000..6c88777f80
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTimeInterval.java
@@ -0,0 +1,60 @@
+/**
+ * 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.Subscriber;
+import rx.schedulers.TimeInterval;
+
+/**
+ * Records the time interval between consecutive elements in an observable sequence.
+ */
+public final class OperatorTimeInterval<T> implements Operator<TimeInterval<T>, T> {
+
+    private final Scheduler scheduler;
+
+    public OperatorTimeInterval(Scheduler scheduler) {
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super TimeInterval<T>> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            // The beginning time is the time when the observer subscribes.
+            private long lastTimestamp = scheduler.now();
+
+
+            @Override
+            public void onNext(T args) {
+                long nowTimestamp = scheduler.now();
+                subscriber.onNext(new TimeInterval<T>(nowTimestamp - lastTimestamp, args));
+                lastTimestamp = nowTimestamp;
+            }
+
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeIntervalTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTimeIntervalTest.java
index 1fc1a646f1..456da7466b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTimeIntervalTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeIntervalTest.java
@@ -32,7 +32,7 @@
 import rx.schedulers.TimeInterval;
 import rx.subjects.PublishSubject;
 
-public class OperationTimeIntervalTest {
+public class OperatorTimeIntervalTest {
 
     private static final TimeUnit TIME_UNIT = TimeUnit.MILLISECONDS;
 

From ed57dc5191bb351d2c9106027c7abe8a72a600da Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 27 Apr 2014 11:30:56 +0800
Subject: [PATCH 300/422] OperatorThrottleFirst

---
 rxjava-core/src/main/java/rx/Observable.java  |  6 +-
 .../rx/operators/OperationThrottleFirst.java  | 88 -------------------
 .../rx/operators/OperatorThrottleFirst.java   | 63 +++++++++++++
 .../src/test/java/rx/ThrottleFirstTests.java  | 62 -------------
 ...st.java => OperatorThrottleFirstTest.java} | 55 +++++++++---
 5 files changed, 108 insertions(+), 166 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorThrottleFirst.java
 delete mode 100644 rxjava-core/src/test/java/rx/ThrottleFirstTests.java
 rename rxjava-core/src/test/java/rx/operators/{OperationThrottleFirstTest.java => OperatorThrottleFirstTest.java} (69%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..843e081631 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -71,7 +71,7 @@
 import rx.operators.OperationTakeTimed;
 import rx.operators.OperationTakeUntil;
 import rx.operators.OperationTakeWhile;
-import rx.operators.OperationThrottleFirst;
+import rx.operators.OperatorThrottleFirst;
 import rx.operators.OperationTimeInterval;
 import rx.operators.OperationTimer;
 import rx.operators.OperationToMap;
@@ -6733,7 +6733,7 @@ public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Int
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlefirst">RxJava Wiki: throttleFirst()</a>
      */
     public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
-        return create(OperationThrottleFirst.throttleFirst(this, windowDuration, unit));
+        return lift(new OperatorThrottleFirst<T>(windowDuration, unit, Schedulers.computation()));
     }
 
     /**
@@ -6755,7 +6755,7 @@ public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlefirst">RxJava Wiki: throttleFirst()</a>
      */
     public final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationThrottleFirst.throttleFirst(this, skipDuration, unit, scheduler));
+        return lift(new OperatorThrottleFirst<T>(skipDuration, unit, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java b/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
deleted file mode 100644
index d305fdf1d7..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationThrottleFirst.java
+++ /dev/null
@@ -1,88 +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.atomic.AtomicLong;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscription;
-import rx.functions.Func1;
-import rx.observers.Subscribers;
-import rx.schedulers.Schedulers;
-
-/**
- * Throttle by windowing a stream and returning the first value in each window.
- */
-public final class OperationThrottleFirst {
-
-    /**
-     * Throttles to first value in each window.
-     * 
-     * @param items
-     *            The {@link Observable} which is publishing events.
-     * @param windowDuration
-     *            Duration of windows within with the first value will be chosen.
-     * @param unit
-     *            The unit of time for the specified timeout.
-     * @return A {@link Func1} which performs the throttle operation.
-     */
-    public static <T> OnSubscribeFunc<T> throttleFirst(Observable<T> items, long windowDuration, TimeUnit unit) {
-        return throttleFirst(items, windowDuration, unit, Schedulers.computation());
-    }
-
-    /**
-     * Throttles to first value in each window.
-     * 
-     * @param items
-     *            The {@link Observable} which is publishing events.
-     * @param windowDuration
-     *            Duration of windows within with the first value will be chosen.
-     * @param unit
-     *            The unit of time for the specified timeout.
-     * @param scheduler
-     *            The {@link Scheduler} to use internally to manage the timers which handle timeout for each event.
-     * @return A {@link Func1} which performs the throttle operation.
-     */
-    public static <T> OnSubscribeFunc<T> throttleFirst(final Observable<T> items, final long windowDuration, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<T>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-
-                final AtomicLong lastOnNext = new AtomicLong(0);
-                final long timeInMilliseconds = unit.toMillis(windowDuration);
-
-                return items.filter(new Func1<T, Boolean>() {
-
-                    @Override
-                    public Boolean call(T value) {
-                        long now = scheduler.now();
-                        if (lastOnNext.get() == 0 || now - lastOnNext.get() >= timeInMilliseconds) {
-                            lastOnNext.set(now);
-                            return Boolean.TRUE;
-                        } else {
-                            return Boolean.FALSE;
-                        }
-                    }
-
-                }).unsafeSubscribe(Subscribers.from(observer));
-            }
-        };
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorThrottleFirst.java b/rxjava-core/src/main/java/rx/operators/OperatorThrottleFirst.java
new file mode 100644
index 0000000000..e693eed821
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorThrottleFirst.java
@@ -0,0 +1,63 @@
+/**
+ * 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.*;
+import rx.Observable.Operator;
+
+/**
+ * Throttle by windowing a stream and returning the first value in each window.
+ */
+public final class OperatorThrottleFirst<T> implements Operator<T, T> {
+
+    private final long timeInMilliseconds;
+    private final Scheduler scheduler;
+
+    public OperatorThrottleFirst(long windowDuration, TimeUnit unit, Scheduler scheduler) {
+        this.timeInMilliseconds = unit.toMillis(windowDuration);
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            private long lastOnNext = 0;
+
+            @Override
+            public void onNext(T v) {
+                long now = scheduler.now();
+                if (lastOnNext == 0 || now - lastOnNext >= timeInMilliseconds) {
+                    lastOnNext = now;
+                    subscriber.onNext(v);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java b/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
deleted file mode 100644
index ee0d1e7c93..0000000000
--- a/rxjava-core/src/test/java/rx/ThrottleFirstTests.java
+++ /dev/null
@@ -1,62 +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;
-
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-
-import java.util.concurrent.TimeUnit;
-
-import org.junit.Test;
-import org.mockito.InOrder;
-
-import rx.schedulers.TestScheduler;
-import rx.subjects.PublishSubject;
-
-public class ThrottleFirstTests {
-
-    @Test
-    public void testThrottle() {
-        @SuppressWarnings("unchecked")
-        Observer<Integer> observer = mock(Observer.class);
-        TestScheduler s = new TestScheduler();
-        PublishSubject<Integer> o = PublishSubject.create();
-        o.throttleFirst(500, TimeUnit.MILLISECONDS, s).subscribe(observer);
-
-        // send events with simulated time increments
-        s.advanceTimeTo(0, TimeUnit.MILLISECONDS);
-        o.onNext(1); // deliver
-        o.onNext(2); // skip
-        s.advanceTimeTo(501, TimeUnit.MILLISECONDS);
-        o.onNext(3); // deliver
-        s.advanceTimeTo(600, TimeUnit.MILLISECONDS);
-        o.onNext(4); // skip
-        s.advanceTimeTo(700, TimeUnit.MILLISECONDS);
-        o.onNext(5); // skip
-        o.onNext(6); // skip
-        s.advanceTimeTo(1001, TimeUnit.MILLISECONDS);
-        o.onNext(7); // deliver
-        s.advanceTimeTo(1501, TimeUnit.MILLISECONDS);
-        o.onCompleted();
-
-        InOrder inOrder = inOrder(observer);
-        inOrder.verify(observer).onNext(1);
-        inOrder.verify(observer).onNext(3);
-        inOrder.verify(observer).onNext(7);
-        inOrder.verify(observer).onCompleted();
-        inOrder.verifyNoMoreInteractions();
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperatorThrottleFirstTest.java
similarity index 69%
rename from rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorThrottleFirstTest.java
index 244e9a6878..b1c83e9325 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationThrottleFirstTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorThrottleFirstTest.java
@@ -27,14 +27,15 @@
 import org.mockito.InOrder;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
-import rx.subscriptions.Subscriptions;
+import rx.subjects.PublishSubject;
 
-public class OperationThrottleFirstTest {
+public class OperatorThrottleFirstTest {
 
     private TestScheduler scheduler;
     private Scheduler.Worker innerScheduler;
@@ -50,20 +51,18 @@ public void before() {
 
     @Test
     public void testThrottlingWithCompleted() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 publishNext(observer, 100, "one");    // publish as it's first
                 publishNext(observer, 300, "two");    // skip as it's last within the first 400
                 publishNext(observer, 900, "three");   // publish
                 publishNext(observer, 905, "four");   // skip
                 publishCompleted(observer, 1000);     // Should be published as soon as the timeout expires.
-
-                return Subscriptions.empty();
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationThrottleFirst.throttleFirst(source, 400, TimeUnit.MILLISECONDS, scheduler));
+        Observable<String> sampled = source.throttleFirst(400, TimeUnit.MILLISECONDS, scheduler);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -79,19 +78,17 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testThrottlingWithError() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 Exception error = new TestException();
                 publishNext(observer, 100, "one");    // Should be published since it is first
                 publishNext(observer, 200, "two");    // Should be skipped since onError will arrive before the timeout expires
                 publishError(observer, 300, error);   // Should be published as soon as the timeout expires.
-
-                return Subscriptions.empty();
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationThrottleFirst.throttleFirst(source, 400, TimeUnit.MILLISECONDS, scheduler));
+        Observable<String> sampled = source.throttleFirst(400, TimeUnit.MILLISECONDS, scheduler);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -132,4 +129,36 @@ public void call() {
     @SuppressWarnings("serial")
     private class TestException extends Exception {
     }
+
+    @Test
+    public void testThrottle() {
+        @SuppressWarnings("unchecked")
+        Observer<Integer> observer = mock(Observer.class);
+        TestScheduler s = new TestScheduler();
+        PublishSubject<Integer> o = PublishSubject.create();
+        o.throttleFirst(500, TimeUnit.MILLISECONDS, s).subscribe(observer);
+
+        // send events with simulated time increments
+        s.advanceTimeTo(0, TimeUnit.MILLISECONDS);
+        o.onNext(1); // deliver
+        o.onNext(2); // skip
+        s.advanceTimeTo(501, TimeUnit.MILLISECONDS);
+        o.onNext(3); // deliver
+        s.advanceTimeTo(600, TimeUnit.MILLISECONDS);
+        o.onNext(4); // skip
+        s.advanceTimeTo(700, TimeUnit.MILLISECONDS);
+        o.onNext(5); // skip
+        o.onNext(6); // skip
+        s.advanceTimeTo(1001, TimeUnit.MILLISECONDS);
+        o.onNext(7); // deliver
+        s.advanceTimeTo(1501, TimeUnit.MILLISECONDS);
+        o.onCompleted();
+
+        InOrder inOrder = inOrder(observer);
+        inOrder.verify(observer).onNext(1);
+        inOrder.verify(observer).onNext(3);
+        inOrder.verify(observer).onNext(7);
+        inOrder.verify(observer).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+    }
 }

From dda23510db78efca6d6812f48bb7d59f0d5c6fd9 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 27 Apr 2014 23:25:13 +0800
Subject: [PATCH 301/422] OperatorTakeWhile

---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../java/rx/operators/OperationTakeWhile.java | 146 ------------------
 .../java/rx/operators/OperatorTakeWhile.java  |  81 ++++++++++
 ...leTest.java => OperatorTakeWhileTest.java} |  36 ++---
 4 files changed, 101 insertions(+), 168 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.java
 rename rxjava-core/src/test/java/rx/operators/{OperationTakeWhileTest.java => OperatorTakeWhileTest.java} (84%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..045d02ae9f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -70,7 +70,7 @@
 import rx.operators.OperationTakeLast;
 import rx.operators.OperationTakeTimed;
 import rx.operators.OperationTakeUntil;
-import rx.operators.OperationTakeWhile;
+import rx.operators.OperatorTakeWhile;
 import rx.operators.OperationThrottleFirst;
 import rx.operators.OperationTimeInterval;
 import rx.operators.OperationTimer;
@@ -6695,7 +6695,7 @@ public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhile()</a>
      */
     public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate) {
-        return create(OperationTakeWhile.takeWhile(this, predicate));
+        return lift(new OperatorTakeWhile(predicate));
     }
 
     /**
@@ -6714,7 +6714,7 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhileWithIndex()</a>
      */
     public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Integer, Boolean> predicate) {
-        return create(OperationTakeWhile.takeWhileWithIndex(this, predicate));
+        return lift(new OperatorTakeWhile(predicate));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
deleted file mode 100644
index a94a570337..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeWhile.java
+++ /dev/null
@@ -1,146 +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.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func1;
-import rx.functions.Func2;
-
-/**
- * Returns an Observable that emits items emitted by the source Observable as long as a specified
- * condition is true.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/takeWhile.png">
- */
-public final class OperationTakeWhile {
-
-    /**
-     * Returns values from an observable sequence as long as a specified condition is true, and then skips the remaining values.
-     * 
-     * @param items
-     * @param predicate
-     *            a function to test each source element for a condition
-     * @return sequence of observable values from the start as long as the predicate is true
-     */
-    public static <T> OnSubscribeFunc<T> takeWhile(final Observable<? extends T> items, final Func1<? super T, Boolean> predicate) {
-        return takeWhileWithIndex(items, OperationTakeWhile.<T> skipIndex(predicate));
-    }
-
-    /**
-     * Returns values from an observable sequence as long as a specified condition is true, and then skips the remaining values.
-     * 
-     * @param items
-     * @param predicate
-     *            a function to test each element for a condition; the second parameter of the function represents the index of the source element; otherwise, false.
-     * @return sequence of observable values from the start as long as the predicate is true
-     */
-    public static <T> OnSubscribeFunc<T> takeWhileWithIndex(final Observable<? extends T> items, final Func2<? super T, ? super Integer, Boolean> predicate) {
-        // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new TakeWhile<T>(items, predicate).onSubscribe(observer);
-            }
-
-        };
-    }
-
-    private static <T> Func2<T, Integer, Boolean> skipIndex(final Func1<? super T, Boolean> underlying) {
-        return new Func2<T, Integer, Boolean>() {
-            @Override
-            public Boolean call(T input, Integer index) {
-                return underlying.call(input);
-            }
-        };
-    }
-
-    /**
-     * 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.
-     * <p>
-     * It IS thread-safe from within it while receiving onNext events from multiple threads.
-     * <p>
-     * 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.
-     * <p>
-     * Note how the takeWhileWithIndex() factory method above protects us from a single instance being exposed with the Observable wrapper handling the subscribe flow.
-     * 
-     * @param <T>
-     */
-    private static class TakeWhile<T> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> items;
-        private final Func2<? super T, ? super Integer, Boolean> predicate;
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-        private TakeWhile(Observable<? extends T> items, Func2<? super T, ? super Integer, Boolean> predicate) {
-            this.items = items;
-            this.predicate = predicate;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            return subscription.wrap(items.unsafeSubscribe(new ItemObserver(observer)));
-        }
-
-        private class ItemObserver extends Subscriber<T> {
-            private final Observer<? super T> observer;
-
-            private final AtomicInteger counter = new AtomicInteger();
-
-            public ItemObserver(Observer<? super T> observer) {
-                // Using AtomicObserver because the unsubscribe, onCompleted, onError and error handling behavior
-                // needs "isFinished" logic to not send duplicated events
-                // The 'testTakeWhile1' and 'testTakeWhile2' tests fail without this.
-                this.observer = new SafeObserver<T>(subscription, observer);
-            }
-
-            @Override
-            public void onCompleted() {
-                observer.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onNext(T args) {
-                Boolean isSelected;
-                try {
-                    isSelected = predicate.call(args, counter.getAndIncrement());
-                } catch (Throwable e) {
-                    observer.onError(e);
-                    return;
-                }
-                if (isSelected) {
-                    observer.onNext(args);
-                } else {
-                    observer.onCompleted();
-                    // this will work if the sequence is asynchronous, it will have no effect on a synchronous observable
-                    subscription.unsubscribe();
-                }
-            }
-
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.java
new file mode 100644
index 0000000000..678798ecfc
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.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.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+import rx.functions.Func2;
+
+/**
+ * Returns an Observable that emits items emitted by the source Observable as long as a specified
+ * condition is true.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/takeWhile.png">
+ */
+public final class OperatorTakeWhile<T> implements Operator<T, T> {
+
+    private final Func2<? super T, ? super Integer, Boolean> predicate;
+
+    public OperatorTakeWhile(final Func1<? super T, Boolean> underlying) {
+        this(new Func2<T, Integer, Boolean>() {
+            @Override
+            public Boolean call(T input, Integer index) {
+                return underlying.call(input);
+            }
+        });
+    }
+
+    public OperatorTakeWhile(Func2<? super T, ? super Integer, Boolean> predicate) {
+        this.predicate = predicate;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            private int counter = 0;
+
+            @Override
+            public void onNext(T args) {
+                boolean isSelected;
+                try {
+                    isSelected = predicate.call(args, counter++);
+                } catch (Throwable e) {
+                    subscriber.onError(e);
+                    return;
+                }
+                if (isSelected) {
+                    subscriber.onNext(args);
+                } else {
+                    subscriber.onCompleted();
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                subscriber.onError(e);
+            }
+
+        };
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
similarity index 84%
rename from rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
index 434b2d1ab4..4c5701aa53 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
@@ -21,31 +21,30 @@
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationTakeWhile.takeWhile;
-import static rx.operators.OperationTakeWhile.takeWhileWithIndex;
 
 import org.junit.Test;
 
 import rx.Observable;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.functions.Func2;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
-import rx.subscriptions.Subscriptions;
 
-public class OperationTakeWhileTest {
+public class OperatorTakeWhileTest {
 
     @Test
     public void testTakeWhile1() {
         Observable<Integer> w = Observable.from(1, 2, 3);
-        Observable<Integer> take = Observable.create(takeWhile(w, new Func1<Integer, Boolean>() {
+        Observable<Integer> take = w.takeWhile(new Func1<Integer, Boolean>() {
             @Override
             public Boolean call(Integer input) {
                 return input < 3;
             }
-        }));
+        });
 
         @SuppressWarnings("unchecked")
         Observer<Integer> observer = mock(Observer.class);
@@ -60,12 +59,12 @@ public Boolean call(Integer input) {
     @Test
     public void testTakeWhileOnSubject1() {
         Subject<Integer, Integer> s = PublishSubject.create();
-        Observable<Integer> take = Observable.create(takeWhile(s, new Func1<Integer, Boolean>() {
+        Observable<Integer> take = s.takeWhile(new Func1<Integer, Boolean>() {
             @Override
             public Boolean call(Integer input) {
                 return input < 3;
             }
-        }));
+        });
 
         @SuppressWarnings("unchecked")
         Observer<Integer> observer = mock(Observer.class);
@@ -90,12 +89,12 @@ public Boolean call(Integer input) {
     @Test
     public void testTakeWhile2() {
         Observable<String> w = Observable.from("one", "two", "three");
-        Observable<String> take = Observable.create(takeWhileWithIndex(w, new Func2<String, Integer, Boolean>() {
+        Observable<String> take = w.takeWhileWithIndex(new Func2<String, Integer, Boolean>() {
             @Override
             public Boolean call(String input, Integer index) {
                 return index < 2;
             }
-        }));
+        });
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -109,21 +108,20 @@ public Boolean call(String input, Integer index) {
 
     @Test
     public void testTakeWhileDoesntLeakErrors() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new Throwable("test failed"));
-                return Subscriptions.empty();
             }
         });
 
-        Observable.create(takeWhile(source, new Func1<String, Boolean>() {
+        source.takeWhile(new Func1<String, Boolean>() {
             @Override
             public Boolean call(String s) {
                 return false;
             }
-        })).toBlockingObservable().lastOrDefault("");
+        }).toBlockingObservable().lastOrDefault("");
     }
 
     @Test
@@ -133,12 +131,12 @@ public void testTakeWhileProtectsPredicateCall() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> take = Observable.create(takeWhile(Observable.create(source), new Func1<String, Boolean>() {
+        Observable<String> take = Observable.create(source).takeWhile(new Func1<String, Boolean>() {
             @Override
             public Boolean call(String s) {
                 throw testException;
             }
-        }));
+        });
         take.subscribe(observer);
 
         // wait for the Observable to complete
@@ -160,12 +158,12 @@ public void testUnsubscribeAfterTake() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<String> take = Observable.create(takeWhileWithIndex(Observable.create(w), new Func2<String, Integer, Boolean>() {
+        Observable<String> take = Observable.create(w).takeWhileWithIndex(new Func2<String, Integer, Boolean>() {
             @Override
             public Boolean call(String s, Integer index) {
                 return index < 1;
             }
-        }));
+        });
         take.subscribe(observer);
 
         // wait for the Observable to complete

From cd04714b9676eb9494ec9e9e39c6879de44c6eaa Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 28 Apr 2014 09:05:28 +0200
Subject: [PATCH 302/422] Operator OnExceptionResumeNextViaObservable

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 ...ionOnExceptionResumeNextViaObservable.java | 122 ------------------
 ...torOnExceptionResumeNextViaObservable.java |  85 ++++++++++++
 ...ExceptionResumeNextViaObservableTest.java} |  14 +-
 4 files changed, 94 insertions(+), 131 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorOnExceptionResumeNextViaObservable.java
 rename rxjava-core/src/test/java/rx/operators/{OperationOnExceptionResumeNextViaObservableTest.java => OperatorOnExceptionResumeNextViaObservableTest.java} (92%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..7e9c2fefce 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -59,7 +59,6 @@
 import rx.operators.OperationMulticast;
 import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
-import rx.operators.OperationOnExceptionResumeNextViaObservable;
 import rx.operators.OperationParallelMerge;
 import rx.operators.OperationReplay;
 import rx.operators.OperationSample;
@@ -108,6 +107,7 @@
 import rx.operators.OperatorObserveOn;
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
+import rx.operators.OperatorOnExceptionResumeNextViaObservable;
 import rx.operators.OperatorParallel;
 import rx.operators.OperatorPivot;
 import rx.operators.OperatorRepeat;
@@ -4592,7 +4592,7 @@ public final Observable<T> onErrorFlatMap(final Func1<OnErrorThrowable, ? extend
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onexceptionresumenext">RxJava Wiki: onExceptionResumeNext()</a>
      */
     public final Observable<T> onExceptionResumeNext(final Observable<? extends T> resumeSequence) {
-        return create(OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable(this, resumeSequence));
+        return lift(new OperatorOnExceptionResumeNextViaObservable<T>(resumeSequence));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
deleted file mode 100644
index 4e31ff2d08..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationOnExceptionResumeNextViaObservable.java
+++ /dev/null
@@ -1,122 +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.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.observers.Subscribers;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Instruct an Observable to pass control to another Observable rather than invoking
- * <code>onError</code> if it encounters an error of type {@link java.lang.Exception}.
- * <p>
- * This differs from {@link Observable#onErrorResumeNext} in that this one does not handle {@link java.lang.Throwable} or {@link java.lang.Error} but lets those continue through.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/onErrorResumeNext.png">
- * <p>
- * By default, when an Observable encounters an error that prevents it from emitting the expected
- * item to its Observer, the Observable invokes its Observer's <code>onError</code> method, and
- * then quits without invoking any more of its Observer's methods. The onErrorResumeNext operation
- * changes this behavior. If you pass an Observable (resumeSequence) to onErrorResumeNext, if the
- * source Observable encounters an error, instead of invoking its Observer's <code>onError</code>
- * method, it will instead relinquish control to this new Observable, which will invoke the
- * Observer's <code>onNext</code> method if it is able to do so. In such a case, because no
- * Observable necessarily invokes <code>onError</code>, the Observer may never know that an error
- * happened.
- * <p>
- * You can use this to prevent errors from propagating or to supply fallback data should errors be
- * encountered.
- */
-public final class OperationOnExceptionResumeNextViaObservable<T> {
-
-    public static <T> OnSubscribeFunc<T> onExceptionResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
-        return new OnExceptionResumeNextViaObservable<T>(originalSequence, resumeSequence);
-    }
-
-    private static class OnExceptionResumeNextViaObservable<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<? extends T> resumeSequence;
-        private final Observable<? extends T> originalSequence;
-
-        public OnExceptionResumeNextViaObservable(Observable<? extends T> originalSequence, Observable<? extends T> resumeSequence) {
-            this.resumeSequence = resumeSequence;
-            this.originalSequence = originalSequence;
-        }
-
-        public Subscription onSubscribe(final Observer<? super T> observer) {
-            final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-            // AtomicReference since we'll be accessing/modifying this across threads so we can switch it if needed
-            final AtomicReference<SafeObservableSubscription> subscriptionRef = new AtomicReference<SafeObservableSubscription>(subscription);
-
-            // subscribe to the original Observable and remember the subscription
-            subscription.wrap(originalSequence.unsafeSubscribe(new Subscriber<T>() {
-                public void onNext(T value) {
-                    // forward the successful calls unless resumed
-                    if (subscriptionRef.get() == subscription)
-                        observer.onNext(value);
-                }
-
-                /**
-                 * When we receive java.lang.Exception, instead of passing the onError forward, we intercept and "resume" with the resumeSequence.
-                 * For Throwable and Error we pass thru.
-                 */
-                public void onError(Throwable ex) {
-                    if (ex instanceof Exception) {
-                        /* 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 and not already resumed before we can process the error
-                        if (currentSubscription == subscription) {
-                            /* error occurred, so switch subscription to the 'resumeSequence' */
-                            SafeObservableSubscription innerSubscription = new SafeObservableSubscription(resumeSequence.unsafeSubscribe(Subscribers.from(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();
-                            }
-                        }
-                    } else {
-                        observer.onError(ex);
-                    }
-                }
-
-                public void onCompleted() {
-                    // forward the successful calls unless resumed
-                    if (subscriptionRef.get() == subscription)
-                        observer.onCompleted();
-                }
-            }));
-
-            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/OperatorOnExceptionResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorOnExceptionResumeNextViaObservable.java
new file mode 100644
index 0000000000..93b775094e
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnExceptionResumeNextViaObservable.java
@@ -0,0 +1,85 @@
+/**
+ * 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;
+
+/**
+ * Instruct an Observable to pass control to another Observable rather than invoking
+ * <code>onError</code> if it encounters an error of type {@link java.lang.Exception}.
+ * <p>
+ * This differs from {@link Observable#onErrorResumeNext} in that this one does not handle 
+ * {@link java.lang.Throwable} or {@link java.lang.Error} but lets those continue through.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/onErrorResumeNext.png">
+ * <p>
+ * By default, when an Observable encounters an error that prevents it from emitting the expected
+ * item to its Observer, the Observable invokes its Observer's <code>onError</code> method, and
+ * then quits without invoking any more of its Observer's methods. The onErrorResumeNext operation
+ * changes this behavior. If you pass an Observable (resumeSequence) to onErrorResumeNext, if the
+ * source Observable encounters an error, instead of invoking its Observer's <code>onError</code>
+ * method, it will instead relinquish control to this new Observable, which will invoke the
+ * Observer's <code>onNext</code> method if it is able to do so. In such a case, because no
+ * Observable necessarily invokes <code>onError</code>, the Observer may never know that an error
+ * happened.
+ * <p>
+ * You can use this to prevent errors from propagating or to supply fallback data should errors be
+ * encountered.
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorOnExceptionResumeNextViaObservable<T> implements Operator<T, T> {
+    final Observable<? extends T> resumeSequence;
+
+    public OperatorOnExceptionResumeNextViaObservable(Observable<? extends T> resumeSequence) {
+        this.resumeSequence = resumeSequence;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        // needs to independently unsubscribe so child can continue with the resume
+        Subscriber<T> s = new Subscriber<T>() {
+
+            @Override
+            public void onNext(T t) {
+                child.onNext(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                if (e instanceof Exception) {
+                    unsubscribe();
+                    resumeSequence.unsafeSubscribe(child);
+                } else {
+                    child.onError(e);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                child.onCompleted();
+            }
+            
+        };
+        child.add(s);
+        
+        return s;
+    }
+    
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnExceptionResumeNextViaObservableTest.java
similarity index 92%
rename from rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorOnExceptionResumeNextViaObservableTest.java
index 576c12d5f9..a7d0a57a4f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationOnExceptionResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnExceptionResumeNextViaObservableTest.java
@@ -22,7 +22,6 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static rx.operators.OperationOnExceptionResumeNextViaObservable.onExceptionResumeNextViaObservable;
 
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -32,7 +31,7 @@
 import rx.Subscription;
 import rx.functions.Func1;
 
-public class OperationOnExceptionResumeNextViaObservableTest {
+public class OperatorOnExceptionResumeNextViaObservableTest {
 
     @Test
     public void testResumeNextWithException() {
@@ -41,7 +40,7 @@ public void testResumeNextWithException() {
         TestObservable f = new TestObservable(s, "one", "EXCEPTION", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
-        Observable<String> observable = Observable.create(onExceptionResumeNextViaObservable(w, resume));
+        Observable<String> observable = w.onExceptionResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -70,7 +69,7 @@ public void testResumeNextWithRuntimeException() {
         TestObservable f = new TestObservable(s, "one", "RUNTIMEEXCEPTION", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
-        Observable<String> observable = Observable.create(onExceptionResumeNextViaObservable(w, resume));
+        Observable<String> observable = w.onExceptionResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -99,7 +98,7 @@ public void testThrowablePassesThru() {
         TestObservable f = new TestObservable(s, "one", "THROWABLE", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
-        Observable<String> observable = Observable.create(onExceptionResumeNextViaObservable(w, resume));
+        Observable<String> observable = w.onExceptionResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -128,7 +127,7 @@ public void testErrorPassesThru() {
         TestObservable f = new TestObservable(s, "one", "ERROR", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
-        Observable<String> observable = Observable.create(onExceptionResumeNextViaObservable(w, resume));
+        Observable<String> observable = w.onExceptionResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
@@ -162,6 +161,7 @@ public void testMapResumeAsyncNext() {
         // Introduce map function that fails intermittently (Map does not prevent this when the observer is a
         //  rx.operator incl onErrorResumeNextViaObservable)
         w = w.map(new Func1<String, String>() {
+            @Override
             public String call(String s) {
                 if ("fail".equals(s))
                     throw new RuntimeException("Forced Failure");
@@ -170,7 +170,7 @@ public String call(String s) {
             }
         });
 
-        Observable<String> observable = Observable.create(onExceptionResumeNextViaObservable(w, resume));
+        Observable<String> observable = w.onExceptionResumeNext(resume);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);

From cd0a844b9bed0c604e9f435dd7bc22473c32a248 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 28 Apr 2014 09:20:18 +0200
Subject: [PATCH 303/422] Operator ParallelMerge

---
 rxjava-core/src/main/java/rx/Observable.java           |  6 +++---
 ...onParallelMerge.java => OperatorParallelMerge.java} |  3 ++-
 ...elMergeTest.java => OperatorParallelMergeTest.java} | 10 +++++-----
 3 files changed, 10 insertions(+), 9 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationParallelMerge.java => OperatorParallelMerge.java} (93%)
 rename rxjava-core/src/test/java/rx/operators/{OperationParallelMergeTest.java => OperatorParallelMergeTest.java} (91%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..64a1058ca4 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -60,7 +60,6 @@
 import rx.operators.OperationOnErrorResumeNextViaObservable;
 import rx.operators.OperationOnErrorReturn;
 import rx.operators.OperationOnExceptionResumeNextViaObservable;
-import rx.operators.OperationParallelMerge;
 import rx.operators.OperationReplay;
 import rx.operators.OperationSample;
 import rx.operators.OperationSequenceEqual;
@@ -109,6 +108,7 @@
 import rx.operators.OperatorOnErrorFlatMap;
 import rx.operators.OperatorOnErrorResumeNextViaFunction;
 import rx.operators.OperatorParallel;
+import rx.operators.OperatorParallelMerge;
 import rx.operators.OperatorPivot;
 import rx.operators.OperatorRepeat;
 import rx.operators.OperatorRetry;
@@ -2323,7 +2323,7 @@ public final static <T> Observable<T> never() {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-parallelmerge">RxJava Wiki: parallelMerge()</a>
      */
     public final static <T> Observable<Observable<T>> parallelMerge(Observable<Observable<T>> source, int parallelObservables) {
-        return OperationParallelMerge.parallelMerge(source, parallelObservables);
+        return OperatorParallelMerge.parallelMerge(source, parallelObservables);
     }
 
     /**
@@ -2346,7 +2346,7 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-parallelmerge">RxJava Wiki: parallelMerge()</a>
      */
     public final static <T> Observable<Observable<T>> parallelMerge(Observable<Observable<T>> source, int parallelObservables, Scheduler scheduler) {
-        return OperationParallelMerge.parallelMerge(source, parallelObservables, scheduler);
+        return OperatorParallelMerge.parallelMerge(source, parallelObservables, scheduler);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java b/rxjava-core/src/main/java/rx/operators/OperatorParallelMerge.java
similarity index 93%
rename from rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
rename to rxjava-core/src/main/java/rx/operators/OperatorParallelMerge.java
index 7c06082c41..1e5e4fc2d4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationParallelMerge.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorParallelMerge.java
@@ -23,7 +23,8 @@
 import rx.observables.GroupedObservable;
 import rx.schedulers.Schedulers;
 
-public class OperationParallelMerge {
+public final class OperatorParallelMerge {
+    private OperatorParallelMerge() { throw new IllegalStateException("No instances!"); }
 
     public static <T> Observable<Observable<T>> parallelMerge(final Observable<Observable<T>> source, final int parallelObservables) {
         return parallelMerge(source, parallelObservables, Schedulers.immediate());
diff --git a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorParallelMergeTest.java
similarity index 91%
rename from rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorParallelMergeTest.java
index b126189c37..138fbff62b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationParallelMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorParallelMergeTest.java
@@ -30,7 +30,7 @@
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 
-public class OperationParallelMergeTest {
+public class OperatorParallelMergeTest {
 
     @Test
     public void testParallelMerge() {
@@ -41,8 +41,8 @@ public void testParallelMerge() {
 
         Observable<Observable<String>> fourStreams = Observable.<Observable<String>> from(p1, p2, p3, p4);
 
-        Observable<Observable<String>> twoStreams = OperationParallelMerge.parallelMerge(fourStreams, 2);
-        Observable<Observable<String>> threeStreams = OperationParallelMerge.parallelMerge(fourStreams, 3);
+        Observable<Observable<String>> twoStreams = Observable.parallelMerge(fourStreams, 2);
+        Observable<Observable<String>> threeStreams = Observable.parallelMerge(fourStreams, 3);
 
         List<? super Observable<String>> fourList = fourStreams.toList().toBlockingObservable().last();
         List<? super Observable<String>> threeList = threeStreams.toList().toBlockingObservable().last();
@@ -62,7 +62,7 @@ public void testNumberOfThreads() {
         final ConcurrentHashMap<Long, Long> threads = new ConcurrentHashMap<Long, Long>();
         // parallelMerge into 3 streams and observeOn for each
         // we expect 3 threads in the output
-        OperationParallelMerge.parallelMerge(getStreams(), 3)
+        Observable.parallelMerge(getStreams(), 3)
                 .flatMap(new Func1<Observable<String>, Observable<String>>() {
 
                     @Override
@@ -89,7 +89,7 @@ public void testNumberOfThreadsOnScheduledMerge() {
 
         // now we parallelMerge into 3 streams and observeOn for each
         // we expect 3 threads in the output
-        Observable.merge(OperationParallelMerge.parallelMerge(getStreams(), 3, Schedulers.newThread()))
+        Observable.merge(Observable.parallelMerge(getStreams(), 3, Schedulers.newThread()))
                 .toBlockingObservable().forEach(new Action1<String>() {
 
                     @Override

From fc7f077686085b3089dcf949bcdbac2ff78cf891 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 28 Apr 2014 09:46:45 +0200
Subject: [PATCH 304/422] OperatorRefCount

---
 .../rx/observables/ConnectableObservable.java |  5 +-
 .../java/rx/operators/OperationRefCount.java  | 67 -------------------
 .../java/rx/operators/OperatorRefCount.java   | 62 +++++++++++++++++
 .../src/test/java/rx/RefCountTests.java       |  1 +
 4 files changed, 66 insertions(+), 69 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationRefCount.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorRefCount.java

diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
index b71ad4d81e..c99332b342 100644
--- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
@@ -18,7 +18,7 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.operators.OperationRefCount;
+import rx.operators.OperatorRefCount;
 
 /**
  * A ConnectableObservable resembles an ordinary {@link Observable}, except that it does not begin
@@ -44,6 +44,7 @@ protected ConnectableObservable(OnSubscribe<T> onSubscribe) {
     /**
      * Call a ConnectableObservable's connect() method to instruct it to begin emitting the
      * items from its underlying {@link Observable} to its {@link Subscriber}s.
+     * @return the subscription representing the connection
      */
     public abstract Subscription connect();
 
@@ -54,6 +55,6 @@ protected ConnectableObservable(OnSubscribe<T> onSubscribe) {
      * @return a {@link Observable}
      */
     public Observable<T> refCount() {
-        return Observable.create(OperationRefCount.refCount(this));
+        return create(new OperatorRefCount<T>(this));
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java b/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
deleted file mode 100644
index 59bcec2f62..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationRefCount.java
+++ /dev/null
@@ -1,67 +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.Subscription;
-import rx.functions.Action0;
-import rx.observables.ConnectableObservable;
-import rx.observers.Subscribers;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Returns an observable sequence that stays connected to the source as long
- * as there is at least one subscription to the observable sequence.
- */
-public final class OperationRefCount<T> {
-    public static <T> Observable.OnSubscribeFunc<T> refCount(ConnectableObservable<T> connectableObservable) {
-        return new RefCount<T>(connectableObservable);
-    }
-
-    private static class RefCount<T> implements Observable.OnSubscribeFunc<T> {
-        private final ConnectableObservable<T> innerConnectableObservable;
-        private final Object gate = new Object();
-        private int count = 0;
-        private Subscription connection = null;
-
-        public RefCount(ConnectableObservable<T> innerConnectableObservable) {
-            this.innerConnectableObservable = innerConnectableObservable;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            final Subscription subscription = innerConnectableObservable.unsafeSubscribe(Subscribers.from(observer));
-            synchronized (gate) {
-                if (count++ == 0) {
-                    connection = innerConnectableObservable.connect();
-                }
-            }
-            return Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    synchronized (gate) {
-                        if (--count == 0) {
-                            connection.unsubscribe();
-                            connection = null;
-                        }
-                    }
-                    subscription.unsubscribe();
-                }
-            });
-        }
-    }
-}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRefCount.java b/rxjava-core/src/main/java/rx/operators/OperatorRefCount.java
new file mode 100644
index 0000000000..9313f89bd2
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRefCount.java
@@ -0,0 +1,62 @@
+/**
+ * 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;
+import rx.Subscription;
+import rx.functions.Action0;
+import rx.observables.ConnectableObservable;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * Returns an observable sequence that stays connected to the source as long
+ * as there is at least one subscription to the observable sequence.
+ * @param <T> the value type
+ */
+public final class OperatorRefCount<T> implements OnSubscribe<T> {
+    final ConnectableObservable<? extends T> source;
+    final Object guard;
+    /** Guarded by guard. */
+    int count;
+    /** Guarded by guard. */
+    Subscription connection;
+    public OperatorRefCount(ConnectableObservable<? extends T> source) {
+        this.source = source;
+        this.guard = new Object();
+    }
+
+    @Override
+    public void call(Subscriber<? super T> t1) {
+        t1.add(Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                synchronized (guard) {
+                    if (--count == 0) {
+                        connection.unsubscribe();
+                        connection = null;
+                    }
+                }
+            }
+        }));
+        source.unsafeSubscribe(t1);
+        synchronized (guard) {
+            if (count++ == 0) {
+                connection = source.connect();
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java
index 524c2e61fe..95a7ec2030 100644
--- a/rxjava-core/src/test/java/rx/RefCountTests.java
+++ b/rxjava-core/src/test/java/rx/RefCountTests.java
@@ -56,6 +56,7 @@ public void call() {
             }
         });
         Observable<Integer> refCounted = observable.publish().refCount();
+        @SuppressWarnings("unchecked")
         Observer<Integer> observer = mock(Observer.class);
         Subscription first = refCounted.subscribe(observer);
         assertEquals(1, subscriptionCount.get());

From 7eb21ab1b7fec1b3090fc44ea007859cb6b26192 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 28 Apr 2014 10:19:58 +0200
Subject: [PATCH 305/422] OperatorSequenceEqual

---
 rxjava-core/src/main/java/rx/Observable.java  |  4 +-
 ...eEqual.java => OperatorSequenceEqual.java} | 50 +++++++++----------
 ...ts.java => OperatorSequenceEqualTest.java} |  2 +-
 3 files changed, 27 insertions(+), 29 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationSequenceEqual.java => OperatorSequenceEqual.java} (58%)
 rename rxjava-core/src/test/java/rx/operators/{OperationSequenceEqualTests.java => OperatorSequenceEqualTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..7d6cc41c91 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -63,7 +63,6 @@
 import rx.operators.OperationParallelMerge;
 import rx.operators.OperationReplay;
 import rx.operators.OperationSample;
-import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSkip;
 import rx.operators.OperationSkipUntil;
 import rx.operators.OperationSwitch;
@@ -113,6 +112,7 @@
 import rx.operators.OperatorRepeat;
 import rx.operators.OperatorRetry;
 import rx.operators.OperatorScan;
+import rx.operators.OperatorSequenceEqual;
 import rx.operators.OperatorSerialize;
 import rx.operators.OperatorSingle;
 import rx.operators.OperatorSkip;
@@ -2476,7 +2476,7 @@ public final Boolean call(T first, T second) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-sequenceequal">RxJava Wiki: sequenceEqual()</a>
      */
     public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
-        return OperationSequenceEqual.sequenceEqual(first, second, equality);
+        return OperatorSequenceEqual.sequenceEqual(first, second, equality);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java b/rxjava-core/src/main/java/rx/operators/OperatorSequenceEqual.java
similarity index 58%
rename from rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
rename to rxjava-core/src/main/java/rx/operators/OperatorSequenceEqual.java
index 9d9792edfb..600a8843f6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationSequenceEqual.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSequenceEqual.java
@@ -18,7 +18,6 @@
 import static rx.Observable.concat;
 import static rx.Observable.from;
 import static rx.Observable.zip;
-import rx.Notification;
 import rx.Observable;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -28,44 +27,43 @@
  * Returns an Observable that emits a Boolean value that indicate whether two
  * sequences are equal by comparing the elements pairwise.
  */
-public class OperationSequenceEqual {
-
-    public static <T> Observable<Boolean> sequenceEqual(
-            Observable<? extends T> first, Observable<? extends T> second,
-            final Func2<? super T, ? super T, Boolean> equality) {
-        Observable<Notification<T>> firstObservable = concat(
-                first.map(new Func1<T, Notification<T>>() {
+public final class OperatorSequenceEqual {
+    private OperatorSequenceEqual() { throw new IllegalStateException("No instances!"); }
+    /** NotificationLite doesn't work as zip uses it. */
+    private static final Object LOCAL_ONCOMPLETED = new Object();
+    static <T> Observable<Object> materializeLite(Observable<T> source) {
+        return concat(
+                source.map(new Func1<T, Object>() {
 
                     @Override
-                    public Notification<T> call(T t1) {
-                        return Notification.createOnNext(t1);
+                    public Object call(T t1) {
+                        return t1;
                     }
 
-                }), from(Notification.<T>createOnCompleted()));
-
-        Observable<Notification<T>> secondObservable = concat(
-                second.map(new Func1<T, Notification<T>>() {
-
-                    @Override
-                    public Notification<T> call(T t1) {
-                        return Notification.createOnNext(t1);
-                    }
-
-                }), from(Notification.<T>createOnCompleted()));
+                }), from(LOCAL_ONCOMPLETED));
+    }
+    public static <T> Observable<Boolean> sequenceEqual(
+            Observable<? extends T> first, Observable<? extends T> second,
+            final Func2<? super T, ? super T, Boolean> equality) {
+        Observable<Object> firstObservable = materializeLite(first);
+        Observable<Object> secondObservable = materializeLite(second);
 
         return zip(firstObservable, secondObservable,
-                new Func2<Notification<T>, Notification<T>, Boolean>() {
+                new Func2<Object, Object, Boolean>() {
 
                     @Override
-                    public Boolean call(Notification<T> t1, Notification<T> t2) {
-                        if (t1.isOnCompleted() && t2.isOnCompleted()) {
+                    @SuppressWarnings("unchecked")
+                    public Boolean call(Object t1, Object t2) {
+                        boolean c1 = t1 == LOCAL_ONCOMPLETED;
+                        boolean c2 = t2 == LOCAL_ONCOMPLETED;
+                        if (c1 && c2) {
                             return true;
                         }
-                        if (t1.isOnCompleted() || t2.isOnCompleted()) {
+                        if (c1 || c2) {
                             return false;
                         }
                         // Now t1 and t2 must be 'onNext'.
-                        return equality.call(t1.getValue(), t2.getValue());
+                        return equality.call((T)t1, (T)t2);
                     }
 
                 }).all(Functions.<Boolean> identity());
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java b/rxjava-core/src/test/java/rx/operators/OperatorSequenceEqualTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSequenceEqualTest.java
index 94619c028f..1fe95d7f7d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSequenceEqualTests.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSequenceEqualTest.java
@@ -27,7 +27,7 @@
 import rx.Observer;
 import rx.functions.Func2;
 
-public class OperationSequenceEqualTests {
+public class OperatorSequenceEqualTest {
 
     @Test
     public void test1() {

From e98cd16be2111f3c54fadc587d1632955f2c1a10 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 28 Apr 2014 10:50:09 +0200
Subject: [PATCH 306/422] OperatorSkipTimed

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../main/java/rx/operators/OperationSkip.java | 125 ------------------
 .../java/rx/operators/OperatorSkipTimed.java  |  80 +++++++++++
 .../rx/operators/OperationTakeTimedTest.java  |   2 +-
 .../operators/OperatorSkipLastTimedTest.java  |   2 +-
 ...ipTest.java => OperatorSkipTimedTest.java} |   6 +-
 6 files changed, 89 insertions(+), 130 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSkip.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSkipTimed.java
 rename rxjava-core/src/test/java/rx/operators/{OperationSkipTest.java => OperatorSkipTimedTest.java} (96%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..314b1ce4dc 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -64,7 +64,6 @@
 import rx.operators.OperationReplay;
 import rx.operators.OperationSample;
 import rx.operators.OperationSequenceEqual;
-import rx.operators.OperationSkip;
 import rx.operators.OperationSkipUntil;
 import rx.operators.OperationSwitch;
 import rx.operators.OperationTakeLast;
@@ -118,6 +117,7 @@
 import rx.operators.OperatorSkip;
 import rx.operators.OperatorSkipLast;
 import rx.operators.OperatorSkipLastTimed;
+import rx.operators.OperatorSkipTimed;
 import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorTake;
@@ -5547,7 +5547,7 @@ public final Observable<T> skip(long time, TimeUnit unit) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
      */
     public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationSkip.SkipTimed<T>(this, time, unit, scheduler));
+        return lift(new OperatorSkipTimed<T>(time, unit, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkip.java b/rxjava-core/src/main/java/rx/operators/OperationSkip.java
deleted file mode 100644
index f52b14374d..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSkip.java
+++ /dev/null
@@ -1,125 +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.atomic.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Worker;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.subscriptions.CompositeSubscription;
-
-/**
- * Returns an Observable that skips the first <code>num</code> items emitted by the source
- * Observable.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/skip.png">
- * <p>
- * You can ignore the first <code>num</code> items emitted by an Observable and attend only to
- * those items that come after, by modifying the Observable with the skip operation.
- */
-public final class OperationSkip {
-
-    /**
-     * Skip the items after subscription for the given duration.
-     * 
-     * @param <T>
-     *            the value type
-     */
-    public static final class SkipTimed<T> implements OnSubscribeFunc<T> {
-        final Observable<? extends T> source;
-        final long time;
-        final TimeUnit unit;
-        final Scheduler scheduler;
-
-        public SkipTimed(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
-            this.source = source;
-            this.time = time;
-            this.unit = unit;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
-            Worker inner = scheduler.createWorker();
-            CompositeSubscription csub = new CompositeSubscription(inner);
-            final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
-            csub.add(so);
-            source.unsafeSubscribe(so);
-            if (!so.isUnsubscribed()) {
-                inner.schedule(so, time, unit);
-            }
-
-            return csub;
-        }
-
-        /**
-         * Observes the source and relays its values once gate turns into true.
-         * 
-         * @param <T>
-         *            the observed value type
-         */
-        private static final class SourceObserver<T> extends Subscriber<T> implements Action0 {
-            final AtomicBoolean gate;
-            final Observer<? super T> observer;
-            final Subscription cancel;
-
-            public SourceObserver(Observer<? super T> 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/OperatorSkipTimed.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipTimed.java
new file mode 100644
index 0000000000..5119c85aaf
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipTimed.java
@@ -0,0 +1,80 @@
+/**
+ * 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.atomic.AtomicBoolean;
+import rx.Observable.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+
+/**
+ * Skips elements until a specified time elapses.
+ * @param <T> the value type
+ */
+public final class OperatorSkipTimed<T> implements Operator<T, T> {
+    final long time;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+
+    public OperatorSkipTimed(long time, TimeUnit unit, Scheduler scheduler) {
+        this.time = time;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> child) {
+        final Worker worker = scheduler.createWorker();
+        child.add(worker);
+        final AtomicBoolean gate = new AtomicBoolean();
+        worker.schedule(new Action0() {
+            @Override
+            public void call() {
+                gate.set(true);
+            }
+        }, time, unit);
+        return new Subscriber<T>(child) {
+
+            @Override
+            public void onNext(T t) {
+                if (gate.get()) {
+                    child.onNext(t);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                try {
+                    child.onError(e);
+                } finally {
+                    unsubscribe();
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                try {
+                    child.onCompleted();
+                } finally {
+                    unsubscribe();
+                }
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
index 856aef6ea3..a31e3dbf5d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
@@ -28,7 +28,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.operators.OperationSkipTest.CustomException;
+import rx.operators.OperatorSkipTimedTest.CustomException;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
index 6bcaf9c6ba..087462122e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
@@ -28,7 +28,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.operators.OperationSkipTest.CustomException;
+import rx.operators.OperatorSkipTimedTest.CustomException;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipTimedTest.java
similarity index 96%
rename from rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSkipTimedTest.java
index 53cfaf63f3..1313b6d001 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipTimedTest.java
@@ -31,7 +31,7 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class OperationSkipTest {
+public class OperatorSkipTimedTest {
 
     @Test
     public void testSkipTimed() {
@@ -41,6 +41,7 @@ public void testSkipTimed() {
 
         Observable<Integer> result = source.skip(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);
@@ -78,6 +79,7 @@ public void testSkipTimedFinishBeforeTime() {
 
         Observable<Integer> result = source.skip(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);
@@ -108,6 +110,7 @@ public void testSkipTimedErrorBeforeTime() {
 
         Observable<Integer> result = source.skip(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);
@@ -135,6 +138,7 @@ public void testSkipTimedErrorAfterTime() {
 
         Observable<Integer> result = source.skip(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);

From 825e4fbb7764d80c4e61a6213228d26cf5446053 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 28 Apr 2014 11:10:05 +0200
Subject: [PATCH 307/422] OperatorSkipUntil

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../java/rx/operators/OperationSkipUntil.java | 135 ------------------
 .../java/rx/operators/OperatorSkipUntil.java  |  90 ++++++++++++
 ...ilTest.java => OperatorSkipUntilTest.java} |   2 +-
 4 files changed, 93 insertions(+), 138 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSkipUntil.java
 rename rxjava-core/src/test/java/rx/operators/{OperationSkipUntilTest.java => OperatorSkipUntilTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..289aa87ff8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -65,7 +65,6 @@
 import rx.operators.OperationSample;
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSkip;
-import rx.operators.OperationSkipUntil;
 import rx.operators.OperationSwitch;
 import rx.operators.OperationTakeLast;
 import rx.operators.OperationTakeTimed;
@@ -118,6 +117,7 @@
 import rx.operators.OperatorSkip;
 import rx.operators.OperatorSkipLast;
 import rx.operators.OperatorSkipLastTimed;
+import rx.operators.OperatorSkipUntil;
 import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorTake;
@@ -5632,7 +5632,7 @@ public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler schedule
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229358.aspx">MSDN: Observable.SkipUntil</a>
      */
     public final <U> Observable<T> skipUntil(Observable<U> other) {
-        return create(new OperationSkipUntil<T, U>(this, other));
+        return lift(new OperatorSkipUntil<T, U>(other));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java b/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.java
deleted file mode 100644
index 19e0aef60b..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSkipUntil.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.AtomicBoolean;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.observers.Subscribers;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-
-/**
- * Skip elements from the source Observable until the secondary
- * observable fires an element.
- * 
- * @see <a href='http://msdn.microsoft.com/en-us/library/hh229358.aspx'>MSDN: Observable.SkipUntil</a>
- */
-public class OperationSkipUntil<T, U> implements OnSubscribeFunc<T> {
-    protected final Observable<T> source;
-    protected final Observable<U> other;
-
-    public OperationSkipUntil(Observable<T> source, Observable<U> other) {
-        this.source = source;
-        this.other = other;
-    }
-
-    @Override
-    public Subscription onSubscribe(Observer<? super T> t1) {
-        return new ResultManager(t1).init();
-    }
-
-    /** Manage the source and other observers. */
-    private class ResultManager implements Subscription, Observer<T> {
-        final Observer<? super T> observer;
-        final CompositeSubscription cancel;
-        final Object guard = new Object();
-        final AtomicBoolean running = new AtomicBoolean();
-
-        public ResultManager(Observer<? super T> 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.set(source.unsafeSubscribe(Subscribers.from(this)));
-            toOther.set(other.unsafeSubscribe(new OtherObserver(toOther)));
-
-            return this;
-        }
-
-        @Override
-        public void unsubscribe() {
-            cancel.unsubscribe();
-        }
-        
-        @Override
-        public boolean isUnsubscribed() {
-            return cancel.isUnsubscribed();
-        }
-
-        @Override
-        public void onNext(T args) {
-            if (running.get()) {
-                observer.onNext(args);
-            }
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            synchronized (guard) {
-                observer.onError(e);
-                unsubscribe();
-            }
-        }
-
-        @Override
-        public void onCompleted() {
-            synchronized (guard) {
-                observer.onCompleted();
-                unsubscribe();
-            }
-        }
-
-        /** Observe the other stream. */
-        private class OtherObserver extends Subscriber<U> {
-            final Subscription self;
-
-            public OtherObserver(Subscription self) {
-                this.self = self;
-            }
-
-            @Override
-            public void onNext(U args) {
-                running.set(true);
-                self.unsubscribe();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                ResultManager.this.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                self.unsubscribe();
-            }
-
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkipUntil.java b/rxjava-core/src/main/java/rx/operators/OperatorSkipUntil.java
new file mode 100644
index 0000000000..409c119457
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkipUntil.java
@@ -0,0 +1,90 @@
+/**
+ * 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.AtomicBoolean;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.observers.SerializedSubscriber;
+
+/**
+ * Skip elements from the source Observable until the secondary
+ * observable fires an element.
+ * 
+ * If the secondary Observable fires no elements, the primary won't fire any elements.
+ * 
+ * @see <a href='http://msdn.microsoft.com/en-us/library/hh229358.aspx'>MSDN: Observable.SkipUntil</a>
+ * 
+ * @param <T> the source and result value type
+ * @param <U> element type of the signalling observable
+ */
+public final class OperatorSkipUntil<T, U> implements Operator<T, T> {
+    final Observable<U> other;
+
+    public OperatorSkipUntil(Observable<U> other) {
+        this.other = other;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final AtomicBoolean gate = new AtomicBoolean();
+        // u needs to unsubscribe from other independently of child
+        Subscriber<U> u = new Subscriber<U>() {
+
+            @Override
+            public void onNext(U t) {
+                gate.set(true);
+                unsubscribe();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                s.unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                unsubscribe();
+            }
+        };
+        child.add(u);
+        other.unsafeSubscribe(u);
+        
+        return new Subscriber<T>(child) {
+            @Override
+            public void onNext(T t) {
+                if (gate.get()) {
+                    s.onNext(t);
+                }
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                s.onCompleted();
+                unsubscribe();
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipUntilTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSkipUntilTest.java
index 82d5030019..eb01cd783b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipUntilTest.java
@@ -29,7 +29,7 @@
 import rx.Observer;
 import rx.subjects.PublishSubject;
 
-public class OperationSkipUntilTest {
+public class OperatorSkipUntilTest {
     @Mock
     Observer<Object> observer;
 

From 71acd871a45207491ba66115d3917769dc75430f Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 28 Apr 2014 23:50:58 +0800
Subject: [PATCH 308/422] Add lift to rxscala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 56 +++++++++++++++++++
 .../main/scala/rx/lang/scala/Observable.scala | 23 ++++++++
 .../main/scala/rx/lang/scala/Subscriber.scala | 10 ++++
 3 files changed, 89 insertions(+)

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 f4181c99ac..5017b3bdd4 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
@@ -645,4 +645,60 @@ class RxScalaDemo extends JUnitSuite {
     val o : Observable[String] = List("alice", "bob", "carol").toObservable
     assertEquals(List("alice", "bob", "carol"), o.retry(3).toBlockingObservable.toList)
   }
+
+  @Test def liftExample1(): Unit = {
+    // Add "No. " in front of each item
+    val o = List(1, 2, 3).toObservable.lift {
+      subscriber: Subscriber[String] =>
+        Subscriber(
+          subscriber,
+          v => subscriber.onNext("No. " + v),
+          e => subscriber.onError(e),
+          () => subscriber.onCompleted
+        )
+    }.toBlockingObservable.toList
+    println(o)
+  }
+
+  @Test def liftExample2(): Unit = {
+    val o = Observable {
+      subscriber: Subscriber[Int] => {
+        for (i <- 1 to 10 if !subscriber.isUnsubscribed) {
+          println("emit " + i)
+          subscriber.onNext(i)
+        }
+        if (!subscriber.isUnsubscribed) {
+          println("emit onCompleted")
+          subscriber.onCompleted
+        }
+      }
+    }
+    // Take the first 5 items
+    val take = 5
+    val result = o.lift {
+      subscriber: Subscriber[String] =>
+        var index = 0
+        Subscriber(
+          subscriber,
+          v => {
+            if (index < take) {
+              subscriber.onNext("No. " + v)
+            }
+            if (index == take - 1) {
+              subscriber.onCompleted
+            }
+            index += 1
+          },
+          e => subscriber.onError(e),
+          () => subscriber.onCompleted
+        )
+    }.toBlockingObservable.toList
+    println(result)
+    // emit 1
+    // emit 2
+    // emit 3
+    // emit 4
+    // emit 5
+    // List(No. 1, No. 2, No. 3, No. 4, No. 5)
+  }
 }
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 78b5cedd97..1f77d2456a 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
@@ -2537,6 +2537,29 @@ trait Observable[+T]
     toScalaObservable[util.Map[K, V]](o).map(m => mapFactory() ++ m.toMap)
   }
 
+  /**
+   * 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.
+   * <p>
+   * In other words, this allows chaining Observers together on an Observable for acting on the values within
+   * the Observable.
+   * {{{
+   * observable.map(...).filter(...).take(5).lift(new ObserverA()).lift(new ObserverB(...)).subscribe()
+   * }}}
+   *
+   * @param operator
+   * @return an Observable that emits values that are the result of applying the bind function to the values
+   *         of the current Observable
+   */
+  def lift[R](operator: Subscriber[_ >: R] => Subscriber[_ >: T]): Observable[R] = {
+    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
+    val thatJava = thisJava.lift[R](new rx.Observable.Operator[R, T] {
+      override def call(subscriber: rx.Subscriber[_ >: R]): rx.Subscriber[_ >: T] = {
+        toJavaSubscriber(operator.call(toScalaSubscriber(subscriber)))
+      }
+    })
+    toScalaObservable(thatJava)
+  }
 }
 
 /**
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
index 9f7091123e..f19abebde1 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
@@ -49,4 +49,14 @@ object Subscriber extends ObserverFactoryMethods[Subscriber] {
       override def onCompleted(): Unit = c()
     })
   }
+
+  def apply[T](subscriber: Subscriber[_], onNext: T => Unit, onError: Throwable => Unit, onCompleted: () => Unit): Subscriber[T] = {
+    val n = onNext; val e = onError; val c = onCompleted
+    // Java calls XXX; Scala receives XXX.
+    Subscriber(new rx.Subscriber[T](subscriber.asJavaSubscriber) {
+      override def onNext(value: T): Unit = n(value)
+      override def onError(error: Throwable): Unit = e(error)
+      override def onCompleted(): Unit = c()
+    })
+  }
 }

From 59ebdb270efb1a215a2cb1636698ef6d970aa54e Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 29 Apr 2014 13:16:42 +0800
Subject: [PATCH 309/422] Add Operator conversion, tail and update liftExample2

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 87 ++++++++++---------
 .../scala/rx/lang/scala/JavaConversions.scala |  8 ++
 .../main/scala/rx/lang/scala/Observable.scala | 33 +++++--
 .../scala/rx/lang/scala/ObservableTest.scala  | 32 ++++---
 4 files changed, 100 insertions(+), 60 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 5017b3bdd4..7d1ee11cd3 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
@@ -650,9 +650,9 @@ class RxScalaDemo extends JUnitSuite {
     // Add "No. " in front of each item
     val o = List(1, 2, 3).toObservable.lift {
       subscriber: Subscriber[String] =>
-        Subscriber(
+        Subscriber[Int](
           subscriber,
-          v => subscriber.onNext("No. " + v),
+          (v: Int)  => subscriber.onNext("No. " + v),
           e => subscriber.onError(e),
           () => subscriber.onCompleted
         )
@@ -661,44 +661,51 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def liftExample2(): Unit = {
-    val o = Observable {
-      subscriber: Subscriber[Int] => {
-        for (i <- 1 to 10 if !subscriber.isUnsubscribed) {
-          println("emit " + i)
-          subscriber.onNext(i)
-        }
-        if (!subscriber.isUnsubscribed) {
-          println("emit onCompleted")
-          subscriber.onCompleted
-        }
-      }
+    // Split the input Strings with " "
+    val splitStringsWithSpace = (subscriber: Subscriber[String]) => {
+      Subscriber[String](
+        subscriber,
+        (v: String) => v.split(" ").foreach(subscriber.onNext(_)),
+        e => subscriber.onError(e),
+        () => subscriber.onCompleted
+      )
+    }
+
+    // Convert the input Strings to Chars
+    val stringsToChars = (subscriber: Subscriber[Char]) => {
+      Subscriber[String](
+        subscriber,
+        (v: String) => v.foreach(subscriber.onNext(_)),
+        e => subscriber.onError(e),
+        () => subscriber.onCompleted
+      )
+    }
+
+    // Skip the first n items. If the length of source is less than n, throw an IllegalArgumentException
+    def skipWithException[T](n: Int) = (subscriber: Subscriber[T]) => {
+      var count = 0
+      Subscriber[T](
+        subscriber,
+        (v: T) => {
+          if (count >= n) subscriber.onNext(v)
+          count += 1
+        },
+        e => subscriber.onError(e),
+        () => if (count < n) subscriber.onError(new IllegalArgumentException("There is no enough items")) else subscriber.onCompleted
+      )
+    }
+
+    val o = List("RxJava – Reactive Extensions for the JVM").toObservable
+      .lift(splitStringsWithSpace)
+      .map(_.toLowerCase)
+      .lift(stringsToChars)
+      .filter(_.isLetter)
+      .lift(skipWithException(100))
+    try {
+      o.toBlockingObservable.toList
+    }
+    catch {
+      case e: IllegalArgumentException => println("IllegalArgumentException from skipWithException")
     }
-    // Take the first 5 items
-    val take = 5
-    val result = o.lift {
-      subscriber: Subscriber[String] =>
-        var index = 0
-        Subscriber(
-          subscriber,
-          v => {
-            if (index < take) {
-              subscriber.onNext("No. " + v)
-            }
-            if (index == take - 1) {
-              subscriber.onCompleted
-            }
-            index += 1
-          },
-          e => subscriber.onError(e),
-          () => subscriber.onCompleted
-        )
-    }.toBlockingObservable.toList
-    println(result)
-    // emit 1
-    // emit 2
-    // emit 3
-    // emit 4
-    // emit 5
-    // List(No. 1, No. 2, No. 3, No. 4, No. 5)
   }
 }
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 c1d03667b4..eb6fbec4dc 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
@@ -54,4 +54,12 @@ object JavaConversions {
       val asJavaObservable = observable
     }
   }
+
+  implicit def toJavaOperator[T, R](operator: Subscriber[R] => Subscriber[_ >: T]): rx.Observable.Operator[R, T] = {
+    new rx.Observable.Operator[R, T] {
+      override def call(subscriber: rx.Subscriber[_ >: R]): rx.Subscriber[_ >: T] = {
+        toJavaSubscriber[T](operator(toScalaSubscriber[R](subscriber)))
+      }
+    }
+  }
 }
\ 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 1f77d2456a..531333450c 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
@@ -2057,7 +2057,28 @@ trait Observable[+T]
    * @see [[Observable.first]]
    */
   def head: Observable[T] = first
-  
+
+  /**
+   * Returns an Observable that emits all items except the first one, or raises an `UnsupportedOperationException`
+   * if the source Observable is empty.
+   *
+   * @return an Observable that emits all items except the first one, or raises an `UnsupportedOperationException`
+   *         if the source Observable is empty.
+   */
+  def tail: Observable[T] = {
+    lift {
+      (subscriber: Subscriber[T]) => {
+        var isFirst = true
+        Subscriber[T](
+          subscriber,
+          (v: T) => if(isFirst) isFirst = false else subscriber.onNext(v),
+          e => subscriber.onError(e),
+          () => if(isFirst) subscriber.onError(new UnsupportedOperationException("tail of empty Observable")) else subscriber.onCompleted
+        )
+      }
+    }
+  }
+
   /**
    * Returns an Observable that emits the last item emitted by the source Observable or notifies observers of
    * an `NoSuchElementException` if the source Observable is empty.
@@ -2551,14 +2572,8 @@ trait Observable[+T]
    * @return an Observable that emits values that are the result of applying the bind function to the values
    *         of the current Observable
    */
-  def lift[R](operator: Subscriber[_ >: R] => Subscriber[_ >: T]): Observable[R] = {
-    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
-    val thatJava = thisJava.lift[R](new rx.Observable.Operator[R, T] {
-      override def call(subscriber: rx.Subscriber[_ >: R]): rx.Subscriber[_ >: T] = {
-        toJavaSubscriber(operator.call(toScalaSubscriber(subscriber)))
-      }
-    })
-    toScalaObservable(thatJava)
+  def lift[R](operator: Subscriber[R] => Subscriber[_ >: T]): Observable[R] = {
+    toScalaObservable(asJavaObservable.lift(toJavaOperator[T, R](operator)))
   }
 }
 
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 397907a6cb..029622d638 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
@@ -146,16 +146,26 @@ class ObservableTests extends JUnitSuite {
     assertEquals(l2, l1)
   }
 
-  /*
- @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 testHead() {
+    val o: Observable[String] = List("alice", "bob", "carol").toObservable.head
+    assertEquals(List("alice"), o.toBlockingObservable.toList)
+  }
+
+  @Test(expected = classOf[NoSuchElementException])
+  def testHeadWithEmptyObservable() {
+    val o: Observable[String] = List[String]().toObservable.head
+    o.toBlockingObservable.toList
+  }
 
+  @Test def testTail() {
+    val o: Observable[String] = List("alice", "bob", "carol").toObservable.tail
+    assertEquals(List("bob", "carol"), o.toBlockingObservable.toList)
+    assertEquals(List("bob", "carol"), o.toBlockingObservable.toList)
+  }
+
+  @Test(expected = classOf[UnsupportedOperationException])
+  def testTailWithEmptyObservable() {
+    val o: Observable[String] = List[String]().toObservable.tail
+    o.toBlockingObservable.toList
+  }
 }

From b7af5c9904798a3a2e9f3057ac5eb005649e0898 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 29 Apr 2014 13:25:49 +0800
Subject: [PATCH 310/422] Add unsubscribe

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

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.java b/rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.java
index 678798ecfc..2ec1f27884 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTakeWhile.java
@@ -56,12 +56,14 @@ public void onNext(T args) {
                     isSelected = predicate.call(args, counter++);
                 } catch (Throwable e) {
                     subscriber.onError(e);
+                    unsubscribe();
                     return;
                 }
                 if (isSelected) {
                     subscriber.onNext(args);
                 } else {
                     subscriber.onCompleted();
+                    unsubscribe();
                 }
             }
 

From 26a4a1a05a6cc367061639fb19bfdda9d5b97fab Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 29 Apr 2014 10:29:03 +0200
Subject: [PATCH 311/422] Operators of contrib-math

---
 .../rx/math/operators/OperationAverage.java   | 348 ------------------
 .../math/operators/OperatorAverageDouble.java |  79 ++++
 .../math/operators/OperatorAverageFloat.java  |  79 ++++
 .../operators/OperatorAverageInteger.java     |  79 ++++
 .../math/operators/OperatorAverageLong.java   |  79 ++++
 ...erationMinMax.java => OperatorMinMax.java} |   3 +-
 .../{OperationSum.java => OperatorSum.java}   |   3 +-
 .../java/rx/observables/MathObservable.java   |  50 +--
 ...rageTest.java => OperatorAverageTest.java} |  45 ++-
 ...inMaxTest.java => OperatorMinMaxTest.java} |   4 +-
 ...ationSumTest.java => OperatorSumTest.java} |  17 +-
 11 files changed, 397 insertions(+), 389 deletions(-)
 delete mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
 create mode 100644 rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
 rename rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/{OperationMinMax.java => OperatorMinMax.java} (97%)
 rename rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/{OperationSum.java => OperatorSum.java} (96%)
 rename rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/{OperationAverageTest.java => OperatorAverageTest.java} (88%)
 rename rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/{OperationMinMaxTest.java => OperatorMinMaxTest.java} (99%)
 rename rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/{OperationSumTest.java => OperatorSumTest.java} (94%)

diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
deleted file mode 100644
index 25d6bc7376..0000000000
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationAverage.java
+++ /dev/null
@@ -1,348 +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.math.operators;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-import rx.functions.Func1;
-import rx.functions.Func2;
-
-/**
- * A few operators for implementing the averaging operation.
- * 
- * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average%28v=vs.103%29.aspx">MSDN: Observable.Average</a>
- */
-public final class OperationAverage {
-    private static final class Tuple2<T> {
-        private final T current;
-        private final Integer count;
-
-        private Tuple2(T v1, Integer v2) {
-            current = v1;
-            count = v2;
-        }
-    }
-
-    public static Observable<Integer> average(Observable<Integer> source) {
-        return source.reduce(new Tuple2<Integer>(0, 0), new Func2<Tuple2<Integer>, Integer, Tuple2<Integer>>() {
-            @Override
-            public Tuple2<Integer> call(Tuple2<Integer> accu, Integer next) {
-                return new Tuple2<Integer>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Integer>, Integer>() {
-            @Override
-            public Integer call(Tuple2<Integer> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    public static Observable<Long> averageLongs(Observable<Long> source) {
-        return source.reduce(new Tuple2<Long>(0L, 0), new Func2<Tuple2<Long>, Long, Tuple2<Long>>() {
-            @Override
-            public Tuple2<Long> call(Tuple2<Long> accu, Long next) {
-                return new Tuple2<Long>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Long>, Long>() {
-            @Override
-            public Long call(Tuple2<Long> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    public static Observable<Float> averageFloats(Observable<Float> source) {
-        return source.reduce(new Tuple2<Float>(0.0f, 0), new Func2<Tuple2<Float>, Float, Tuple2<Float>>() {
-            @Override
-            public Tuple2<Float> call(Tuple2<Float> accu, Float next) {
-                return new Tuple2<Float>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Float>, Float>() {
-            @Override
-            public Float call(Tuple2<Float> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    public static Observable<Double> averageDoubles(Observable<Double> source) {
-        return source.reduce(new Tuple2<Double>(0.0d, 0), new Func2<Tuple2<Double>, Double, Tuple2<Double>>() {
-            @Override
-            public Tuple2<Double> call(Tuple2<Double> accu, Double next) {
-                return new Tuple2<Double>(accu.current + next, accu.count + 1);
-            }
-        }).map(new Func1<Tuple2<Double>, Double>() {
-            @Override
-            public Double call(Tuple2<Double> result) {
-                if (result.count == 0) {
-                    throw new IllegalArgumentException("Sequence contains no elements");
-                }
-                return result.current / result.count;
-            }
-        });
-    }
-
-    /**
-     * Compute the average by extracting integer values from the source via an
-     * extractor function.
-     * 
-     * @param <T>
-     *            the source value type
-     */
-    public static final class AverageIntegerExtractor<T> implements OnSubscribeFunc<Integer> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Integer> valueExtractor;
-
-        public AverageIntegerExtractor(Observable<? extends T> source, Func1<? super T, Integer> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Integer> t1) {
-            return source.subscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
-            final Observer<? super Integer> observer;
-            int sum;
-            int count;
-
-            public AverageObserver(Observer<? super Integer> 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 <T>
-     *            the source value type
-     */
-    public static final class AverageLongExtractor<T> implements OnSubscribeFunc<Long> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Long> valueExtractor;
-
-        public AverageLongExtractor(Observable<? extends T> source, Func1<? super T, Long> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Long> t1) {
-            return source.subscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
-            final Observer<? super Long> observer;
-            long sum;
-            int count;
-
-            public AverageObserver(Observer<? super Long> 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 <T>
-     *            the source value type
-     */
-    public static final class AverageFloatExtractor<T> implements OnSubscribeFunc<Float> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Float> valueExtractor;
-
-        public AverageFloatExtractor(Observable<? extends T> source, Func1<? super T, Float> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Float> t1) {
-            return source.subscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
-            final Observer<? super Float> observer;
-            float sum;
-            int count;
-
-            public AverageObserver(Observer<? super Float> 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 <T>
-     *            the source value type
-     */
-    public static final class AverageDoubleExtractor<T> implements OnSubscribeFunc<Double> {
-        final Observable<? extends T> source;
-        final Func1<? super T, Double> valueExtractor;
-
-        public AverageDoubleExtractor(Observable<? extends T> source, Func1<? super T, Double> valueExtractor) {
-            this.source = source;
-            this.valueExtractor = valueExtractor;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Double> t1) {
-            return source.subscribe(new AverageObserver(t1));
-        }
-
-        /** Computes the average. */
-        private final class AverageObserver implements Observer<T> {
-            final Observer<? super Double> observer;
-            double sum;
-            int count;
-
-            public AverageObserver(Observer<? super Double> 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-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
new file mode 100644
index 0000000000..8c823b5717
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting double values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageDouble<T> implements Operator<Double, T> {
+    final Func1<? super T, Double> valueExtractor;
+
+    public OperatorAverageDouble(Func1<? super T, Double> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Double> child) {
+    	return new AverageObserver(child);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Double> child;
+        double sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Double> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
new file mode 100644
index 0000000000..c3699ee357
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting float values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageFloat<T> implements Operator<Float, T> {
+    final Func1<? super T, Float> valueExtractor;
+
+    public OperatorAverageFloat(Func1<? super T, Float> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Float> child) {
+        return new AverageObserver(child);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Float> child;
+        float sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Float> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
new file mode 100644
index 0000000000..1bab7638f6
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting integer values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageInteger<T> implements Operator<Integer, T> {
+    final Func1<? super T, Integer> valueExtractor;
+
+    public OperatorAverageInteger(Func1<? super T, Integer> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Integer> t1) {
+        return new AverageObserver(t1);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Integer> child;
+        int sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Integer> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
new file mode 100644
index 0000000000..f0f03e4cc2
--- /dev/null
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting long values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageLong<T> implements Operator<Long, T> {
+    final Func1<? super T, Long> valueExtractor;
+
+    public OperatorAverageLong(Func1<? super T, Long> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Long> child) {
+        return new AverageObserver(child);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Long> child;
+        long sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Long> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorMinMax.java
similarity index 97%
rename from rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java
rename to rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorMinMax.java
index cfa92d4fce..d3a42fc2f2 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationMinMax.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorMinMax.java
@@ -26,7 +26,8 @@
 /**
  * Returns the minimum element in an observable sequence.
  */
-public class OperationMinMax {
+public final class OperatorMinMax {
+	private OperatorMinMax() { throw new IllegalStateException("No instances!"); }
 
     public static <T extends Comparable<? super T>> Observable<T> min(
             Observable<T> source) {
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorSum.java
similarity index 96%
rename from rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java
rename to rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorSum.java
index 3d519e4220..19bd0e9fa3 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperationSum.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorSum.java
@@ -25,7 +25,8 @@
  *      href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum%28v=vs.103%29.aspx">MSDN:
  *      Observable.Sum</a>
  */
-public final class OperationSum {
+public final class OperatorSum {
+	private OperatorSum() { throw new IllegalStateException("No instances!"); }
 
     public static Observable<Integer> sumIntegers(Observable<Integer> source) {
         return source.reduce(0, ACCUM_INT);
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java b/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
index 2614983bf8..1514f1c9a4 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/observables/MathObservable.java
@@ -19,9 +19,13 @@
 
 import rx.Observable;
 import rx.functions.Func1;
-import rx.math.operators.OperationAverage;
-import rx.math.operators.OperationMinMax;
-import rx.math.operators.OperationSum;
+import rx.functions.Functions;
+import rx.math.operators.OperatorMinMax;
+import rx.math.operators.OperatorSum;
+import rx.math.operators.OperatorAverageDouble;
+import rx.math.operators.OperatorAverageFloat;
+import rx.math.operators.OperatorAverageInteger;
+import rx.math.operators.OperatorAverageLong;
 
 public class MathObservable<T> {
 
@@ -48,7 +52,7 @@ public static <T> MathObservable<T> from(Observable<T> o) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final static Observable<Double> averageDouble(Observable<Double> source) {
-        return OperationAverage.averageDoubles(source);
+        return source.lift(new OperatorAverageDouble<Double>(Functions.<Double>identity()));
     }
 
     /**
@@ -64,7 +68,7 @@ public final static Observable<Double> averageDouble(Observable<Double> source)
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final static Observable<Float> averageFloat(Observable<Float> source) {
-        return OperationAverage.averageFloats(source);
+        return source.lift(new OperatorAverageFloat<Float>(Functions.<Float>identity()));
     }
 
     /**
@@ -82,7 +86,7 @@ public final static Observable<Float> averageFloat(Observable<Float> source) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final static Observable<Integer> averageInteger(Observable<Integer> source) {
-        return OperationAverage.average(source);
+        return source.lift(new OperatorAverageInteger<Integer>(Functions.<Integer>identity()));
     }
 
     /**
@@ -98,7 +102,7 @@ public final static Observable<Integer> averageInteger(Observable<Integer> sourc
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final static Observable<Long> averageLong(Observable<Long> source) {
-        return OperationAverage.averageLongs(source);
+        return source.lift(new OperatorAverageLong<Long>(Functions.<Long>identity()));
     }
 
     /**
@@ -117,7 +121,7 @@ public final static Observable<Long> averageLong(Observable<Long> source) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211837.aspx">MSDN: Observable.Max</a>
      */
     public final static <T extends Comparable<? super T>> Observable<T> max(Observable<T> source) {
-        return OperationMinMax.max(source);
+        return OperatorMinMax.max(source);
     }
 
     /**
@@ -134,7 +138,7 @@ public final static <T extends Comparable<? super T>> Observable<T> max(Observab
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229715.aspx">MSDN: Observable.Min</a>
      */
     public final static <T extends Comparable<? super T>> Observable<T> min(Observable<T> source) {
-        return OperationMinMax.min(source);
+        return OperatorMinMax.min(source);
     }
 
     /**
@@ -150,7 +154,7 @@ public final static <T extends Comparable<? super T>> Observable<T> min(Observab
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final static Observable<Double> sumDouble(Observable<Double> source) {
-        return OperationSum.sumDoubles(source);
+        return OperatorSum.sumDoubles(source);
     }
 
     /**
@@ -166,7 +170,7 @@ public final static Observable<Double> sumDouble(Observable<Double> source) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final static Observable<Float> sumFloat(Observable<Float> source) {
-        return OperationSum.sumFloats(source);
+        return OperatorSum.sumFloats(source);
     }
 
     /**
@@ -182,7 +186,7 @@ public final static Observable<Float> sumFloat(Observable<Float> source) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final static Observable<Integer> sumInteger(Observable<Integer> source) {
-        return OperationSum.sumIntegers(source);
+        return OperatorSum.sumIntegers(source);
     }
 
     /**
@@ -198,7 +202,7 @@ public final static Observable<Integer> sumInteger(Observable<Integer> source) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final static Observable<Long> sumLong(Observable<Long> source) {
-        return OperationSum.sumLongs(source);
+        return OperatorSum.sumLongs(source);
     }
 
     /**
@@ -215,7 +219,7 @@ public final static Observable<Long> sumLong(Observable<Long> source) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtractor) {
-        return Observable.create(new OperationAverage.AverageDoubleExtractor<T>(o, valueExtractor));
+        return o.lift(new OperatorAverageDouble<T>(valueExtractor));
     }
 
     /**
@@ -232,7 +236,7 @@ public final Observable<Double> averageDouble(Func1<? super T, Double> valueExtr
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtractor) {
-        return Observable.create(new OperationAverage.AverageFloatExtractor<T>(o, valueExtractor));
+        return o.lift(new OperatorAverageFloat<T>(valueExtractor));
     }
 
     /**
@@ -249,7 +253,7 @@ public final Observable<Float> averageFloat(Func1<? super T, Float> valueExtract
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueExtractor) {
-        return Observable.create(new OperationAverage.AverageIntegerExtractor<T>(o, valueExtractor));
+        return o.lift(new OperatorAverageInteger<T>(valueExtractor));
     }
 
     /**
@@ -266,7 +270,7 @@ public final Observable<Integer> averageInteger(Func1<? super T, Integer> valueE
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.average.aspx">MSDN: Observable.Average</a>
      */
     public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor) {
-        return Observable.create(new OperationAverage.AverageLongExtractor<T>(o, valueExtractor));
+        return o.lift(new OperatorAverageLong<T>(valueExtractor));
     }
 
     /**
@@ -286,7 +290,7 @@ public final Observable<Long> averageLong(Func1<? super T, Long> valueExtractor)
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211635.aspx">MSDN: Observable.Max</a>
      */
     public final Observable<T> max(Comparator<? super T> comparator) {
-        return OperationMinMax.max(o, comparator);
+        return OperatorMinMax.max(o, comparator);
     }
 
     /**
@@ -305,7 +309,7 @@ public final Observable<T> max(Comparator<? super T> comparator) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229095.aspx">MSDN: Observable.Min</a>
      */
     public final Observable<T> min(Comparator<? super T> comparator) {
-        return OperationMinMax.min(o, comparator);
+        return OperatorMinMax.min(o, comparator);
     }
 
     /**
@@ -322,7 +326,7 @@ public final Observable<T> min(Comparator<? super T> comparator) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtractor) {
-        return OperationSum.sumAtLeastOneDoubles(o.map(valueExtractor));
+        return OperatorSum.sumAtLeastOneDoubles(o.map(valueExtractor));
     }
 
     /**
@@ -339,7 +343,7 @@ public final Observable<Double> sumDouble(Func1<? super T, Double> valueExtracto
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor) {
-        return OperationSum.sumAtLeastOneFloats(o.map(valueExtractor));
+        return OperatorSum.sumAtLeastOneFloats(o.map(valueExtractor));
     }
 
     /**
@@ -356,7 +360,7 @@ public final Observable<Float> sumFloat(Func1<? super T, Float> valueExtractor)
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtractor) {
-        return OperationSum.sumAtLeastOneIntegers(o.map(valueExtractor));
+        return OperatorSum.sumAtLeastOneIntegers(o.map(valueExtractor));
     }
 
     /**
@@ -373,6 +377,6 @@ public final Observable<Integer> sumInteger(Func1<? super T, Integer> valueExtra
      * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.sum.aspx">MSDN: Observable.Sum</a>
      */
     public final Observable<Long> sumLong(Func1<? super T, Long> valueExtractor) {
-        return OperationSum.sumAtLeastOneLongs(o.map(valueExtractor));
+        return OperatorSum.sumAtLeastOneLongs(o.map(valueExtractor));
     }
 }
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorAverageTest.java
similarity index 88%
rename from rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java
rename to rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorAverageTest.java
index a77868dc7a..b53d19d874 100644
--- a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationAverageTest.java
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorAverageTest.java
@@ -15,9 +15,16 @@
  */
 package rx.math.operators;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import static rx.math.operators.OperationAverage.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyDouble;
+import static org.mockito.Matchers.anyFloat;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.isA;
+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 org.junit.Test;
 
@@ -25,8 +32,9 @@
 import rx.Observer;
 import rx.functions.Func1;
 import rx.observables.MathObservable;
+import static rx.observables.MathObservable.*;
 
-public class OperationAverageTest {
+public class OperatorAverageTest {
 
     @SuppressWarnings("unchecked")
     Observer<Integer> w = mock(Observer.class);
@@ -40,7 +48,7 @@ public class OperationAverageTest {
     @Test
     public void testAverageOfAFewInts() throws Throwable {
         Observable<Integer> src = Observable.from(1, 2, 3, 4, 6);
-        average(src).subscribe(w);
+        averageInteger(src).subscribe(w);
 
         verify(w, times(1)).onNext(anyInt());
         verify(w).onNext(3);
@@ -51,7 +59,7 @@ public void testAverageOfAFewInts() throws Throwable {
     @Test
     public void testEmptyAverage() throws Throwable {
         Observable<Integer> src = Observable.empty();
-        average(src).subscribe(w);
+        averageInteger(src).subscribe(w);
 
         verify(w, never()).onNext(anyInt());
         verify(w, times(1)).onError(isA(IllegalArgumentException.class));
@@ -61,7 +69,7 @@ public void testEmptyAverage() throws Throwable {
     @Test
     public void testAverageOfAFewLongs() throws Throwable {
         Observable<Long> src = Observable.from(1L, 2L, 3L, 4L, 6L);
-        averageLongs(src).subscribe(wl);
+        averageLong(src).subscribe(wl);
 
         verify(wl, times(1)).onNext(anyLong());
         verify(wl).onNext(3L);
@@ -72,7 +80,7 @@ public void testAverageOfAFewLongs() throws Throwable {
     @Test
     public void testEmptyAverageLongs() throws Throwable {
         Observable<Long> src = Observable.empty();
-        averageLongs(src).subscribe(wl);
+        averageLong(src).subscribe(wl);
 
         verify(wl, never()).onNext(anyLong());
         verify(wl, times(1)).onError(isA(IllegalArgumentException.class));
@@ -82,7 +90,7 @@ public void testEmptyAverageLongs() throws Throwable {
     @Test
     public void testAverageOfAFewFloats() throws Throwable {
         Observable<Float> src = Observable.from(1.0f, 2.0f);
-        averageFloats(src).subscribe(wf);
+        averageFloat(src).subscribe(wf);
 
         verify(wf, times(1)).onNext(anyFloat());
         verify(wf).onNext(1.5f);
@@ -93,7 +101,7 @@ public void testAverageOfAFewFloats() throws Throwable {
     @Test
     public void testEmptyAverageFloats() throws Throwable {
         Observable<Float> src = Observable.empty();
-        averageFloats(src).subscribe(wf);
+        averageFloat(src).subscribe(wf);
 
         verify(wf, never()).onNext(anyFloat());
         verify(wf, times(1)).onError(isA(IllegalArgumentException.class));
@@ -103,7 +111,7 @@ public void testEmptyAverageFloats() throws Throwable {
     @Test
     public void testAverageOfAFewDoubles() throws Throwable {
         Observable<Double> src = Observable.from(1.0d, 2.0d);
-        averageDoubles(src).subscribe(wd);
+        averageDouble(src).subscribe(wd);
 
         verify(wd, times(1)).onNext(anyDouble());
         verify(wd).onNext(1.5d);
@@ -114,7 +122,7 @@ public void testAverageOfAFewDoubles() throws Throwable {
     @Test
     public void testEmptyAverageDoubles() throws Throwable {
         Observable<Double> src = Observable.empty();
-        averageDoubles(src).subscribe(wd);
+        averageDouble(src).subscribe(wd);
 
         verify(wd, never()).onNext(anyDouble());
         verify(wd, times(1)).onError(isA(IllegalArgumentException.class));
@@ -144,6 +152,7 @@ public Integer call(String t1) {
         };
 
         Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -161,6 +170,7 @@ public Long call(String t1) {
         };
 
         Observable<Long> result = MathObservable.from(source).averageLong(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -178,6 +188,7 @@ public Float call(String t1) {
         };
 
         Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -195,6 +206,7 @@ public Double call(String t1) {
         };
 
         Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -212,6 +224,7 @@ public Integer call(String t1) {
         };
 
         Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -229,6 +242,7 @@ public Long call(String t1) {
         };
 
         Observable<Long> result = MathObservable.from(source).averageLong(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -246,6 +260,7 @@ public Float call(String t1) {
         };
 
         Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -263,6 +278,7 @@ public Double call(String t1) {
         };
 
         Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -280,6 +296,7 @@ public Integer call(String t1) {
         };
 
         Observable<Integer> result = MathObservable.from(source).averageInteger(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -297,6 +314,7 @@ public Long call(String t1) {
         };
 
         Observable<Long> result = MathObservable.from(source).averageLong(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -314,6 +332,7 @@ public Float call(String t1) {
         };
 
         Observable<Float> result = MathObservable.from(source).averageFloat(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -331,6 +350,7 @@ public Double call(String t1) {
         };
 
         Observable<Double> result = MathObservable.from(source).averageDouble(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -338,5 +358,6 @@ public Double call(String t1) {
     }
     
     static class CustomException extends RuntimeException {
+		private static final long serialVersionUID = 6873927510089089979L;
     }
 }
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorMinMaxTest.java
similarity index 99%
rename from rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
rename to rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorMinMaxTest.java
index 64d0a38f4d..3445b237fc 100644
--- a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationMinMaxTest.java
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorMinMaxTest.java
@@ -17,7 +17,7 @@
 
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.math.operators.OperationMinMax.*;
+import static rx.math.operators.OperatorMinMax.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -32,7 +32,7 @@
 import rx.Observer;
 import rx.functions.Func1;
 
-public class OperationMinMaxTest {
+public class OperatorMinMaxTest {
     @Test
     public void testMin() {
         Observable<Integer> observable = min(Observable.from(2, 3, 1, 4));
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorSumTest.java
similarity index 94%
rename from rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java
rename to rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorSumTest.java
index 43e2805d43..ddb057c0a9 100644
--- a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperationSumTest.java
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorSumTest.java
@@ -17,7 +17,7 @@
 
 import static org.mockito.Matchers.*;
 import static org.mockito.Mockito.*;
-import static rx.math.operators.OperationSum.*;
+import static rx.math.operators.OperatorSum.*;
 
 import org.junit.Test;
 
@@ -26,7 +26,7 @@
 import rx.functions.Func1;
 import rx.observables.MathObservable;
 
-public class OperationSumTest {
+public class OperatorSumTest {
 
     @SuppressWarnings("unchecked")
     Observer<Integer> w = mock(Observer.class);
@@ -148,6 +148,7 @@ public Integer call(String t1) {
         };
 
         Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -165,6 +166,7 @@ public Long call(String t1) {
         };
 
         Observable<Long> result = MathObservable.from(source).sumLong(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -182,6 +184,7 @@ public Float call(String t1) {
         };
 
         Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -199,6 +202,7 @@ public Double call(String t1) {
         };
 
         Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -216,6 +220,7 @@ public Integer call(String t1) {
         };
 
         Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -233,6 +238,7 @@ public Long call(String t1) {
         };
 
         Observable<Long> result = MathObservable.from(source).sumLong(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -250,6 +256,7 @@ public Float call(String t1) {
         };
 
         Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -267,6 +274,7 @@ public Double call(String t1) {
         };
 
         Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -284,6 +292,7 @@ public Integer call(String t1) {
         };
 
         Observable<Integer> result = MathObservable.from(source).sumInteger(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -301,6 +310,7 @@ public Long call(String t1) {
         };
 
         Observable<Long> result = MathObservable.from(source).sumLong(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -318,6 +328,7 @@ public Float call(String t1) {
         };
 
         Observable<Float> result = MathObservable.from(source).sumFloat(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -335,6 +346,7 @@ public Double call(String t1) {
         };
 
         Observable<Double> result = MathObservable.from(source).sumDouble(length);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         result.subscribe(o);
 
@@ -342,5 +354,6 @@ public Double call(String t1) {
     }
 
     static class CustomException extends RuntimeException {
+		private static final long serialVersionUID = 8825937249852675778L;
     }
 }

From 1ea2cb97c42d8b27cb9ebef89f678c6c4bf47674 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 29 Apr 2014 10:31:59 +0200
Subject: [PATCH 312/422] Corrected LF

---
 .../math/operators/OperatorAverageDouble.java | 156 +++++++++---------
 .../math/operators/OperatorAverageFloat.java  | 156 +++++++++---------
 .../operators/OperatorAverageInteger.java     | 156 +++++++++---------
 .../math/operators/OperatorAverageLong.java   | 156 +++++++++---------
 4 files changed, 312 insertions(+), 312 deletions(-)

diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
index 8c823b5717..baad9ff8e6 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
@@ -1,79 +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.math.operators;
-
-import rx.Observable.Operator;
-import rx.Subscriber;
-import rx.functions.Func1;
-
-/**
- * Compute the average by extracting double values from the source via an
- * extractor function.
- * 
- * @param <T>
- *            the source value type
- */
-public final class OperatorAverageDouble<T> implements Operator<Double, T> {
-    final Func1<? super T, Double> valueExtractor;
-
-    public OperatorAverageDouble(Func1<? super T, Double> valueExtractor) {
-        this.valueExtractor = valueExtractor;
-    }
-
-    @Override
-    public Subscriber<? super T> call(Subscriber<? super Double> child) {
-    	return new AverageObserver(child);
-    }
-
-    /** Computes the average. */
-    private final class AverageObserver extends Subscriber<T> {
-        final Subscriber<? super Double> child;
-        double sum;
-        int count;
-
-        public AverageObserver(Subscriber<? super Double> subscriber) {
-        	super(subscriber);
-            this.child = subscriber;
-        }
-
-        @Override
-        public void onNext(T args) {
-            sum += valueExtractor.call(args);
-            count++;
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            child.onError(e);
-        }
-
-        @Override
-        public void onCompleted() {
-            if (count > 0) {
-                try {
-                    child.onNext(sum / count);
-                } catch (Throwable t) {
-                    child.onError(t);
-                    return;
-                }
-                child.onCompleted();
-            } else {
-                child.onError(new IllegalArgumentException("Sequence contains no elements"));
-            }
-        }
-
-    }
+/**
+ * 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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting double values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageDouble<T> implements Operator<Double, T> {
+    final Func1<? super T, Double> valueExtractor;
+
+    public OperatorAverageDouble(Func1<? super T, Double> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Double> child) {
+    	return new AverageObserver(child);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Double> child;
+        double sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Double> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
 }
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
index c3699ee357..148d4f3d84 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
@@ -1,79 +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.math.operators;
-
-import rx.Observable.Operator;
-import rx.Subscriber;
-import rx.functions.Func1;
-
-/**
- * Compute the average by extracting float values from the source via an
- * extractor function.
- * 
- * @param <T>
- *            the source value type
- */
-public final class OperatorAverageFloat<T> implements Operator<Float, T> {
-    final Func1<? super T, Float> valueExtractor;
-
-    public OperatorAverageFloat(Func1<? super T, Float> valueExtractor) {
-        this.valueExtractor = valueExtractor;
-    }
-
-    @Override
-    public Subscriber<? super T> call(Subscriber<? super Float> child) {
-        return new AverageObserver(child);
-    }
-
-    /** Computes the average. */
-    private final class AverageObserver extends Subscriber<T> {
-        final Subscriber<? super Float> child;
-        float sum;
-        int count;
-
-        public AverageObserver(Subscriber<? super Float> subscriber) {
-        	super(subscriber);
-            this.child = subscriber;
-        }
-
-        @Override
-        public void onNext(T args) {
-            sum += valueExtractor.call(args);
-            count++;
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            child.onError(e);
-        }
-
-        @Override
-        public void onCompleted() {
-            if (count > 0) {
-                try {
-                    child.onNext(sum / count);
-                } catch (Throwable t) {
-                    child.onError(t);
-                    return;
-                }
-                child.onCompleted();
-            } else {
-                child.onError(new IllegalArgumentException("Sequence contains no elements"));
-            }
-        }
-
-    }
+/**
+ * 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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting float values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageFloat<T> implements Operator<Float, T> {
+    final Func1<? super T, Float> valueExtractor;
+
+    public OperatorAverageFloat(Func1<? super T, Float> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Float> child) {
+        return new AverageObserver(child);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Float> child;
+        float sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Float> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
 }
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
index 1bab7638f6..ef037101bd 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
@@ -1,79 +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.math.operators;
-
-import rx.Observable.Operator;
-import rx.Subscriber;
-import rx.functions.Func1;
-
-/**
- * Compute the average by extracting integer values from the source via an
- * extractor function.
- * 
- * @param <T>
- *            the source value type
- */
-public final class OperatorAverageInteger<T> implements Operator<Integer, T> {
-    final Func1<? super T, Integer> valueExtractor;
-
-    public OperatorAverageInteger(Func1<? super T, Integer> valueExtractor) {
-        this.valueExtractor = valueExtractor;
-    }
-
-    @Override
-    public Subscriber<? super T> call(Subscriber<? super Integer> t1) {
-        return new AverageObserver(t1);
-    }
-
-    /** Computes the average. */
-    private final class AverageObserver extends Subscriber<T> {
-        final Subscriber<? super Integer> child;
-        int sum;
-        int count;
-
-        public AverageObserver(Subscriber<? super Integer> subscriber) {
-        	super(subscriber);
-            this.child = subscriber;
-        }
-
-        @Override
-        public void onNext(T args) {
-            sum += valueExtractor.call(args);
-            count++;
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            child.onError(e);
-        }
-
-        @Override
-        public void onCompleted() {
-            if (count > 0) {
-                try {
-                    child.onNext(sum / count);
-                } catch (Throwable t) {
-                    child.onError(t);
-                    return;
-                }
-                child.onCompleted();
-            } else {
-                child.onError(new IllegalArgumentException("Sequence contains no elements"));
-            }
-        }
-
-    }
+/**
+ * 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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting integer values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageInteger<T> implements Operator<Integer, T> {
+    final Func1<? super T, Integer> valueExtractor;
+
+    public OperatorAverageInteger(Func1<? super T, Integer> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Integer> t1) {
+        return new AverageObserver(t1);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Integer> child;
+        int sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Integer> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
 }
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
index f0f03e4cc2..5f879a0528 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
@@ -1,79 +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.math.operators;
-
-import rx.Observable.Operator;
-import rx.Subscriber;
-import rx.functions.Func1;
-
-/**
- * Compute the average by extracting long values from the source via an
- * extractor function.
- * 
- * @param <T>
- *            the source value type
- */
-public final class OperatorAverageLong<T> implements Operator<Long, T> {
-    final Func1<? super T, Long> valueExtractor;
-
-    public OperatorAverageLong(Func1<? super T, Long> valueExtractor) {
-        this.valueExtractor = valueExtractor;
-    }
-
-    @Override
-    public Subscriber<? super T> call(Subscriber<? super Long> child) {
-        return new AverageObserver(child);
-    }
-
-    /** Computes the average. */
-    private final class AverageObserver extends Subscriber<T> {
-        final Subscriber<? super Long> child;
-        long sum;
-        int count;
-
-        public AverageObserver(Subscriber<? super Long> subscriber) {
-        	super(subscriber);
-            this.child = subscriber;
-        }
-
-        @Override
-        public void onNext(T args) {
-            sum += valueExtractor.call(args);
-            count++;
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            child.onError(e);
-        }
-
-        @Override
-        public void onCompleted() {
-            if (count > 0) {
-                try {
-                    child.onNext(sum / count);
-                } catch (Throwable t) {
-                    child.onError(t);
-                    return;
-                }
-                child.onCompleted();
-            } else {
-                child.onError(new IllegalArgumentException("Sequence contains no elements"));
-            }
-        }
-
-    }
+/**
+ * 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.math.operators;
+
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.functions.Func1;
+
+/**
+ * Compute the average by extracting long values from the source via an
+ * extractor function.
+ * 
+ * @param <T>
+ *            the source value type
+ */
+public final class OperatorAverageLong<T> implements Operator<Long, T> {
+    final Func1<? super T, Long> valueExtractor;
+
+    public OperatorAverageLong(Func1<? super T, Long> valueExtractor) {
+        this.valueExtractor = valueExtractor;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Long> child) {
+        return new AverageObserver(child);
+    }
+
+    /** Computes the average. */
+    private final class AverageObserver extends Subscriber<T> {
+        final Subscriber<? super Long> child;
+        long sum;
+        int count;
+
+        public AverageObserver(Subscriber<? super Long> subscriber) {
+        	super(subscriber);
+            this.child = subscriber;
+        }
+
+        @Override
+        public void onNext(T args) {
+            sum += valueExtractor.call(args);
+            count++;
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (count > 0) {
+                try {
+                    child.onNext(sum / count);
+                } catch (Throwable t) {
+                    child.onError(t);
+                    return;
+                }
+                child.onCompleted();
+            } else {
+                child.onError(new IllegalArgumentException("Sequence contains no elements"));
+            }
+        }
+
+    }
 }
\ No newline at end of file

From bc202f40b820c0804ddbf6feaaee4a5d33602826 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 29 Apr 2014 10:59:29 +0200
Subject: [PATCH 313/422] Operator When

---
 ...atterns.java => OperatorJoinPatterns.java} | 20 ++++++-------
 .../java/rx/observables/JoinObservable.java   | 28 +++++++++----------
 ...nJoinsTest.java => OperatorJoinsTest.java} |  2 +-
 3 files changed, 25 insertions(+), 25 deletions(-)
 rename rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/{OperationJoinPatterns.java => OperatorJoinPatterns.java} (88%)
 rename rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/{OperationJoinsTest.java => OperatorJoinsTest.java} (99%)

diff --git a/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperationJoinPatterns.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperatorJoinPatterns.java
similarity index 88%
rename from rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperationJoinPatterns.java
rename to rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperatorJoinPatterns.java
index 81ea84aee1..1079796f03 100644
--- a/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperationJoinPatterns.java
+++ b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperatorJoinPatterns.java
@@ -22,9 +22,9 @@
 import java.util.Map;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.joins.ActivePlan0;
@@ -32,13 +32,12 @@
 import rx.joins.Pattern1;
 import rx.joins.Pattern2;
 import rx.joins.Plan0;
-import rx.observers.Subscribers;
 import rx.subscriptions.CompositeSubscription;
 
 /**
  * Join patterns: And, Then, When.
  */
-public class OperationJoinPatterns {
+public class OperatorJoinPatterns {
     /**
      * Creates a pattern that matches when both observable sequences have an available element.
      */
@@ -68,7 +67,7 @@ public static <T1, R> Plan0<R> then(/* this */Observable<T1> source, Func1<T1, R
     /**
      * Joins together the results from several patterns.
      */
-    public static <R> OnSubscribeFunc<R> when(Plan0<R>... plans) {
+    public static <R> OnSubscribe<R> when(Plan0<R>... plans) {
         if (plans == null) {
             throw new NullPointerException("plans");
         }
@@ -78,13 +77,13 @@ public static <R> OnSubscribeFunc<R> when(Plan0<R>... plans) {
     /**
      * Joins together the results from several patterns.
      */
-    public static <R> OnSubscribeFunc<R> when(final Iterable<? extends Plan0<R>> plans) {
+    public static <R> OnSubscribe<R> when(final Iterable<? extends Plan0<R>> plans) {
         if (plans == null) {
             throw new NullPointerException("plans");
         }
-        return new OnSubscribeFunc<R>() {
+        return new OnSubscribe<R>() {
             @Override
-            public Subscription onSubscribe(final Observer<? super R> t1) {
+            public void call(final Subscriber<? super R> t1) {
                 final Map<Object, JoinObserver> externalSubscriptions = new HashMap<Object, JoinObserver>();
                 final Object gate = new Object();
                 final List<ActivePlan0> activePlans = new ArrayList<ActivePlan0>();
@@ -122,14 +121,15 @@ public void call(ActivePlan0 activePlan) {
                         }));
                     }
                 } catch (Throwable t) {
-                    return Observable.<R> error(t).unsafeSubscribe(Subscribers.from(t1));
+                	Observable.<R> error(t).unsafeSubscribe(t1);
+                    return;
                 }
                 CompositeSubscription group = new CompositeSubscription();
+                t1.add(group);
                 for (JoinObserver jo : externalSubscriptions.values()) {
                     jo.subscribe(gate);
                     group.add(jo);
                 }
-                return group;
             }
         };
     }
diff --git a/rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java
index d79b1f2204..2faefd2d4c 100644
--- a/rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java
+++ b/rxjava-contrib/rxjava-joins/src/main/java/rx/observables/JoinObservable.java
@@ -4,7 +4,7 @@
 import rx.functions.Func1;
 import rx.joins.Pattern2;
 import rx.joins.Plan0;
-import rx.joins.operators.OperationJoinPatterns;
+import rx.joins.operators.OperatorJoinPatterns;
 
 public class JoinObservable<T> {
 
@@ -32,7 +32,7 @@ public static <T> JoinObservable<T> from(Observable<T> o) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229153.aspx">MSDN: Observable.And</a>
      */
     public final <T2> Pattern2<T, T2> and(Observable<T2> right) {
-        return OperationJoinPatterns.and(o, right);
+        return OperatorJoinPatterns.and(o, right);
     }
 
     /**
@@ -52,7 +52,7 @@ public final static <R> JoinObservable<R> when(Iterable<? extends Plan0<R>> plan
         if (plans == null) {
             throw new NullPointerException("plans");
         }
-        return from(Observable.create(OperationJoinPatterns.when(plans)));
+        return from(Observable.create(OperatorJoinPatterns.when(plans)));
     }
 
     /**
@@ -69,7 +69,7 @@ public final static <R> JoinObservable<R> when(Iterable<? extends Plan0<R>> plan
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229889.aspx">MSDN: Observable.When</a>
      */
     public final static <R> JoinObservable<R> when(Plan0<R>... plans) {
-        return from(Observable.create(OperationJoinPatterns.when(plans)));
+        return from(Observable.create(OperatorJoinPatterns.when(plans)));
     }
 
     /**
@@ -85,7 +85,7 @@ public final static <R> JoinObservable<R> when(Plan0<R>... plans) {
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1) {
-        return from(Observable.create(OperationJoinPatterns.when(p1)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1)));
     }
 
     /**
@@ -103,7 +103,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1) {
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2)));
     }
 
     /**
@@ -123,7 +123,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2) {
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2, p3)));
     }
 
     /**
@@ -145,7 +145,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2, p3, p4)));
     }
 
     /**
@@ -169,7 +169,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2, p3, p4, p5)));
     }
 
     /**
@@ -195,7 +195,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2, p3, p4, p5, p6)));
     }
 
     /**
@@ -223,7 +223,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7)));
     }
 
     /**
@@ -253,7 +253,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7, Plan0<R> p8) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8)));
     }
 
     /**
@@ -285,7 +285,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R
      */
     @SuppressWarnings("unchecked")
     public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R> p3, Plan0<R> p4, Plan0<R> p5, Plan0<R> p6, Plan0<R> p7, Plan0<R> p8, Plan0<R> p9) {
-        return from(Observable.create(OperationJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8, p9)));
+        return from(Observable.create(OperatorJoinPatterns.when(p1, p2, p3, p4, p5, p6, p7, p8, p9)));
     }
 
     /**
@@ -303,7 +303,7 @@ public final static <R> JoinObservable<R> when(Plan0<R> p1, Plan0<R> p2, Plan0<R
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211662.aspx">MSDN: Observable.Then</a>
      */
     public final <R> Plan0<R> then(Func1<T, R> selector) {
-        return OperationJoinPatterns.then(o, selector);
+        return OperatorJoinPatterns.then(o, selector);
     }
     
     public Observable<T> toObservable() {
diff --git a/rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperationJoinsTest.java b/rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperatorJoinsTest.java
similarity index 99%
rename from rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperationJoinsTest.java
rename to rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperatorJoinsTest.java
index 3b5fac3050..b6b5dfe5a3 100644
--- a/rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperationJoinsTest.java
+++ b/rxjava-contrib/rxjava-joins/src/test/java/rx/joins/operators/OperatorJoinsTest.java
@@ -40,7 +40,7 @@
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
 
-public class OperationJoinsTest {
+public class OperatorJoinsTest {
     @Mock
     Observer<Integer> observer;
 

From b16727cd5437122f73108fe68c7a420f4679b9da Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 29 Apr 2014 13:25:16 +0200
Subject: [PATCH 314/422] Fix for SerializedObserverTest

---
 .../rx/observers/SerializedObserverTest.java  | 202 ++++++++++--------
 1 file changed, 107 insertions(+), 95 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index 32f9f359e7..27174fb599 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -64,7 +64,7 @@ private Observer<String> serializedObserver(Observer<String> o) {
     @Test
     public void testSingleThreadedBasic() {
         Subscription s = mock(Subscription.class);
-        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
+        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable("one", "two", "three");
         Observable<String> w = Observable.create(onSubscribe);
 
         Observer<String> aw = serializedObserver(observer);
@@ -84,8 +84,7 @@ public void testSingleThreadedBasic() {
 
     @Test
     public void testMultiThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three");
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyObserver = new BusyObserver();
@@ -109,8 +108,7 @@ public void testMultiThreadedBasic() {
 
     @Test(timeout = 1000)
     public void testMultiThreadedWithNPE() throws InterruptedException {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null);
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyObserver = new BusyObserver();
@@ -141,40 +139,40 @@ public void testMultiThreadedWithNPE() throws InterruptedException {
 
     @Test
     public void testMultiThreadedWithNPEinMiddle() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
-        Observable<String> w = Observable.create(onSubscribe);
-
-        BusyObserver busyObserver = new BusyObserver();
-        Observer<String> aw = serializedObserver(busyObserver);
-
-        w.subscribe(aw);
-        onSubscribe.waitToFinish();
-
-        System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
-
-        // we can have concurrency ...
-        assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
-        // ... but the onNext execution should be single threaded
-        assertEquals(1, busyObserver.maxConcurrentThreads.get());
-
-        // this should not be the full number of items since the error should stop it before it completes all 9
-        System.out.println("onNext count: " + busyObserver.onNextCount.get());
-        assertTrue(busyObserver.onNextCount.get() < 9);
-        assertTrue(busyObserver.onError);
-        // no onCompleted because onError was invoked
-        assertFalse(busyObserver.onCompleted);
-        // non-deterministic because unsubscribe happens after 'waitToFinish' releases
-        // so commenting out for now as this is not a critical thing to test here
-        // verify(s, times(1)).unsubscribe();
+        int n = 10;
+        for (int i = 0; i < n; i++) {
+            TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, 
+                    "four", "five", "six", "seven", "eight", "nine");
+            Observable<String> w = Observable.create(onSubscribe);
+
+            BusyObserver busyObserver = new BusyObserver();
+            Observer<String> aw = serializedObserver(busyObserver);
+
+            w.subscribe(aw);
+            onSubscribe.waitToFinish();
+
+            System.out.println("OnSubscribe maxConcurrentThreads: " + onSubscribe.maxConcurrentThreads.get() + "  Observer maxConcurrentThreads: " + busyObserver.maxConcurrentThreads.get());
+
+            // we can have concurrency ...
+            assertTrue(onSubscribe.maxConcurrentThreads.get() > 1);
+            // ... but the onNext execution should be single threaded
+            assertEquals(1, busyObserver.maxConcurrentThreads.get());
+
+            // this should not be the full number of items since the error should stop it before it completes all 9
+            System.out.println("onNext count: " + busyObserver.onNextCount.get());
+            assertFalse(busyObserver.onCompleted);
+            assertTrue(busyObserver.onError);
+            assertTrue(busyObserver.onNextCount.get() < 9);
+            // no onCompleted because onError was invoked
+            // non-deterministic because unsubscribe happens after 'waitToFinish' releases
+            // so commenting out for now as this is not a critical thing to test here
+            // verify(s, times(1)).unsubscribe();
+        }
     }
 
     /**
      * A non-realistic use case that tries to expose thread-safety issues by throwing lots of out-of-order
      * events on many threads.
-     * 
-     * @param w
-     * @param tw
      */
     @Test
     public void runOutOfOrderConcurrencyTest() {
@@ -226,11 +224,6 @@ public void runOutOfOrderConcurrencyTest() {
         }
     }
 
-    /**
-     * 
-     * @param w
-     * @param tw
-     */
     @Test
     public void runConcurrencyTest() {
         ExecutorService tp = Executors.newFixedThreadPool(20);
@@ -283,59 +276,68 @@ public void runConcurrencyTest() {
     @Test
     public void testNotificationDelay() throws InterruptedException {
         ExecutorService tp = Executors.newFixedThreadPool(2);
+        try {
+            int n = 10;
+            for (int i = 0; i < n; i++) {
+                final CountDownLatch firstOnNext = new CountDownLatch(1);
+                final CountDownLatch onNextCount = new CountDownLatch(2);
+                final CountDownLatch latch = new CountDownLatch(1);
+                final CountDownLatch running = new CountDownLatch(2);
 
-        final CountDownLatch firstOnNext = new CountDownLatch(1);
-        final CountDownLatch onNextCount = new CountDownLatch(2);
-        final CountDownLatch latch = new CountDownLatch(1);
+                TestSubscriber<String> to = new TestSubscriber<String>(new Observer<String>() {
 
-        TestSubscriber<String> to = new TestSubscriber<String>(new Observer<String>() {
+                    @Override
+                    public void onCompleted() {
 
-            @Override
-            public void onCompleted() {
-
-            }
+                    }
 
-            @Override
-            public void onError(Throwable e) {
+                    @Override
+                    public void onError(Throwable e) {
 
-            }
+                    }
 
-            @Override
-            public void onNext(String t) {
-                firstOnNext.countDown();
-                // force it to take time when delivering so the second one is enqueued
-                try {
-                    latch.await();
-                } catch (InterruptedException e) {
-                }
-            }
+                    @Override
+                    public void onNext(String t) {
+                        firstOnNext.countDown();
+                        // force it to take time when delivering so the second one is enqueued
+                        try {
+                            latch.await();
+                        } catch (InterruptedException e) {
+                        }
+                    }
 
-        });
-        Observer<String> o = serializedObserver(to);
+                });
+                Observer<String> o = serializedObserver(to);
 
-        Future<?> f1 = tp.submit(new OnNextThread(o, 1, onNextCount));
-        Future<?> f2 = tp.submit(new OnNextThread(o, 1, onNextCount));
+                Future<?> f1 = tp.submit(new OnNextThread(o, 1, onNextCount, running));
+                Future<?> f2 = tp.submit(new OnNextThread(o, 1, onNextCount, running));
 
-        firstOnNext.await();
+                running.await(); // let one of the OnNextThread actually run before proceeding
+                
+                firstOnNext.await();
 
-        Thread t1 = to.getLastSeenThread();
-        System.out.println("first onNext on thread: " + t1);
+                Thread t1 = to.getLastSeenThread();
+                System.out.println("first onNext on thread: " + t1);
 
-        latch.countDown();
+                latch.countDown();
 
-        waitOnThreads(f1, f2);
-        // not completed yet
+                waitOnThreads(f1, f2);
+                // not completed yet
 
-        assertEquals(2, to.getOnNextEvents().size());
+                assertEquals(2, to.getOnNextEvents().size());
 
-        Thread t2 = to.getLastSeenThread();
-        System.out.println("second onNext on thread: " + t2);
+                Thread t2 = to.getLastSeenThread();
+                System.out.println("second onNext on thread: " + t2);
 
-        assertSame(t1, t2);
+                assertSame(t1, t2);
 
-        System.out.println(to.getOnNextEvents());
-        o.onCompleted();
-        System.out.println(to.getOnNextEvents());
+                System.out.println(to.getOnNextEvents());
+                o.onCompleted();
+                System.out.println(to.getOnNextEvents());
+            }
+        } finally {
+            tp.shutdown();
+        }
     }
 
     /**
@@ -435,20 +437,22 @@ public static class OnNextThread implements Runnable {
         private final Observer<String> observer;
         private final int numStringsToSend;
         final AtomicInteger produced;
+        private final CountDownLatch running;
 
-        OnNextThread(Observer<String> observer, int numStringsToSend, CountDownLatch latch) {
-            this(observer, numStringsToSend, new AtomicInteger(), latch);
+        OnNextThread(Observer<String> observer, int numStringsToSend, CountDownLatch latch, CountDownLatch running) {
+            this(observer, numStringsToSend, new AtomicInteger(), latch, running);
         }
 
         OnNextThread(Observer<String> observer, int numStringsToSend, AtomicInteger produced) {
-            this(observer, numStringsToSend, produced, null);
+            this(observer, numStringsToSend, produced, null, null);
         }
 
-        OnNextThread(Observer<String> observer, int numStringsToSend, AtomicInteger produced, CountDownLatch latch) {
+        OnNextThread(Observer<String> observer, int numStringsToSend, AtomicInteger produced, CountDownLatch latch, CountDownLatch running) {
             this.observer = observer;
             this.numStringsToSend = numStringsToSend;
             this.produced = produced;
             this.latch = latch;
+            this.running = running;
         }
 
         OnNextThread(Observer<String> observer, int numStringsToSend) {
@@ -457,6 +461,9 @@ public static class OnNextThread implements Runnable {
 
         @Override
         public void run() {
+            if (running != null) {
+                running.countDown();
+            }
             for (int i = 0; i < numStringsToSend; i++) {
                 observer.onNext(Thread.currentThread().getId() + "-" + i);
                 if (latch != null) {
@@ -603,19 +610,18 @@ public int assertEvents(TestConcurrencyObserverEvent expectedEndingEvent) throws
     /**
      * This spawns a single thread for the subscribe execution
      */
-    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestSingleThreadedObservable implements Observable.OnSubscribe<String> {
 
-        final Subscription s;
         final String[] values;
         private Thread t = null;
 
-        public TestSingleThreadedObservable(final Subscription s, final String... values) {
-            this.s = s;
+        public TestSingleThreadedObservable(final String... values) {
             this.values = values;
 
         }
 
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        @Override
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestSingleThreadedObservable subscribed to ...");
             t = new Thread(new Runnable() {
 
@@ -637,7 +643,6 @@ public void run() {
             System.out.println("starting TestSingleThreadedObservable thread");
             t.start();
             System.out.println("done starting TestSingleThreadedObservable thread");
-            return s;
         }
 
         public void waitToFinish() {
@@ -653,23 +658,21 @@ public void waitToFinish() {
     /**
      * This spawns a thread for the subscription, then a separate thread for each onNext call.
      */
-    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestMultiThreadedObservable implements Observable.OnSubscribe<String> {
 
-        final Subscription s;
         final String[] values;
         Thread t = null;
         AtomicInteger threadsRunning = new AtomicInteger();
         AtomicInteger maxConcurrentThreads = new AtomicInteger();
         ExecutorService threadPool;
 
-        public TestMultiThreadedObservable(Subscription s, String... values) {
-            this.s = s;
+        public TestMultiThreadedObservable(String... values) {
             this.values = values;
             this.threadPool = Executors.newCachedThreadPool();
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestMultiThreadedObservable subscribed to ...");
             t = new Thread(new Runnable() {
 
@@ -677,7 +680,9 @@ public Subscription onSubscribe(final Observer<? super String> observer) {
                 public void run() {
                     try {
                         System.out.println("running TestMultiThreadedObservable thread");
+                        int j = 0;
                         for (final String s : values) {
+                            final int fj = ++j;
                             threadPool.execute(new Runnable() {
 
                                 @Override
@@ -685,10 +690,16 @@ public void run() {
                                     threadsRunning.incrementAndGet();
                                     try {
                                         // perform onNext call
-                                        System.out.println("TestMultiThreadedObservable onNext: " + s);
+                                        System.out.println("TestMultiThreadedObservable onNext: " + s + " on thread " + Thread.currentThread().getName());
                                         if (s == null) {
                                             // force an error
                                             throw new NullPointerException();
+                                        } else {
+                                             // allow the exception to queue up
+                                            int sleep = (fj % 3) * 10;
+                                            if (sleep != 0) {
+                                                Thread.sleep(sleep);
+                                            }
                                         }
                                         observer.onNext(s);
                                         // capture 'maxThreads'
@@ -714,7 +725,9 @@ public void run() {
                     // wait until all threads are done, then mark it as COMPLETED
                     try {
                         // wait for all the threads to finish
-                        threadPool.awaitTermination(2, TimeUnit.SECONDS);
+                        if (!threadPool.awaitTermination(5, TimeUnit.SECONDS)) {
+                            System.out.println("Threadpool did not terminate in time.");
+                        }
                     } catch (InterruptedException e) {
                         throw new RuntimeException(e);
                     }
@@ -724,7 +737,6 @@ public void run() {
             System.out.println("starting TestMultiThreadedObservable thread");
             t.start();
             System.out.println("done starting TestMultiThreadedObservable thread");
-            return s;
         }
 
         public void waitToFinish() {
@@ -776,7 +788,7 @@ public void onNext(String args) {
                 onNextCount.incrementAndGet();
                 try {
                     // simulate doing something computational
-                    Thread.sleep(200);
+                    Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }

From 6fe11aa16761d17986457a5b80a6f4d0e84f1d0e Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 29 Apr 2014 14:05:49 +0200
Subject: [PATCH 315/422] Conditional statements contribution to Operator

---
 .../src/main/java/rx/Statement.java           |  29 +-
 .../rx/operators/OperationConditionals.java   | 324 ------------------
 .../java/rx/operators/OperatorIfThen.java     |  41 +++
 .../java/rx/operators/OperatorSwitchCase.java |  48 +++
 .../rx/operators/OperatorWhileDoWhile.java    | 129 +++++++
 ...est.java => OperatorConditionalsTest.java} |   8 +-
 6 files changed, 243 insertions(+), 336 deletions(-)
 delete mode 100644 rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
 create mode 100644 rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.java
 create mode 100644 rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.java
 create mode 100644 rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.java
 rename rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/{OperationConditionalsTest.java => OperatorConditionalsTest.java} (98%)

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 4064750139..f536b9c8d5 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
@@ -18,13 +18,15 @@
 import java.util.Map;
 
 import rx.functions.Func0;
-import rx.operators.OperationConditionals;
+import rx.operators.OperatorIfThen;
+import rx.operators.OperatorSwitchCase;
+import rx.operators.OperatorWhileDoWhile;
 
 /**
  * Imperative statements expressed as Observable operators.
  */
-public class Statement {
-
+public final class Statement {
+	private Statement() { throw new IllegalStateException("No instances!"); }
     /**
      * Return a particular one of several possible Observables based on a case
      * selector.
@@ -99,7 +101,7 @@ public static <K, R> Observable<R> switchCase(Func0<? extends K> caseSelector,
     public static <K, R> Observable<R> switchCase(Func0<? extends K> caseSelector,
             Map<? super K, ? extends Observable<? extends R>> mapOfCases,
             Observable<? extends R> defaultCase) {
-        return Observable.create(OperationConditionals.switchCase(caseSelector, mapOfCases, defaultCase));
+        return Observable.create(new OperatorSwitchCase<K, R>(caseSelector, mapOfCases, defaultCase));
     }
 
     /**
@@ -116,8 +118,8 @@ public static <K, R> Observable<R> switchCase(Func0<? extends K> caseSelector,
      *         Observable, and then continues to replay them so long as the post
      *         condition is true
      */
-    public static <T> Observable<T> doWhile(Observable<T> source, Func0<Boolean> postCondition) {
-        return Observable.create(OperationConditionals.doWhile(source, postCondition));
+    public static <T> Observable<T> doWhile(Observable<? extends T> source, Func0<Boolean> postCondition) {
+        return Observable.create(new OperatorWhileDoWhile<T>(source, TRUE, postCondition));
     }
 
     /**
@@ -132,8 +134,8 @@ public static <T> Observable<T> doWhile(Observable<T> source, Func0<Boolean> pos
      * @return an Observable that replays the emissions from the source
      *         Observable so long as <code>preCondition</code> is true
      */
-    public static <T> Observable<T> whileDo(Observable<T> source, Func0<Boolean> preCondition) {
-        return Observable.create(OperationConditionals.whileDo(source, preCondition));
+    public static <T> Observable<T> whileDo(Observable<? extends T> source, Func0<Boolean> preCondition) {
+        return Observable.create(new OperatorWhileDoWhile<T>(source, preCondition, preCondition));
     }
 
     /**
@@ -200,7 +202,16 @@ public static <R> Observable<R> ifThen(Func0<Boolean> condition, Observable<? ex
      */
     public static <R> Observable<R> ifThen(Func0<Boolean> condition, Observable<? extends R> then,
             Observable<? extends R> orElse) {
-        return Observable.create(OperationConditionals.ifThen(condition, then, orElse));
+        return Observable.create(new OperatorIfThen<R>(condition, then, orElse));
+    }
+    /** Returns always true. */
+    private static final class Func0True implements Func0<Boolean> {
+        @Override
+        public Boolean call() {
+            return true;
+        }
     }
 
+    /** Returns always true function. */
+    private static final Func0True TRUE = new Func0True();
 }
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
deleted file mode 100644
index 61eb86c77a..0000000000
--- a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperationConditionals.java
+++ /dev/null
@@ -1,324 +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.Map;
-
-import rx.Observable;
-import rx.Observable.OnSubscribe;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Func0;
-import rx.subscriptions.MultipleAssignmentSubscription;
-import rx.subscriptions.SerialSubscription;
-import rx.subscriptions.Subscriptions;
-
-/**
- * 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 <K>
-     *            the case key type
-     * @param <R>
-     *            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 <K, R> OnSubscribeFunc<R> switchCase(
-            Func0<? extends K> caseSelector,
-            Map<? super K, ? extends Observable<? extends R>> mapOfCases,
-            Observable<? extends R> defaultCase) {
-        return new SwitchCase<K, R>(caseSelector, mapOfCases, defaultCase);
-    }
-
-    /**
-     * Return a subscription function that subscribes to either the
-     * then or orElse Observables depending on a condition function.
-     * 
-     * @param <R>
-     *            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 <R> OnSubscribeFunc<R> ifThen(
-            Func0<Boolean> condition,
-            Observable<? extends R> then,
-            Observable<? extends R> orElse) {
-        return new IfThen<R>(condition, then, orElse);
-    }
-
-    /**
-     * Return a subscription function that subscribes to the source Observable,
-     * then resubscribes only if the postCondition evaluates to true.
-     * 
-     * @param <T>
-     *            the result value type
-     * @param source
-     *            the source Observable
-     * @param postCondition
-     *            the post condition after the source completes
-     * @return a subscription function.
-     */
-    public static <T> OnSubscribe<T> doWhile(Observable<? extends T> source, Func0<Boolean> postCondition) {
-        return new WhileDoWhile<T>(source, TRUE, postCondition);
-    }
-
-    /**
-     * Return a subscription function that subscribes and resubscribes to the source
-     * Observable if the preCondition evaluates to true.
-     * 
-     * @param <T>
-     *            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 <T> OnSubscribe<T> whileDo(Observable<? extends T> source, Func0<Boolean> preCondition) {
-        return new WhileDoWhile<T>(source, preCondition, preCondition);
-    }
-
-    /**
-     * Select an observable from a map based on a case key returned by a selector
-     * function when an observer subscribes.
-     * 
-     * @param <K>
-     *            the case key type
-     * @param <R>
-     *            the result value type
-     */
-    private static final class SwitchCase<K, R> implements OnSubscribeFunc<R> {
-        final Func0<? extends K> caseSelector;
-        final Map<? super K, ? extends Observable<? extends R>> mapOfCases;
-        final Observable<? extends R> defaultCase;
-
-        public SwitchCase(Func0<? extends K> caseSelector,
-                Map<? super K, ? extends Observable<? extends R>> mapOfCases,
-                Observable<? extends R> defaultCase) {
-            this.caseSelector = caseSelector;
-            this.mapOfCases = mapOfCases;
-            this.defaultCase = defaultCase;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super R> t1) {
-            Observable<? extends R> 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<Boolean> {
-        @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 <R>
-     *            the result value type
-     */
-    private static final class IfThen<R> implements OnSubscribeFunc<R> {
-        final Func0<Boolean> condition;
-        final Observable<? extends R> then;
-        final Observable<? extends R> orElse;
-
-        public IfThen(Func0<Boolean> condition, Observable<? extends R> then, Observable<? extends R> orElse) {
-            this.condition = condition;
-            this.then = then;
-            this.orElse = orElse;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super R> t1) {
-            Observable<? extends R> 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.
-     * <p>
-     * This combines the While and DoWhile into a single operation through
-     * the conditions.
-     * 
-     * @param <T>
-     *            the result value type
-     */
-    private static final class WhileDoWhile<T> implements OnSubscribe<T> {
-        final Func0<Boolean> preCondition;
-        final Func0<Boolean> postCondition;
-        final Observable<? extends T> source;
-
-        public WhileDoWhile(Observable<? extends T> source,
-                Func0<Boolean> preCondition, Func0<Boolean> postCondition) {
-            this.source = source;
-            this.preCondition = preCondition;
-            this.postCondition = postCondition;
-        }
-
-        @Override
-        public void call(Subscriber<? super T> child) {
-            boolean first;
-            try {
-                first = preCondition.call();
-            } catch (Throwable t) {
-                child.onError(t);
-                return;
-            }
-
-            SerialSubscription cancel = new SerialSubscription();
-            final WhileDoWhile<T>.SourceObserver sourceObserver = new SourceObserver(child, cancel);
-
-            if (first) {
-                Subscriber<T> firstSubscription = new Subscriber<T>() {
-
-                    @Override
-                    public void onCompleted() {
-                        sourceObserver.onCompleted();
-                    }
-
-                    @Override
-                    public void onError(Throwable e) {
-                        sourceObserver.onError(e);
-                    }
-
-                    @Override
-                    public void onNext(T t) {
-                        sourceObserver.onNext(t);
-                    }
-
-                };
-                cancel.set(firstSubscription);
-                source.unsafeSubscribe(firstSubscription);
-            } else {
-                child.onCompleted();
-            }
-        }
-
-        /** Observe the source. */
-        final class SourceObserver implements Observer<T> {
-            final Subscriber<? super T> actual;
-            final SerialSubscription cancel;
-
-            public SourceObserver(Subscriber<? super T> actual, SerialSubscription cancel) {
-                this.actual = actual;
-                this.cancel = cancel;
-            }
-
-            @Override
-            public void onNext(T args) {
-                actual.onNext(args);
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                actual.onError(e);
-            }
-
-            @Override
-            public void onCompleted() {
-                boolean next;
-                try {
-                    next = postCondition.call();
-                } catch (Throwable t) {
-                    actual.onError(t);
-                    return;
-                }
-                if (next) {
-                    Subscriber<T> newSubscription = new Subscriber<T>() {
-
-                        @Override
-                        public void onCompleted() {
-                            SourceObserver.this.onCompleted();
-                        }
-
-                        @Override
-                        public void onError(Throwable e) {
-                            SourceObserver.this.onError(e);
-                        }
-
-                        @Override
-                        public void onNext(T t) {
-                            SourceObserver.this.onNext(t);
-                        }
-
-                    };
-                    cancel.set(newSubscription);
-                    source.unsafeSubscribe(newSubscription);
-
-                } else {
-                    actual.onCompleted();
-                }
-            }
-
-        }
-    }
-}
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.java
new file mode 100644
index 0000000000..827124e29a
--- /dev/null
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.java
@@ -0,0 +1,41 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Func0;
+
+/**
+ * Given a condition, subscribe to one of the observables when an Observer
+ * subscribes.
+ * 
+ * @param <R>
+ *            the result value type
+ */
+public final class OperatorIfThen<R> implements OnSubscribe<R> {
+    final Func0<Boolean> condition;
+    final Observable<? extends R> then;
+    final Observable<? extends R> orElse;
+
+    public OperatorIfThen(Func0<Boolean> condition, Observable<? extends R> then, Observable<? extends R> orElse) {
+        this.condition = condition;
+        this.then = then;
+        this.orElse = orElse;
+    }
+
+    @Override
+    public void call(Subscriber<? super R> t1) {
+        Observable<? extends R> target;
+        try {
+            if (condition.call()) {
+                target = then;
+            } else {
+                target = orElse;
+            }
+        } catch (Throwable t) {
+            t1.onError(t);
+            return;
+        }
+        target.subscribe(t1);
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.java
new file mode 100644
index 0000000000..53cf09f62f
--- /dev/null
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.java
@@ -0,0 +1,48 @@
+package rx.operators;
+
+import java.util.Map;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Func0;
+
+/**
+ * Select an observable from a map based on a case key returned by a selector
+ * function when an observer subscribes.
+ * 
+ * @param <K>
+ *            the case key type
+ * @param <R>
+ *            the result value type
+ */
+public final class OperatorSwitchCase<K, R> implements OnSubscribe<R> {
+    final Func0<? extends K> caseSelector;
+    final Map<? super K, ? extends Observable<? extends R>> mapOfCases;
+    final Observable<? extends R> defaultCase;
+
+    public OperatorSwitchCase(Func0<? extends K> caseSelector,
+            Map<? super K, ? extends Observable<? extends R>> mapOfCases,
+            Observable<? extends R> defaultCase) {
+        this.caseSelector = caseSelector;
+        this.mapOfCases = mapOfCases;
+        this.defaultCase = defaultCase;
+    }
+
+    @Override
+    public void call(Subscriber<? super R> t1) {
+        Observable<? extends R> target;
+        try {
+            K caseKey = caseSelector.call();
+            if (mapOfCases.containsKey(caseKey)) {
+                target = mapOfCases.get(caseKey);
+            } else {
+                target = defaultCase;
+            }
+        } catch (Throwable t) {
+            t1.onError(t);
+            return;
+        }
+        target.subscribe(t1);
+    }
+}
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.java
new file mode 100644
index 0000000000..bade4c427e
--- /dev/null
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.java
@@ -0,0 +1,129 @@
+package rx.operators;
+
+import rx.Observable;
+import rx.Observer;
+import rx.Subscriber;
+import rx.Observable.OnSubscribe;
+import rx.functions.Func0;
+import rx.subscriptions.SerialSubscription;
+
+/**
+ * Repeatedly subscribes to the source observable if the pre- or
+ * postcondition is true.
+ * <p>
+ * This combines the While and DoWhile into a single operation through
+ * the conditions.
+ * 
+ * @param <T>
+ *            the result value type
+ */
+public final class OperatorWhileDoWhile<T> implements OnSubscribe<T> {
+    final Func0<Boolean> preCondition;
+    final Func0<Boolean> postCondition;
+    final Observable<? extends T> source;
+
+    public OperatorWhileDoWhile(Observable<? extends T> source,
+            Func0<Boolean> preCondition, Func0<Boolean> postCondition) {
+        this.source = source;
+        this.preCondition = preCondition;
+        this.postCondition = postCondition;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> child) {
+        boolean first;
+        try {
+            first = preCondition.call();
+        } catch (Throwable t) {
+            child.onError(t);
+            return;
+        }
+
+        if (first) {
+            SerialSubscription cancel = new SerialSubscription();
+            child.add(cancel);
+            final SourceObserver sourceObserver = new SourceObserver(child, cancel);
+
+            Subscriber<T> firstSubscription = new Subscriber<T>() {
+
+                @Override
+                public void onCompleted() {
+                    sourceObserver.onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    sourceObserver.onError(e);
+                }
+
+                @Override
+                public void onNext(T t) {
+                    sourceObserver.onNext(t);
+                }
+
+            };
+            cancel.set(firstSubscription);
+            source.unsafeSubscribe(firstSubscription);
+        } else {
+            child.onCompleted();
+        }
+    }
+
+    /** Observe the source. */
+    final class SourceObserver implements Observer<T> {
+        final Subscriber<? super T> actual;
+        final SerialSubscription cancel;
+
+        public SourceObserver(Subscriber<? super T> actual, SerialSubscription cancel) {
+            this.actual = actual;
+            this.cancel = cancel;
+        }
+
+        @Override
+        public void onNext(T args) {
+            actual.onNext(args);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            actual.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            boolean next;
+            try {
+                next = postCondition.call();
+            } catch (Throwable t) {
+                actual.onError(t);
+                return;
+            }
+            if (next) {
+                Subscriber<T> newSubscription = new Subscriber<T>() {
+
+                    @Override
+                    public void onCompleted() {
+                        SourceObserver.this.onCompleted();
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        SourceObserver.this.onError(e);
+                    }
+
+                    @Override
+                    public void onNext(T t) {
+                        SourceObserver.this.onNext(t);
+                    }
+
+                };
+                cancel.set(newSubscription);
+                source.unsafeSubscribe(newSubscription);
+
+            } else {
+                actual.onCompleted();
+            }
+        }
+
+    }
+}
\ No newline at end of file
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/OperatorConditionalsTest.java
similarity index 98%
rename from rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperationConditionalsTest.java
rename to rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperatorConditionalsTest.java
index 18530022cd..d59b0ed2ac 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/OperatorConditionalsTest.java
@@ -38,7 +38,7 @@
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
 
-public class OperationConditionalsTest {
+public class OperatorConditionalsTest {
     @Mock
     Observer<Object> observer;
     TestScheduler scheduler;
@@ -232,8 +232,9 @@ public void testMapGetThrows() {
         Observable<Integer> source2 = Observable.from(4, 5, 6);
 
         Map<Integer, Observable<Integer>> map = new HashMap<Integer, Observable<Integer>>() {
+			private static final long serialVersionUID = -4342868139960216388L;
 
-            @Override
+			@Override
             public Observable<Integer> get(Object key) {
                 if (key.equals(2)) {
                     throw new RuntimeException("Forced failure!");
@@ -256,8 +257,9 @@ public void testMapContainsKeyThrows() {
         Observable<Integer> source1 = Observable.from(1, 2, 3);
 
         Map<Integer, Observable<Integer>> map = new HashMap<Integer, Observable<Integer>>() {
+			private static final long serialVersionUID = 1975411728567003983L;
 
-            @Override
+			@Override
             public boolean containsKey(Object key) {
                 if (key.equals(2)) {
                     throw new RuntimeException("Forced failure!");

From d85303842df9baca07dbaa28e6fed623a0189996 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 29 Apr 2014 15:22:07 +0200
Subject: [PATCH 316/422] Operator Switch

---
 rxjava-core/src/main/java/rx/Observable.java  |   6 +-
 .../java/rx/operators/OperationSwitch.java    | 175 -------------
 .../java/rx/operators/OperatorSwitch.java     | 234 ++++++++++++++++++
 ...witchTest.java => OperatorSwitchTest.java} |  30 ++-
 4 files changed, 252 insertions(+), 193 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationSwitch.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorSwitch.java
 rename rxjava-core/src/test/java/rx/operators/{OperationSwitchTest.java => OperatorSwitchTest.java} (94%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..58db739250 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -66,7 +66,6 @@
 import rx.operators.OperationSequenceEqual;
 import rx.operators.OperationSkip;
 import rx.operators.OperationSkipUntil;
-import rx.operators.OperationSwitch;
 import rx.operators.OperationTakeLast;
 import rx.operators.OperationTakeTimed;
 import rx.operators.OperationTakeUntil;
@@ -120,6 +119,7 @@
 import rx.operators.OperatorSkipLastTimed;
 import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
+import rx.operators.OperatorSwitch;
 import rx.operators.OperatorTake;
 import rx.operators.OperatorTimeout;
 import rx.operators.OperatorTimeoutWithSelector;
@@ -2494,9 +2494,11 @@ public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T
      * @return an Observable that emits the items emitted by the Observable most recently emitted by the source
      *         Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-switchonnext">RxJava Wiki: switchOnNext()</a>
+     * 
+     * @param <T> the element type
      */
     public final static <T> Observable<T> switchOnNext(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
-        return create(OperationSwitch.switchDo(sequenceOfSequences));
+        return sequenceOfSequences.lift(new OperatorSwitch<T>());
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java b/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
deleted file mode 100644
index 4af058f283..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationSwitch.java
+++ /dev/null
@@ -1,175 +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.Subscriber;
-import rx.Subscription;
-import rx.functions.Func1;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-
-/**
- * Transforms an Observable that emits Observables into a single Observable that
- * emits the items emitted by the most recently published of those Observables.
- * <p>
- * <img width="640" src=
- * "https://github.com/Netflix/RxJava/wiki/images/rx-operators/switchDo.png">
- */
-public final class OperationSwitch {
-
-    /**
-     * This function transforms an {@link Observable} sequence of {@link Observable} sequences into a single {@link Observable} sequence
-     * which produces values from the most recently published {@link Observable} .
-     * 
-     * @param sequences
-     *            The {@link Observable} sequence consisting of {@link Observable} sequences.
-     * @return A {@link Func1} which does this transformation.
-     */
-    public static <T> OnSubscribeFunc<T> switchDo(final Observable<? extends Observable<? extends T>> sequences) {
-        return new OnSubscribeFunc<T>() {
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new Switch<T>(sequences).onSubscribe(observer);
-            }
-        };
-    }
-
-    private static class Switch<T> implements OnSubscribeFunc<T> {
-
-        private final Observable<? extends Observable<? extends T>> sequences;
-
-        public Switch(Observable<? extends Observable<? extends T>> sequences) {
-            this.sequences = sequences;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            SafeObservableSubscription parent;
-            parent = new SafeObservableSubscription();
-
-            SerialSubscription child = new SerialSubscription();
-
-            parent.wrap(sequences.unsafeSubscribe(new SwitchObserver<T>(observer, parent, child)));
-
-            return new CompositeSubscription(parent, child);
-        }
-    }
-
-    private static class SwitchObserver<T> extends Subscriber<Observable<? extends T>> {
-
-        private final Object gate;
-        private final Observer<? super T> observer;
-        private final SafeObservableSubscription parent;
-        private final SerialSubscription child;
-        private long latest;
-        private boolean stopped;
-        private boolean hasLatest;
-
-        public SwitchObserver(Observer<? super T> observer, SafeObservableSubscription parent,
-                SerialSubscription child) {
-            this.observer = observer;
-            this.parent = parent;
-            this.child = child;
-            this.gate = new Object();
-        }
-
-        @Override
-        public void onNext(Observable<? extends T> args) {
-            final long id;
-            synchronized (gate) {
-                id = ++latest;
-                this.hasLatest = true;
-            }
-
-            final SafeObservableSubscription sub = new SafeObservableSubscription();
-            sub.wrap(args.unsafeSubscribe(new Subscriber<T>() {
-                @Override
-                public void onNext(T args) {
-                    synchronized (gate) {
-                        if (latest == id) {
-                            SwitchObserver.this.observer.onNext(args);
-                        }
-                    }
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    sub.unsubscribe();
-                    SafeObservableSubscription s = null;
-                    synchronized (gate) {
-                        if (latest == id) {
-                            SwitchObserver.this.observer.onError(e);
-                            s = SwitchObserver.this.parent;
-                        }
-                    }
-                    if (s != null) {
-                        s.unsubscribe();
-                    }
-                }
-
-                @Override
-                public void onCompleted() {
-                    sub.unsubscribe();
-                    SafeObservableSubscription s = null;
-                    synchronized (gate) {
-                        if (latest == id) {
-                            SwitchObserver.this.hasLatest = false;
-
-                            if (stopped) {
-                                SwitchObserver.this.observer.onCompleted();
-                                s = SwitchObserver.this.parent;
-                            }
-                        }
-                    }
-                    if (s != null) {
-                        s.unsubscribe();
-                    }
-                }
-
-            }));
-
-            this.child.set(sub);
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            synchronized (gate) {
-                this.observer.onError(e);
-            }
-
-            this.parent.unsubscribe();
-        }
-
-        @Override
-        public void onCompleted() {
-            SafeObservableSubscription s = null;
-            synchronized (gate) {
-                this.stopped = true;
-                if (!this.hasLatest) {
-                    this.observer.onCompleted();
-                    s = this.parent;
-                }
-            }
-            if (s != null) {
-                s.unsubscribe();
-            }
-        }
-
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSwitch.java b/rxjava-core/src/main/java/rx/operators/OperatorSwitch.java
new file mode 100644
index 0000000000..00d206da35
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSwitch.java
@@ -0,0 +1,234 @@
+/**
+ * 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.List;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Subscriber;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.SerialSubscription;
+
+/**
+ * Transforms an Observable that emits Observables into a single Observable that
+ * emits the items emitted by the most recently published of those Observables.
+ * <p>
+ * <img width="640" src=
+ * "https://github.com/Netflix/RxJava/wiki/images/rx-operators/switchDo.png">
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorSwitch<T> implements Operator<T, Observable<? extends T>> {
+
+    @Override
+    public Subscriber<? super Observable<? extends T>> call(final Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final SerialSubscription ssub = new SerialSubscription();
+        child.add(ssub);
+        
+        return new Subscriber<Observable<? extends T>>(child) {
+            final Object guard = new Object();
+            final Subscriber<?> self = this;
+            final NotificationLite<?> nl = NotificationLite.instance();
+            /** Guarded by guard. */
+            int index;
+            /** Guarded by guard. */
+            boolean active;
+            /** Guarded by guard. */
+            boolean mainDone;
+            /** Guarded by guard. */
+            List<Object> queue;
+            /** Guarded by guard. */
+            boolean emitting;
+            @Override
+            public void onNext(Observable<? extends T> t) {
+                final int id;
+                synchronized (guard) {
+                    id = ++index;
+                    active = true;
+                }
+                
+                Subscriber<T> sub = new Subscriber<T>() {
+
+                    @Override
+                    public void onNext(T t) {
+                        emit(t, id);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        error(e, id);
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        complete(id);
+                    }
+                    
+                };
+                ssub.set(sub);
+                
+                t.unsafeSubscribe(sub);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                s.onError(e);
+                unsubscribe();
+            }
+
+            @Override
+            public void onCompleted() {
+                List<Object> localQueue;
+                synchronized (guard) {
+                    mainDone = true;
+                    if (active) {
+                        return;
+                    }
+                    if (emitting) {
+                        if (queue == null) {
+                            queue = new ArrayList<Object>();
+                        }
+                        queue.add(nl.completed());
+                        return;
+                    }
+                    localQueue = queue;
+                    queue = null;
+                    emitting = true;
+                }
+                drain(localQueue);
+                s.onCompleted();
+                unsubscribe();
+            }
+            void emit(T value, int id) {
+                List<Object> localQueue;
+                synchronized (guard) {
+                    if (id != index) {
+                        return;
+                    }
+                    if (emitting) {
+                        if (queue == null) {
+                            queue = new ArrayList<Object>();
+                        }
+                        queue.add(value);
+                        return;
+                    }
+                    localQueue = queue;
+                    queue = null;
+                    emitting = true;
+                }
+                boolean once = true;
+                boolean skipFinal = false;
+                try {
+                    do {
+                        drain(localQueue);
+                        if (once) {
+                            once = false;
+                            s.onNext(value);
+                        }
+                        synchronized (guard) {
+                            localQueue = queue;
+                            queue = null;
+                            if (localQueue == null) {
+                                emitting = false;
+                                skipFinal = true;
+                                break;
+                            }
+                        }
+                    } while (!s.isUnsubscribed());
+                } finally {
+                    if (!skipFinal) {
+                        synchronized (guard) {
+                            emitting = false;
+                        }
+                    }
+                }
+            }
+            void drain(List<Object> localQueue) {
+                if (localQueue == null) {
+                    return;
+                }
+                for (Object o : localQueue) {
+                    if (nl.isCompleted(o)) {
+                        s.onCompleted();
+                        break;
+                    } else
+                    if (nl.isError(o)) {
+                        s.onError(nl.getError(o));
+                        break;
+                    } else {
+                        @SuppressWarnings("unchecked")
+                        T t = (T)o;
+                        s.onNext(t);
+                    }
+                }
+            }
+            
+            void error(Throwable e, int id) {
+                List<Object> localQueue;
+                synchronized (guard) {
+                    if (id != index) {
+                        return;
+                    }
+                    if (emitting) {
+                        if (queue == null) {
+                            queue = new ArrayList<Object>();
+                        }
+                        queue.add(nl.error(e));
+                        return;
+                    }
+                    
+                    localQueue = queue;
+                    queue = null;
+                    emitting = true;
+                }
+                
+                drain(localQueue);
+                s.onError(e);
+                unsubscribe();
+            }
+            void complete(int id) {
+                List<Object> localQueue;
+                synchronized (guard) {
+                    if (id != index) {
+                        return;
+                    }
+                    active = false;
+                    if (!mainDone) {
+                        return;
+                    }
+                    if (emitting) {
+                        if (queue == null) {
+                            queue = new ArrayList<Object>();
+                        }
+                        queue.add(nl.completed());
+                        return;
+                    }
+                    
+                    localQueue = queue;
+                    queue = null;
+                    emitting = true;
+                }
+                
+                drain(localQueue);
+                s.onCompleted();
+                unsubscribe();
+            }
+        };
+    }
+    
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSwitchTest.java
similarity index 94%
rename from rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSwitchTest.java
index a0d6fede6b..b90086e821 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSwitchTest.java
@@ -28,16 +28,17 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
-
 import rx.Observable;
 import rx.Observer;
+
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.Subscriptions;
 
-public class OperationSwitchTest {
+public class OperatorSwitchTest {
 
     private TestScheduler scheduler;
     private Scheduler.Worker innerScheduler;
@@ -53,25 +54,22 @@ public void before() {
 
     @Test
     public void testSwitchWhenOuterCompleteBeforeInner() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribeFunc<String>() {
+            public void call(Subscriber<? super Observable<String>> observer) {
+                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 70, "one");
                         publishNext(observer, 100, "two");
                         publishCompleted(observer, 200);
-                        return Subscriptions.empty();
                     }
                 }));
                 publishCompleted(observer, 60);
-
-                return Subscriptions.empty();
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationSwitch.switchDo(source));
+        Observable<String> sampled = Observable.switchOnNext(source);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -111,7 +109,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationSwitch.switchDo(source));
+        Observable<String> sampled = Observable.switchOnNext(source);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -157,7 +155,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationSwitch.switchDo(source));
+        Observable<String> sampled = Observable.switchOnNext(source);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -217,7 +215,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationSwitch.switchDo(source));
+        Observable<String> sampled = Observable.switchOnNext(source);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -282,7 +280,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationSwitch.switchDo(source));
+        Observable<String> sampled = Observable.switchOnNext(source);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -337,7 +335,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationSwitch.switchDo(source));
+        Observable<String> sampled = Observable.switchOnNext(source);
         sampled.subscribe(observer);
 
         InOrder inOrder = inOrder(observer);
@@ -421,7 +419,7 @@ public Subscription onSubscribe(Observer<? super String> observer) {
             }
         });
 
-        Observable<String> sampled = Observable.create(OperationSwitch.switchDo(source));
+        Observable<String> sampled = Observable.switchOnNext(source);
         sampled.subscribe(observer);
 
         scheduler.advanceTimeTo(1000, TimeUnit.MILLISECONDS);

From 1383d3d76369353695e7869cdad5780648171e63 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 29 Apr 2014 15:56:39 +0200
Subject: [PATCH 317/422] Operator TakeTimed

---
 rxjava-core/src/main/java/rx/Observable.java  |   4 +-
 .../java/rx/operators/OperationTakeTimed.java | 289 ------------------
 .../java/rx/operators/OperatorTakeTimed.java  |  84 +++++
 ...edTest.java => OperatorTakeTimedTest.java} |   2 +-
 4 files changed, 87 insertions(+), 292 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTakeTimed.java
 rename rxjava-core/src/test/java/rx/operators/{OperationTakeTimedTest.java => OperatorTakeTimedTest.java} (99%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 746362ca78..868199ebe2 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -68,7 +68,6 @@
 import rx.operators.OperationSkipUntil;
 import rx.operators.OperationSwitch;
 import rx.operators.OperationTakeLast;
-import rx.operators.OperationTakeTimed;
 import rx.operators.OperationTakeUntil;
 import rx.operators.OperationTakeWhile;
 import rx.operators.OperationThrottleFirst;
@@ -121,6 +120,7 @@
 import rx.operators.OperatorSkipWhile;
 import rx.operators.OperatorSubscribeOn;
 import rx.operators.OperatorTake;
+import rx.operators.OperatorTakeTimed;
 import rx.operators.OperatorTimeout;
 import rx.operators.OperatorTimeoutWithSelector;
 import rx.operators.OperatorTimestamp;
@@ -6447,7 +6447,7 @@ public final Observable<T> take(long time, TimeUnit unit) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
      */
     public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperationTakeTimed.TakeTimed<T>(this, time, unit, scheduler));
+        return lift(new OperatorTakeTimed<T>(time, unit, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
deleted file mode 100644
index dd51c9e9e7..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeTimed.java
+++ /dev/null
@@ -1,289 +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.atomic.AtomicInteger;
-
-import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Worker;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Returns an Observable that emits the first <code>num</code> items emitted by the source
- * Observable.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-Observers/take.png">
- * <p>
- * You can choose to pay attention only to the first <code>num</code> items emitted by an
- * Observable by using the take operation. This operation returns an Observable that will invoke a
- * subscribing Observer's <code>onNext</code> function a maximum of <code>num</code> times before
- * invoking <code>onCompleted</code>.
- */
-public final class OperationTakeTimed {
-
-    //TODO this has not been migrated to use bind yet
-
-    /**
-     * Returns a specified number of contiguous values from the start of an observable sequence.
-     * 
-     * @param items
-     * @param num
-     * @return the specified number of contiguous values from the start of the given observable sequence
-     */
-    public static <T> OnSubscribeFunc<T> take(final Observable<? extends T> items, final int num) {
-        // wrap in a Func so that if a chain is built up, then asynchronously subscribed to twice we will have 2 instances of Take<T> rather than 1 handing both, which is not thread-safe.
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new Take<T>(items, num).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.
-     * <p>
-     * It IS thread-safe from within it while receiving onNext events from multiple threads.
-     * <p>
-     * 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.
-     * <p>
-     * Note how the take() factory method above protects us from a single instance being exposed with the Observable wrapper handling the subscribe flow.
-     * 
-     * @param <T>
-     */
-    private static class Take<T> implements OnSubscribeFunc<T> {
-        private final Observable<? extends T> items;
-        private final int num;
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-        private Take(Observable<? extends T> items, int num) {
-            this.items = items;
-            this.num = num;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            if (num < 1) {
-                items.unsafeSubscribe(new Subscriber<T>()
-                {
-                    @Override
-                    public void onCompleted()
-                    {
-                    }
-
-                    @Override
-                    public void onError(Throwable e)
-                    {
-                    }
-
-                    @Override
-                    public void onNext(T args)
-                    {
-                    }
-                }).unsubscribe();
-                observer.onCompleted();
-                return Subscriptions.empty();
-            }
-
-            return subscription.wrap(items.unsafeSubscribe(new ItemObserver(observer)));
-        }
-
-        private class ItemObserver extends Subscriber<T> {
-            private final Observer<? super T> observer;
-
-            private final AtomicInteger counter = new AtomicInteger();
-            private volatile boolean hasEmitedError = false;
-
-            public ItemObserver(Observer<? super T> observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onCompleted() {
-                if (hasEmitedError) {
-                    return;
-                }
-                if (counter.getAndSet(num) < num) {
-                    observer.onCompleted();
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                if (hasEmitedError) {
-                    return;
-                }
-                if (counter.getAndSet(num) < num) {
-                    observer.onError(e);
-                }
-            }
-
-            @Override
-            public void onNext(T args) {
-                if (hasEmitedError) {
-                    return;
-                }
-                final int count = counter.incrementAndGet();
-                if (count <= num) {
-                    try {
-                        observer.onNext(args);
-                    } catch (Throwable ex) {
-                        hasEmitedError = true;
-                        observer.onError(ex);
-                        subscription.unsubscribe();
-                        return;
-                    }
-                    if (count == num) {
-                        observer.onCompleted();
-                    }
-                }
-                if (count >= num) {
-                    // this will work if the sequence is asynchronous, it will have no effect on a synchronous observable
-                    subscription.unsubscribe();
-                }
-            }
-
-        }
-
-    }
-
-    /**
-     * Takes values from the source until a timer fires.
-     * 
-     * @param <T>
-     *            the result value type
-     */
-    public static final class TakeTimed<T> implements OnSubscribeFunc<T> {
-        final Observable<? extends T> source;
-        final long time;
-        final TimeUnit unit;
-        final Scheduler scheduler;
-
-        public TakeTimed(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
-            this.source = source;
-            this.time = time;
-            this.unit = unit;
-            this.scheduler = scheduler;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
-            Worker inner = scheduler.createWorker();
-            CompositeSubscription csub = new CompositeSubscription(inner);
-            final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
-            csub.add(so);
-            source.unsafeSubscribe(so);
-            if (!so.isUnsubscribed()) {
-                inner.schedule(so, time, unit);
-            }
-
-            return csub;
-        }
-
-        /**
-         * Observes the source and relays its values until gate turns into false.
-         * 
-         * @param <T>
-         *            the observed value type
-         */
-        private static final class SourceObserver<T> extends Subscriber<T> implements Action0 {
-            final Observer<? super T> 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<? super T> 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/OperatorTakeTimed.java b/rxjava-core/src/main/java/rx/operators/OperatorTakeTimed.java
new file mode 100644
index 0000000000..33cc48404d
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTakeTimed.java
@@ -0,0 +1,84 @@
+/**
+ * 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.Operator;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observers.SerializedSubscriber;
+
+/**
+ * Takes values from the source until the specific time ellapses.
+ * 
+ * @param <T>
+ *            the result value type
+ */
+public final class OperatorTakeTimed<T> implements Operator<T, T> {
+    final long time;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+
+    public OperatorTakeTimed(long time, TimeUnit unit, Scheduler scheduler) {
+        this.time = time;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super T> child) {
+        Worker worker = scheduler.createWorker();
+        child.add(worker);
+        
+        TakeSubscriber<T> ts = new TakeSubscriber<T>(new SerializedSubscriber<T>(child));
+        worker.schedule(ts, time, unit);
+        return ts;
+    }
+    /** Subscribed to source and scheduled on a worker. */
+    static final class TakeSubscriber<T> extends Subscriber<T> implements Action0 {
+        final Subscriber<? super T> child;
+        public TakeSubscriber(Subscriber<? super T> child) {
+            super(child);
+            this.child = child;
+        }
+
+        @Override
+        public void onNext(T t) {
+            child.onNext(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            child.onError(e);
+            unsubscribe();
+        }
+
+        @Override
+        public void onCompleted() {
+            child.onCompleted();
+            unsubscribe();
+        }
+
+        @Override
+        public void call() {
+            onCompleted();
+        }
+        
+        
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTimedTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTakeTimedTest.java
index 856aef6ea3..49877e1c7e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTimedTest.java
@@ -32,7 +32,7 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class OperationTakeTimedTest {
+public class OperatorTakeTimedTest {
 
     @Test
     public void testTakeTimed() {

From 9d319bcbfc0841ed311880b3c066e51b698e3ef0 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 29 Apr 2014 21:35:05 +0800
Subject: [PATCH 318/422] Update CompletenessTest

---
 .../test/scala/rx/lang/scala/CompletenessTest.scala | 13 +++++++++++++
 1 file changed, 13 insertions(+)

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 d4778d7d5e..ee82c26e26 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
@@ -79,6 +79,7 @@ class CompletenessTest extends JUnitSuite {
       "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`]",
+      "lift(Operator[_ <: R, _ >: T])" -> "lift(Subscriber[R] => Subscriber[_ >: T])",
       "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])",
@@ -89,16 +90,28 @@ class CompletenessTest extends JUnitSuite {
       "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)",
+      "retry()" -> "retry()",
       "scan(Func2[T, T, T])" -> unnecessary,
       "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)",
       "skip(Int)" -> "drop(Int)",
+      "skip(Long, TimeUnit)" -> "drop(Duration)",
+      "skip(Long, TimeUnit, Scheduler)" -> "drop(Duration, Scheduler)",
       "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)",
       "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary,
       "startWith(Iterable[T])" -> "[unnecessary because we can just use `++` instead]",
+      "skipLast(Int)" -> "dropRight(Int)",
+      "skipLast(Long, TimeUnit)" -> "dropRight(Duration)",
+      "skipLast(Long, TimeUnit, Scheduler)" -> "dropRight(Duration, Scheduler)",
       "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)`]",
+      "timeout(Func0[_ <: Observable[U]], Func1[_ >: T, _ <: Observable[V]], Observable[_ <: T])" -> "timeout(() => Observable[U], T => Observable[V], Observable[O])",
+      "timeout(Func1[_ >: T, _ <: Observable[V]], Observable[_ <: T])" -> "timeout(() => Observable[U], T => Observable[V])",
+      "timeout(Long, TimeUnit, Observable[_ <: T])" -> "timeout(Duration, Observable[U])",
+      "timeout(Long, TimeUnit, Observable[_ <: T], Scheduler)" -> "timeout(Duration, Observable[U], Scheduler)",
+      "timer(Long, Long, TimeUnit)" -> "timer(Duration, Duration)",
+      "timer(Long, Long, TimeUnit, Scheduler)" -> "timer(Duration, Duration, Scheduler)",
       "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))`]",

From 445941761e651ffa96dbb063644227cb210e6b7f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 29 Apr 2014 17:12:46 -0700
Subject: [PATCH 319/422] collapse imports

attempt to reduce merge conflicts as it's always the import statements that are conflicting
---
 rxjava-core/src/main/java/rx/Observable.java | 138 ++-----------------
 1 file changed, 10 insertions(+), 128 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index cfa0e98c6e..52d9cd5e09 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -14,135 +14,17 @@
 
 import static rx.functions.Functions.alwaysFalse;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-
-import rx.exceptions.Exceptions;
-import rx.exceptions.OnErrorNotImplementedException;
-import rx.exceptions.OnErrorThrowable;
-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.observables.BlockingObservable;
-import rx.observables.ConnectableObservable;
-import rx.observables.GroupedObservable;
+import java.util.*;
+import java.util.concurrent.*;
+
+import rx.exceptions.*;
+import rx.functions.*;
+import rx.observables.*;
 import rx.observers.SafeSubscriber;
-import rx.operators.OnSubscribeFromIterable;
-import rx.operators.OnSubscribeRange;
-import rx.operators.OperationDelay;
-import rx.operators.OperationTakeLast;
-import rx.operators.OperationTakeUntil;
-import rx.operators.OperationWindow;
-import rx.operators.OperatorAll;
-import rx.operators.OperatorAmb;
-import rx.operators.OperatorAny;
-import rx.operators.OperatorAsObservable;
-import rx.operators.OperatorBufferWithSingleObservable;
-import rx.operators.OperatorBufferWithSize;
-import rx.operators.OperatorBufferWithStartEndObservable;
-import rx.operators.OperatorBufferWithTime;
-import rx.operators.OperatorCache;
-import rx.operators.OperatorCast;
-import rx.operators.OperatorCombineLatest;
-import rx.operators.OperatorConcat;
-import rx.operators.OperatorDebounceWithSelector;
-import rx.operators.OperatorDebounceWithTime;
-import rx.operators.OperatorDefaultIfEmpty;
-import rx.operators.OperatorDefer;
-import rx.operators.OperatorDematerialize;
-import rx.operators.OperatorDistinct;
-import rx.operators.OperatorDistinctUntilChanged;
-import rx.operators.OperatorDoOnEach;
-import rx.operators.OperatorElementAt;
-import rx.operators.OperatorFilter;
-import rx.operators.OperatorFinally;
-import rx.operators.OperatorGroupBy;
-import rx.operators.OperatorGroupByUntil;
-import rx.operators.OperatorGroupJoin;
-import rx.operators.OperatorJoin;
-import rx.operators.OperatorMap;
-import rx.operators.OperatorMaterialize;
-import rx.operators.OperatorMerge;
-import rx.operators.OperatorMergeDelayError;
-import rx.operators.OperatorMergeMapPair;
-import rx.operators.OperatorMergeMapTransform;
-import rx.operators.OperatorMergeMaxConcurrent;
-import rx.operators.OperatorMulticast;
-import rx.operators.OperatorMulticastSelector;
-import rx.operators.OperatorObserveOn;
-import rx.operators.OperatorOnErrorFlatMap;
-import rx.operators.OperatorOnErrorResumeNextViaFunction;
-import rx.operators.OperatorOnErrorResumeNextViaObservable;
-import rx.operators.OperatorOnErrorReturn;
-import rx.operators.OperatorOnExceptionResumeNextViaObservable;
-import rx.operators.OperatorParallel;
-import rx.operators.OperatorParallelMerge;
-import rx.operators.OperatorPivot;
-import rx.operators.OperatorRepeat;
-import rx.operators.OperatorReplay;
-import rx.operators.OperatorRetry;
-import rx.operators.OperatorSampleWithObservable;
-import rx.operators.OperatorSampleWithTime;
-import rx.operators.OperatorScan;
-import rx.operators.OperatorSequenceEqual;
-import rx.operators.OperatorSerialize;
-import rx.operators.OperatorSingle;
-import rx.operators.OperatorSkip;
-import rx.operators.OperatorSkipLast;
-import rx.operators.OperatorSkipLastTimed;
-import rx.operators.OperatorSkipTimed;
-import rx.operators.OperatorSkipUntil;
-import rx.operators.OperatorSkipWhile;
-import rx.operators.OperatorSubscribeOn;
-import rx.operators.OperatorSwitch;
-import rx.operators.OperatorTake;
-import rx.operators.OperatorTakeTimed;
-import rx.operators.OperatorTakeWhile;
-import rx.operators.OperatorThrottleFirst;
-import rx.operators.OperatorTimeInterval;
-import rx.operators.OperatorTimeout;
-import rx.operators.OperatorTimeoutWithSelector;
-import rx.operators.OperatorTimerOnce;
-import rx.operators.OperatorTimerPeriodically;
-import rx.operators.OperatorTimestamp;
-import rx.operators.OperatorToMap;
-import rx.operators.OperatorToMultimap;
-import rx.operators.OperatorToObservableFuture;
-import rx.operators.OperatorToObservableList;
-import rx.operators.OperatorToObservableSortedList;
-import rx.operators.OperatorUnsubscribeOn;
-import rx.operators.OperatorUsing;
-import rx.operators.OperatorZip;
-import rx.operators.OperatorZipIterable;
-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.operators.*;
+import rx.plugins.*;
+import rx.schedulers.*;
+import rx.subjects.*;
 import rx.subscriptions.Subscriptions;
 
 /**

From 49075d6d5d413301c53f1139d64d3cb7ab4460e2 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 30 Apr 2014 12:28:01 +0800
Subject: [PATCH 320/422] OperatorTakeUntil

---
 rxjava-core/src/main/java/rx/Observable.java  |  2 +-
 ...nTakeUntil.java => OperatorTakeUntil.java} | 43 +++++++------------
 ...ilTest.java => OperatorTakeUntilTest.java} |  4 +-
 3 files changed, 19 insertions(+), 30 deletions(-)
 rename rxjava-core/src/main/java/rx/operators/{OperationTakeUntil.java => OperatorTakeUntil.java} (74%)
 rename rxjava-core/src/test/java/rx/operators/{OperationTakeUntilTest.java => OperatorTakeUntilTest.java} (98%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 52d9cd5e09..daad88dd4a 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6555,7 +6555,7 @@ public final Observable<List<T>> takeLastBuffer(long time, TimeUnit unit, Schedu
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takeuntil">RxJava Wiki: takeUntil()</a>
      */
     public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
-        return OperationTakeUntil.takeUntil(this, other);
+        return OperatorTakeUntil.takeUntil(this, other);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java b/rxjava-core/src/main/java/rx/operators/OperatorTakeUntil.java
similarity index 74%
rename from rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
rename to rxjava-core/src/main/java/rx/operators/OperatorTakeUntil.java
index 9ad8d9a6ab..c9d987a48b 100644
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTakeUntil.java
@@ -16,19 +16,18 @@
 package rx.operators;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Func1;
 
+import static rx.Observable.Operator;
+
 /**
  * Returns an Observable that emits the items from the source Observable until another Observable
  * emits an item.
  * <p>
  * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/takeUntil.png">
  */
-public class OperationTakeUntil {
+public final class OperatorTakeUntil {
 
     /**
      * Returns the values from the source observable sequence until the other observable sequence produces a value.
@@ -44,8 +43,8 @@ public class OperationTakeUntil {
      * @return An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.
      */
     public static <T, E> Observable<T> takeUntil(final Observable<? extends T> source, final Observable<? extends E> other) {
-        Observable<Notification<T>> s = Observable.create(new SourceObservable<T>(source));
-        Observable<Notification<T>> o = Observable.create(new OtherObservable<T, E>(other));
+        Observable<Notification<T>> s = source.lift(new SourceObservable<T>());
+        Observable<Notification<T>> o = other.lift(new OtherObservable<T, E>());
 
         Observable<Notification<T>> result = Observable.merge(s, o);
 
@@ -81,19 +80,14 @@ private Notification(boolean halt, T value) {
 
     }
 
-    private static class SourceObservable<T> implements OnSubscribeFunc<Notification<T>> {
-        private final Observable<? extends T> sequence;
-
-        private SourceObservable(Observable<? extends T> sequence) {
-            this.sequence = sequence;
-        }
+    private static class SourceObservable<T> implements Operator<Notification<T>, T> {
 
         @Override
-        public Subscription onSubscribe(final Observer<? super Notification<T>> notificationObserver) {
-            return sequence.unsafeSubscribe(new Subscriber<T>() {
+        public Subscriber<? super T> call(final Subscriber<? super Notification<T>> notificationObserver) {
+            return new Subscriber<T>(notificationObserver) {
                 @Override
                 public void onCompleted() {
-                    notificationObserver.onNext(Notification.<T> halt());
+                    notificationObserver.onNext(Notification.<T>halt());
                 }
 
                 @Override
@@ -105,23 +99,18 @@ public void onError(Throwable e) {
                 public void onNext(T args) {
                     notificationObserver.onNext(Notification.value(args));
                 }
-            });
+            };
         }
     }
 
-    private static class OtherObservable<T, E> implements OnSubscribeFunc<Notification<T>> {
-        private final Observable<? extends E> sequence;
-
-        private OtherObservable(Observable<? extends E> sequence) {
-            this.sequence = sequence;
-        }
+    private static class OtherObservable<T, E> implements Operator<Notification<T>, E> {
 
         @Override
-        public Subscription onSubscribe(final Observer<? super Notification<T>> notificationObserver) {
-            return sequence.unsafeSubscribe(new Subscriber<E>() {
+        public Subscriber<? super E> call(final Subscriber<? super Notification<T>> notificationObserver) {
+            return new Subscriber<E>(notificationObserver) {
                 @Override
                 public void onCompleted() {
-                    notificationObserver.onNext(Notification.<T> halt());
+                    notificationObserver.onNext(Notification.<T>halt());
                 }
 
                 @Override
@@ -131,9 +120,9 @@ public void onError(Throwable e) {
 
                 @Override
                 public void onNext(E args) {
-                    notificationObserver.onNext(Notification.<T> halt());
+                    notificationObserver.onNext(Notification.<T>halt());
                 }
-            });
+            };
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeUntilTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTakeUntilTest.java
index 8c41a57c29..6f75578185 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeUntilTest.java
@@ -18,7 +18,7 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationTakeUntil.takeUntil;
+import static rx.operators.OperatorTakeUntil.takeUntil;
 
 import org.junit.Test;
 
@@ -26,7 +26,7 @@
 import rx.Observer;
 import rx.Subscription;
 
-public class OperationTakeUntilTest {
+public class OperatorTakeUntilTest {
 
     @Test
     @SuppressWarnings("unchecked")

From cd717d69fc46515e3d35e142c9f6bd52f5232bc7 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 30 Apr 2014 12:12:34 +0800
Subject: [PATCH 321/422] OperatorTakeLast

---
 rxjava-core/src/main/java/rx/Observable.java  |   9 +-
 .../java/rx/operators/OperationTakeLast.java  | 245 ------------------
 .../java/rx/operators/OperatorTakeLast.java   |  85 ++++++
 .../rx/operators/OperatorTakeLastTimed.java   | 107 ++++++++
 .../rx/operators/OperatorTakeLastTest.java    | 103 ++++++++
 ...st.java => OperatorTakeLastTimedTest.java} |  99 +------
 6 files changed, 305 insertions(+), 343 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTakeLast.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorTakeLastTimed.java
 create mode 100644 rxjava-core/src/test/java/rx/operators/OperatorTakeLastTest.java
 rename rxjava-core/src/test/java/rx/operators/{OperationTakeLastTest.java => OperatorTakeLastTimedTest.java} (65%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 52d9cd5e09..05d268131f 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6356,7 +6356,7 @@ public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-takelast">RxJava Wiki: takeLast()</a>
      */
     public final Observable<T> takeLast(final int count) {
-        return create(OperationTakeLast.takeLast(this, count));
+        return lift(new OperatorTakeLast<T>(count));
     }
 
     /**
@@ -6400,10 +6400,7 @@ public final Observable<T> takeLast(int count, long time, TimeUnit unit) {
      *             if {@code count} is less than zero
      */
     public final Observable<T> 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 lift(new OperatorTakeLastTimed<T>(count, time, unit, scheduler));
     }
 
     /**
@@ -6441,7 +6438,7 @@ public final Observable<T> takeLast(long time, TimeUnit unit) {
      *         provided by {@code scheduler}
      */
     public final Observable<T> takeLast(long time, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationTakeLast.takeLast(this, time, unit, scheduler));
+        return lift(new OperatorTakeLastTimed<T>(time, unit, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
deleted file mode 100644
index dbbb497eb7..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationTakeLast.java
+++ /dev/null
@@ -1,245 +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.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.Subscriber;
-import rx.Subscription;
-import rx.schedulers.Timestamped;
-
-/**
- * Returns an Observable that emits the last <code>count</code> items emitted by the source
- * Observable.
- * <p>
- * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/last.png">
- */
-public final class OperationTakeLast {
-
-    public static <T> OnSubscribeFunc<T> takeLast(final Observable<? extends T> items, final int count) {
-        return new OnSubscribeFunc<T>() {
-
-            @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return new TakeLast<T>(items, count).onSubscribe(observer);
-            }
-
-        };
-    }
-
-    private static class TakeLast<T> implements OnSubscribeFunc<T> {
-        private final int count;
-        private final Observable<? extends T> items;
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-
-        TakeLast(final Observable<? extends T> items, final int count) {
-            this.count = count;
-            this.items = items;
-        }
-
-        public Subscription onSubscribe(Observer<? super T> observer) {
-            if (count < 0) {
-                throw new IndexOutOfBoundsException(
-                        "count could not be negative");
-            }
-            return subscription.wrap(items.unsafeSubscribe(new ItemObserver(observer)));
-        }
-
-        private class ItemObserver extends Subscriber<T> {
-
-            /**
-             * Store the last count elements until now.
-             */
-            private Deque<T> deque = new LinkedList<T>();
-            private final Observer<? super T> observer;
-            private final ReentrantLock lock = new ReentrantLock();
-
-            public ItemObserver(Observer<? super T> observer) {
-                this.observer = observer;
-            }
-
-            @Override
-            public void onCompleted() {
-                try {
-                    for (T value : deque) {
-                        observer.onNext(value);
-                    }
-                    observer.onCompleted();
-                } catch (Throwable e) {
-                    observer.onError(e);
-                }
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onNext(T value) {
-                if (count == 0) {
-                    // If count == 0, we do not need to put value into deque and
-                    // remove it at once. We can ignore the value directly.
-                    return;
-                }
-                lock.lock();
-                try {
-                    deque.offerLast(value);
-                    if (deque.size() > count) {
-                        // Now deque has count + 1 elements, so the first
-                        // element in the deque definitely does not belong
-                        // to the last count elements of the source
-                        // sequence. We can drop it now.
-                        deque.removeFirst();
-                    }
-                } catch (Throwable e) {
-                    observer.onError(e);
-                    subscription.unsubscribe();
-                } finally {
-                    lock.unlock();
-                }
-            }
-
-        }
-
-    }
-
-    /**
-     * Returns the items emitted by source whose arrived in the time window
-     * before the source completed.
-     */
-    public static <T> OnSubscribeFunc<T> takeLast(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
-        return new TakeLastTimed<T>(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 <T> OnSubscribeFunc<T> takeLast(Observable<? extends T> source, int count, long time, TimeUnit unit, Scheduler scheduler) {
-        return new TakeLastTimed<T>(source, count, time, unit, scheduler);
-    }
-
-    /** Take only the values which appeared some time before the completion. */
-    static final class TakeLastTimed<T> implements OnSubscribeFunc<T> {
-        final Observable<? extends T> source;
-        final long ageMillis;
-        final Scheduler scheduler;
-        final int count;
-
-        public TakeLastTimed(Observable<? extends T> 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<? super T> t1) {
-            SafeObservableSubscription sas = new SafeObservableSubscription();
-            sas.wrap(source.unsafeSubscribe(new TakeLastTimedObserver<T>(t1, sas, count, ageMillis, scheduler)));
-            return sas;
-        }
-    }
-
-    /** Observes source values and keeps the most recent items. */
-    static final class TakeLastTimedObserver<T> extends Subscriber<T> {
-        final Observer<? super T> observer;
-        final Subscription cancel;
-        final long ageMillis;
-        final Scheduler scheduler;
-        /** -1 indicates unlimited buffer. */
-        final int count;
-
-        final Deque<Timestamped<T>> buffer = new LinkedList<Timestamped<T>>();
-
-        public TakeLastTimedObserver(Observer<? super T> 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<T> 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>(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<T> 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/main/java/rx/operators/OperatorTakeLast.java b/rxjava-core/src/main/java/rx/operators/OperatorTakeLast.java
new file mode 100644
index 0000000000..c3d6f9c3b3
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTakeLast.java
@@ -0,0 +1,85 @@
+/**
+ * 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 java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * Returns an Observable that emits the last <code>count</code> items emitted by the source
+ * Observable.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/last.png">
+ */
+public final class OperatorTakeLast<T> implements Operator<T, T> {
+
+    private final int count;
+
+    public OperatorTakeLast(int count) {
+        if (count < 0) {
+            throw new IndexOutOfBoundsException("count could not be negative");
+        }
+        this.count = count;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            private NotificationLite<T> notification = NotificationLite.instance();
+            /**
+             * Store the last count elements until now.
+             */
+            private Deque<Object> deque = new ArrayDeque<Object>();
+
+            @Override
+            public void onCompleted() {
+                try {
+                    for (Object value : deque) {
+                        subscriber.onNext(notification.getValue(value));
+                    }
+                } catch (Throwable e) {
+                    onError(e);
+                    return;
+                }
+                deque.clear();
+                subscriber.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                deque.clear();
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onNext(T value) {
+                if (count == 0) {
+                    // If count == 0, we do not need to put value into deque and
+                    // remove it at once. We can ignore the value directly.
+                    return;
+                }
+                if (deque.size() == count) {
+                    deque.removeFirst();
+                }
+                deque.offerLast(notification.next(value));
+            }
+        };
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTakeLastTimed.java b/rxjava-core/src/main/java/rx/operators/OperatorTakeLastTimed.java
new file mode 100644
index 0000000000..80e83bae57
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTakeLastTimed.java
@@ -0,0 +1,107 @@
+/**
+ * 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.Subscriber;
+import rx.schedulers.Timestamped;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Returns an Observable that emits the last <code>count</code> items emitted by the source
+ * Observable.
+ * <p>
+ * <img width="640" src="https://github.com/Netflix/RxJava/wiki/images/rx-operators/last.png">
+ */
+public final class OperatorTakeLastTimed<T> implements Operator<T, T> {
+
+    private final long ageMillis;
+    private final Scheduler scheduler;
+    private final int count;
+
+    public OperatorTakeLastTimed(long time, TimeUnit unit, Scheduler scheduler) {
+        this.ageMillis = unit.toMillis(time);
+        this.scheduler = scheduler;
+        this.count = -1;
+    }
+
+    public OperatorTakeLastTimed(int count, long time, TimeUnit unit, Scheduler scheduler) {
+        if (count < 0) {
+            throw new IndexOutOfBoundsException("count could not be negative");
+        }
+        this.ageMillis = unit.toMillis(time);
+        this.scheduler = scheduler;
+        this.count = count;
+    }
+
+    @Override
+    public Subscriber<? super T> call(final Subscriber<? super T> subscriber) {
+        return new Subscriber<T>(subscriber) {
+
+            private final Deque<Timestamped<T>> buffer = new ArrayDeque<Timestamped<T>>();
+
+            protected void runEvictionPolicy(long now) {
+                // trim size
+                while (count >= 0 && buffer.size() > count) {
+                    buffer.pollFirst();
+                }
+                // remove old entries
+                while (!buffer.isEmpty()) {
+                    Timestamped<T> 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>(t, args));
+                runEvictionPolicy(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                buffer.clear();
+                subscriber.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                runEvictionPolicy(scheduler.now());
+                try {
+                    for (Timestamped<T> v : buffer) {
+                        subscriber.onNext(v.getValue());
+
+                    }
+                } catch (Throwable e) {
+                    onError(e);
+                    return;
+                }
+                buffer.clear();
+                subscriber.onCompleted();
+            }
+        };
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTest.java
new file mode 100644
index 0000000000..6f25b851a0
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTest.java
@@ -0,0 +1,103 @@
+/**
+ * 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 org.junit.Test;
+import org.mockito.InOrder;
+import rx.Observable;
+import rx.Observer;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+
+public class OperatorTakeLastTest {
+
+    @Test
+    public void testTakeLastEmpty() {
+        Observable<String> w = Observable.empty();
+        Observable<String> take = w.takeLast(2);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        take.subscribe(observer);
+        verify(observer, never()).onNext(any(String.class));
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testTakeLast1() {
+        Observable<String> w = Observable.from("one", "two", "three");
+        Observable<String> take = w.takeLast(2);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        InOrder inOrder = inOrder(observer);
+        take.subscribe(observer);
+        inOrder.verify(observer, times(1)).onNext("two");
+        inOrder.verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onNext("one");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testTakeLast2() {
+        Observable<String> w = Observable.from("one");
+        Observable<String> take = w.takeLast(10);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        take.subscribe(observer);
+        verify(observer, times(1)).onNext("one");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testTakeLastWithZeroCount() {
+        Observable<String> w = Observable.from("one");
+        Observable<String> take = w.takeLast(0);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        take.subscribe(observer);
+        verify(observer, never()).onNext("one");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test
+    public void testTakeLastWithNull() {
+        Observable<String> w = Observable.from("one", null, "three");
+        Observable<String> take = w.takeLast(2);
+
+        @SuppressWarnings("unchecked")
+        Observer<String> observer = mock(Observer.class);
+        take.subscribe(observer);
+        verify(observer, never()).onNext("one");
+        verify(observer, times(1)).onNext(null);
+        verify(observer, times(1)).onNext("three");
+        verify(observer, never()).onError(any(Throwable.class));
+        verify(observer, times(1)).onCompleted();
+    }
+
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testTakeLastWithNegativeCount() {
+        Observable.from("one").takeLast(-1);
+    }
+
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTimedTest.java
similarity index 65%
rename from rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorTakeLastTimedTest.java
index 241e319ee3..b670c7e697 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationTakeLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTimedTest.java
@@ -15,108 +15,23 @@
  */
 package rx.operators;
 
-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 rx.operators.OperationTakeLast.takeLast;
-
-import java.util.concurrent.TimeUnit;
-
 import org.junit.Test;
 import org.mockito.InOrder;
-
 import rx.Observable;
 import rx.Observer;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class OperationTakeLastTest {
-
-    @Test
-    public void testTakeLastEmpty() {
-        Observable<String> w = Observable.empty();
-        Observable<String> take = Observable.create(takeLast(w, 2));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        take.subscribe(observer);
-        verify(observer, never()).onNext(any(String.class));
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testTakeLast1() {
-        Observable<String> w = Observable.from("one", "two", "three");
-        Observable<String> take = Observable.create(takeLast(w, 2));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        InOrder inOrder = inOrder(observer);
-        take.subscribe(observer);
-        inOrder.verify(observer, times(1)).onNext("two");
-        inOrder.verify(observer, times(1)).onNext("three");
-        verify(observer, never()).onNext("one");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
-
-    @Test
-    public void testTakeLast2() {
-        Observable<String> w = Observable.from("one");
-        Observable<String> take = Observable.create(takeLast(w, 10));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        take.subscribe(observer);
-        verify(observer, times(1)).onNext("one");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
+import java.util.concurrent.TimeUnit;
 
-    @Test
-    public void testTakeLastWithZeroCount() {
-        Observable<String> w = Observable.from("one");
-        Observable<String> take = Observable.create(takeLast(w, 0));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        take.subscribe(observer);
-        verify(observer, never()).onNext("one");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
 
-    @Test
-    public void testTakeLastWithNull() {
-        Observable<String> w = Observable.from("one", null, "three");
-        Observable<String> take = Observable.create(takeLast(w, 2));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        take.subscribe(observer);
-        verify(observer, never()).onNext("one");
-        verify(observer, times(1)).onNext(null);
-        verify(observer, times(1)).onNext("three");
-        verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, times(1)).onCompleted();
-    }
+public class OperatorTakeLastTimedTest {
 
-    @Test
-    public void testTakeLastWithNegativeCount() {
-        Observable<String> w = Observable.from("one");
-        Observable<String> take = Observable.create(takeLast(w, -1));
-
-        @SuppressWarnings("unchecked")
-        Observer<String> observer = mock(Observer.class);
-        take.subscribe(observer);
-        verify(observer, never()).onNext("one");
-        verify(observer, times(1)).onError(
-                any(IndexOutOfBoundsException.class));
-        verify(observer, never()).onCompleted();
+    @Test(expected = IndexOutOfBoundsException.class)
+    public void testTakeLastTimedWithNegativeCount() {
+        Observable.from("one").takeLast(-1, 1, TimeUnit.SECONDS);
     }
 
     @Test

From 947e5f8662bc7b920f1e33acb46a1a88333a0763 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 30 Apr 2014 13:08:09 +0200
Subject: [PATCH 322/422] Fixes to the operators.

---
 .../main/java/rx/observers/Subscribers.java   |  22 +--
 .../java/rx/operators/OperatorMulticast.java  |  20 ++-
 .../java/rx/operators/OperatorRefCount.java   | 161 +++++++++++++++++-
 .../rx/operators/OperatorSampleWithTime.java  |   1 +
 .../src/test/java/rx/RefCountTests.java       |  51 +++++-
 5 files changed, 220 insertions(+), 35 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/Subscribers.java b/rxjava-core/src/main/java/rx/observers/Subscribers.java
index bc9496e3e3..4fb8f9dd48 100644
--- a/rxjava-core/src/main/java/rx/observers/Subscribers.java
+++ b/rxjava-core/src/main/java/rx/observers/Subscribers.java
@@ -7,29 +7,9 @@
 import rx.functions.Action1;
 
 public class Subscribers {
-
-    private static final Subscriber<Object> EMPTY = new Subscriber<Object>() {
-
-        @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 <T> Subscriber<T> empty() {
-        return (Subscriber<T>) EMPTY;
+        return from(Observers.empty());
     }
 
     public static <T> Subscriber<T> from(final Observer<? super T> o) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
index 4a5016b717..01d647316c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
@@ -15,6 +15,7 @@
  */
 package rx.operators;
 
+import java.util.BitSet;
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
@@ -49,9 +50,10 @@ public void call(Subscriber<? super R> subscriber) {
 
     @Override
     public Subscription connect() {
+        Subscriber<T> s = null;
         synchronized (guard) {
             if (subscription == null) {
-                subscription = source.unsafeSubscribe(new Subscriber<T>() {
+                s = new Subscriber<T>() {
                     @Override
                     public void onCompleted() {
                         subject.onCompleted();
@@ -66,18 +68,24 @@ public void onError(Throwable e) {
                     public void onNext(T args) {
                         subject.onNext(args);
                     }
-                });
+                };
+                subscription = s;
             }
         }
+        if (s != null) {
+            source.unsafeSubscribe(s);
+        }
 
         return Subscriptions.create(new Action0() {
             @Override
             public void call() {
+                Subscription s;
                 synchronized (guard) {
-                    if (subscription != null) {
-                        subscription.unsubscribe();
-                        subscription = null;
-                    }
+                    s = subscription;
+                    subscription = null;
+                }
+                if (s != null) {
+                    s.unsubscribe();
                 }
             }
         });
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorRefCount.java b/rxjava-core/src/main/java/rx/operators/OperatorRefCount.java
index bfcc157951..3831dd63b0 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorRefCount.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorRefCount.java
@@ -15,6 +15,10 @@
  */
 package rx.operators;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
 import rx.Observable.OnSubscribe;
 import rx.Subscriber;
 import rx.Subscription;
@@ -31,32 +35,175 @@ public final class OperatorRefCount<T> implements OnSubscribe<T> {
     final ConnectableObservable<? extends T> source;
     final Object guard;
     /** Guarded by guard. */
-    int count;
+    int index;
     /** Guarded by guard. */
+    boolean emitting;
+    /** Guarded by guard. If true, indicates a connection request, false indicates a disconnect request. */
+    List<Token> queue;
+    /** Manipulated while in the serialized section. */
+    int count;
+    /** Manipulated while in the serialized section. */
     Subscription connection;
+    /** Manipulated while in the serialized section. */
+    final Map<Token, Object> connectionStatus;
+    /** Occupied indicator. */
+    private static final Object OCCUPIED = new Object();
     public OperatorRefCount(ConnectableObservable<? extends T> source) {
         this.source = source;
         this.guard = new Object();
+        this.connectionStatus = new WeakHashMap<Token, Object>();
     }
 
     @Override
     public void call(Subscriber<? super T> t1) {
+        int id;
+        synchronized (guard) {
+            id = ++index;
+        }
+        final Token t = new Token(id);
         t1.add(Subscriptions.create(new Action0() {
             @Override
             public void call() {
-                synchronized (guard) {
-                    if (--count == 0) {
-                        connection.unsubscribe();
-                        connection = null;
-                    }
-                }
+                disconnect(t);
             }
         }));
         source.unsafeSubscribe(t1);
+        connect(t);
+    }
+    private void connect(Token id) {
+        List<Token> localQueue;
+        synchronized (guard) {
+            if (emitting) {
+                if (queue == null) {
+                    queue = new ArrayList<Token>();
+                }
+                queue.add(id);
+                return;
+            }
+            
+            localQueue = queue;
+            queue = null;
+            emitting = true;
+        }
+        boolean once = true;
+        do {
+            drain(localQueue);
+            if (once) {
+                once = false;
+                doConnect(id);
+            }
+            synchronized (guard) {
+                localQueue = queue;
+                queue = null;
+                if (localQueue == null) {
+                    emitting = false;
+                    return;
+                }
+            }
+        } while (true);
+    }
+    private void disconnect(Token id) {
+        List<Token> localQueue;
         synchronized (guard) {
+            if (emitting) {
+                if (queue == null) {
+                    queue = new ArrayList<Token>();
+                }
+                queue.add(id.toDisconnect()); // negative value indicates disconnect
+                return;
+            }
+            
+            localQueue = queue;
+            queue = null;
+            emitting = true;
+        }
+        boolean once = true;
+        do {
+            drain(localQueue);
+            if (once) {
+                once = false;
+                doDisconnect(id);
+            }
+            synchronized (guard) {
+                localQueue = queue;
+                queue = null;
+                if (localQueue == null) {
+                    emitting = false;
+                    return;
+                }
+            }
+        } while (true);
+    }
+    private void drain(List<Token> localQueue) {
+        if (localQueue == null) {
+            return;
+        }
+        int n = localQueue.size();
+        for (int i = 0; i < n; i++) {
+            Token id = localQueue.get(i);
+            if (id.isDisconnect()) {
+                doDisconnect(id);
+            } else {
+                doConnect(id);
+            }
+        }
+    }
+    private void doConnect(Token id) {
+        // this method is called only once per id
+        // if add succeeds, id was not yet disconnected
+        if (connectionStatus.put(id, OCCUPIED) == null) {
             if (count++ == 0) {
                 connection = source.connect();
             }
+        } else {
+            // connection exists due to disconnect, just remove
+            connectionStatus.remove(id);
+        }
+    }
+    private void doDisconnect(Token id) {
+        // this method is called only once per id
+        // if remove succeeds, id was connected
+        if (connectionStatus.remove(id) != null) {
+            if (--count == 0) {
+                connection.unsubscribe();
+                connection = null;
+            }
+        } else {
+            // mark id as if connected
+            connectionStatus.put(id, OCCUPIED);
+        }
+    }
+    /** Token that represens a connection request or a disconnection request. */
+    private static final class Token {
+        final int id;
+        public Token(int id) {
+            this.id = id;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (obj.getClass() != getClass()) {
+                return false;
+            }
+            int other = ((Token)obj).id;
+            return id == other || -id == other;
+        }
+
+        @Override
+        public int hashCode() {
+            return id < 0 ? -id : id;
+        }
+        public boolean isDisconnect() {
+            return id < 0;
+        }
+        public Token toDisconnect() {
+            if (id < 0) {
+                return this;
+            }
+            return new Token(-id);
         }
     }
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java b/rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java
index 2b92b9792e..31642ea439 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSampleWithTime.java
@@ -80,6 +80,7 @@ public void onError(Throwable e) {
         @Override
         public void onCompleted() {
             subscriber.onCompleted();
+            unsubscribe();
         }
 
         @Override
diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java
index 95a7ec2030..43726456dd 100644
--- a/rxjava-core/src/test/java/rx/RefCountTests.java
+++ b/rxjava-core/src/test/java/rx/RefCountTests.java
@@ -16,7 +16,7 @@
 package rx;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.*;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -25,11 +25,14 @@
 
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.InOrder;
 import org.mockito.MockitoAnnotations;
 
 import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.observers.Subscribers;
 import rx.schedulers.TestScheduler;
+import rx.subjects.ReplaySubject;
 import rx.subscriptions.Subscriptions;
 
 public class RefCountTests {
@@ -152,4 +155,50 @@ public void call(Long t1) {
         assertEquals(1L, list3.get(1).longValue());
 
     }
+    
+    @Test
+    public void testAlreadyUnsubscribedClient() {
+        Subscriber<Integer> done = Subscribers.empty();
+        done.unsubscribe();
+        
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o = mock(Observer.class);
+        
+        Observable<Integer> result = Observable.just(1).publish().refCount();
+        
+        result.subscribe(done);
+        
+        result.subscribe(o);
+        
+        verify(o).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    @Test
+    public void testAlreadyUnsubscribedInterleavesWithClient() {
+        ReplaySubject<Integer> source = ReplaySubject.create();
+
+        Subscriber<Integer> done = Subscribers.empty();
+        done.unsubscribe();
+        
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        Observable<Integer> result = source.publish().refCount();
+        
+        result.subscribe(o);
+        
+        source.onNext(1);
+        
+        result.subscribe(done);
+        
+        source.onNext(2);
+        source.onCompleted();
+        
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onNext(2);
+        inOrder.verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
 }

From 21578d5d06523542516b027e6927faa569a33ffd Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 30 Apr 2014 15:16:32 +0200
Subject: [PATCH 323/422] Operator Window and other changes

---
 rxjava-core/src/main/java/rx/Observable.java  |  22 +-
 .../rx/operators/BufferUntilSubscriber.java   | 193 +++--
 .../java/rx/operators/ChunkedOperation.java   | 675 ------------------
 .../java/rx/operators/OperationWindow.java    | 527 --------------
 .../rx/operators/OperatorBufferWithTime.java  |   2 +
 .../OperatorWindowWithObservable.java         | 303 ++++++++
 .../rx/operators/OperatorWindowWithSize.java  | 165 +++++
 .../OperatorWindowWithStartEndObservable.java | 220 ++++++
 .../rx/operators/OperatorWindowWithTime.java  | 470 ++++++++++++
 ...indowTest.java => OperatorWindowTest.java} |  64 +-
 10 files changed, 1336 insertions(+), 1305 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationWindow.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorWindowWithObservable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorWindowWithSize.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorWindowWithStartEndObservable.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorWindowWithTime.java
 rename rxjava-core/src/test/java/rx/operators/{OperationWindowTest.java => OperatorWindowTest.java} (88%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 52d9cd5e09..fef1c6dc3e 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7238,7 +7238,7 @@ public final Observable<T> unsubscribeOn(Scheduler scheduler) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final <TClosing> Observable<Observable<T>> window(Func0<? extends Observable<? extends TClosing>> closingSelector) {
-        return create(OperationWindow.window(this, closingSelector));
+        return lift(new OperatorWindowWithObservable<T, TClosing>(closingSelector));
     }
 
     /**
@@ -7255,7 +7255,7 @@ public final <TClosing> Observable<Observable<T>> window(Func0<? extends Observa
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(int count) {
-        return create(OperationWindow.window(this, count));
+        return lift(new OperatorWindowWithSize<T>(count, count));
     }
 
     /**
@@ -7275,7 +7275,7 @@ public final Observable<Observable<T>> window(int count) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(int count, int skip) {
-        return create(OperationWindow.window(this, count, skip));
+        return lift(new OperatorWindowWithSize<T>(count, skip));
     }
 
     /**
@@ -7297,7 +7297,7 @@ public final Observable<Observable<T>> window(int count, int skip) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(long timespan, long timeshift, TimeUnit unit) {
-        return create(OperationWindow.window(this, timespan, timeshift, unit));
+        return lift(new OperatorWindowWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, Schedulers.computation()));
     }
 
     /**
@@ -7321,7 +7321,7 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, timeshift, unit, scheduler));
+        return lift(new OperatorWindowWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, scheduler));
     }
 
     /**
@@ -7342,7 +7342,7 @@ public final Observable<Observable<T>> window(long timespan, long timeshift, Tim
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(long timespan, TimeUnit unit) {
-        return create(OperationWindow.window(this, timespan, unit));
+        return lift(new OperatorWindowWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, Schedulers.computation()));
     }
 
     /**
@@ -7367,7 +7367,7 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int count) {
-        return create(OperationWindow.window(this, timespan, unit, count));
+        return lift(new OperatorWindowWithTime<T>(timespan, timespan, unit, count, Schedulers.computation()));
     }
 
     /**
@@ -7394,7 +7394,7 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, unit, count, scheduler));
+        return lift(new OperatorWindowWithTime<T>(timespan, timespan, unit, count, scheduler));
     }
 
     /**
@@ -7417,7 +7417,7 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final Observable<Observable<T>> window(long timespan, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, unit, scheduler));
+        return lift(new OperatorWindowWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, scheduler));
     }
 
     /**
@@ -7437,7 +7437,7 @@ public final Observable<Observable<T>> window(long timespan, TimeUnit unit, Sche
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
      */
     public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<? extends TOpening> windowOpenings, Func1<? super TOpening, ? extends Observable<? extends TClosing>> closingSelector) {
-        return create(OperationWindow.window(this, windowOpenings, closingSelector));
+        return lift(new OperatorWindowWithStartEndObservable<T, TOpening, TClosing>(windowOpenings, closingSelector));
     }
 
     /**
@@ -7455,7 +7455,7 @@ public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<?
      *         where the boundary of each window is determined by the items emitted from the {@code boundary} Observable
      */
     public final <U> Observable<Observable<T>> window(Observable<U> boundary) {
-        return create(OperationWindow.window(this, boundary));
+        return lift(new OperatorWindowWithObservable<T, U>(boundary));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index f5679959d2..7687d8bb04 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -15,12 +15,18 @@
  */
 package rx.operators;
 
+import java.util.LinkedHashSet;
+import java.util.Set;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observers.Subscribers;
+import rx.subscriptions.Subscriptions;
 
 /**
  * A solution to the "time gap" problem that occurs with `groupBy` and `pivot` => https://github.com/Netflix/RxJava/issues/844
@@ -43,44 +49,151 @@
 public class BufferUntilSubscriber<T> extends Observable<T> implements Observer<T> {
 
     public static <T> BufferUntilSubscriber<T> create() {
-        return new BufferUntilSubscriber<T>(new AtomicReference<Observer<? super T>>(new BufferedObserver<T>()));
+        State<T> state = new State<T>();
+        return new BufferUntilSubscriber<T>(state);
     }
 
-    private final AtomicReference<Observer<? super T>> observerRef;
+    /** The common state. */
+    static final class State<T> {
+        /** Lite notifications of type T. */
+        final NotificationLite<T> nl = NotificationLite.instance();
+        /** The first observer or the one which buffers until the first arrives. */
+        final AtomicReference<Observer<? super T>> observerRef = new AtomicReference<Observer<? super T>>(new BufferedObserver<T>());
+        /** How many subscribers. */
+        final AtomicBoolean first = new AtomicBoolean();
+        /** The rest of the subscribers without buffering. Guarded by this. */
+        final Set<Subscriber<? super T>> subscribers = new LinkedHashSet<Subscriber<? super T>>();
+        /** Guarded by this. */
+        boolean done;
+        /** Guarded by this. */
+        Throwable exception;
+    }
+    
+    static final class OnSubscribeAction<T> implements OnSubscribe<T> {
+        final State<T> state;
 
-    private BufferUntilSubscriber(final AtomicReference<Observer<? super T>> observerRef) {
-        super(new OnSubscribe<T>() {
+        public OnSubscribeAction(State<T> state) {
+            this.state = state;
+        }
 
-            @Override
-            public void call(Subscriber<? super T> s) {
+        @Override
+        public void call(final Subscriber<? super T> s) {
+            if (state.first.compareAndSet(false, true)) {
                 // drain queued notifications before subscription
                 // we do this here before PassThruObserver so the consuming thread can do this before putting itself in the line of the producer
-                BufferedObserver<T> buffered = (BufferedObserver<T>) observerRef.get();
-                Object o = null;
+                BufferedObserver<? super T> buffered = (BufferedObserver<? super T>)state.observerRef.get();
+                Object o;
                 while ((o = buffered.buffer.poll()) != null) {
-                    emit(s, o);
+                    state.nl.accept(s, o);
                 }
                 // register real observer for pass-thru ... and drain any further events received on first notification
-                observerRef.set(new PassThruObserver<T>(s, buffered.buffer, observerRef));
-            }
+                state.observerRef.set(new PassThruObserver<T>(s, buffered.buffer, state.observerRef));
+                s.add(Subscriptions.create(new Action0() {
+                    @Override
+                    public void call() {
+                        state.observerRef.set(Subscribers.empty());
+                    }
+                }));
+            } else {
+                Throwable e = null;
+                boolean done;
+                synchronized (state) {
+                    done = state.done;
+                    if (!done) {
+                        state.subscribers.add(s);
+                    } else {
+                        e = state.exception;
+                    }
+                }
+                if (done) {
+                    if (e != null) {
+                        s.onError(e);
+                    } else {
+                        s.onCompleted();
+                    }
+                    return;
+                }
+                s.add(Subscriptions.create(new Action0() { 
 
-        });
-        this.observerRef = observerRef;
+                    @Override
+                    public void call() {
+                        synchronized (state) {
+                            state.subscribers.remove(s);
+                        }
+                    }
+                }));
+            }
+        }
+        
+    }
+    final State<T> state;
+    
+    private BufferUntilSubscriber(State<T> state) {
+        super(new OnSubscribeAction<T>(state));
+        this.state = state;
     }
 
     @Override
     public void onCompleted() {
-        observerRef.get().onCompleted();
+        state.observerRef.get().onCompleted();
+        // notify the rest
+        Subscriber<?>[] list;
+        synchronized (state) {
+            if (!state.done) {
+                return;
+            }
+            state.done = true;
+            if (state.subscribers.isEmpty()) {
+                return;
+            }
+            list = state.subscribers.toArray(new Subscriber<?>[state.subscribers.size()]);
+            state.subscribers.clear();
+        }
+        for (Subscriber<?> s : list) {
+            s.onCompleted();
+        }
     }
 
     @Override
     public void onError(Throwable e) {
-        observerRef.get().onError(e);
+        state.observerRef.get().onError(e);
+        // notify the rest
+        Subscriber<?>[] list;
+        synchronized (state) {
+            if (!state.done) {
+                return;
+            }
+            state.done = true;
+            state.exception = e;
+            if (state.subscribers.isEmpty()) {
+                return;
+            }
+            list = state.subscribers.toArray(new Subscriber<?>[state.subscribers.size()]);
+            state.subscribers.clear();
+        }
+        for (Subscriber<?> s : list) {
+            s.onError(e);
+        }
     }
 
     @Override
+    @SuppressWarnings({ "unchecked", "rawtypes" })
     public void onNext(T t) {
-        observerRef.get().onNext(t);
+        state.observerRef.get().onNext(t);
+        // notify the rest
+        Subscriber[] list;
+        synchronized (state) {
+            if (state.done) {
+                return;
+            }
+            if (state.subscribers.isEmpty()) {
+                return;
+            }
+            list = state.subscribers.toArray(new Subscriber[state.subscribers.size()]);
+        }
+        for (Subscriber s : list) {
+            s.onNext(t);
+        }
     }
 
     /**
@@ -97,6 +210,7 @@ private static class PassThruObserver<T> extends Subscriber<T> {
         // this assumes single threaded synchronous notifications (the Rx contract for a single Observer)
         private final ConcurrentLinkedQueue<Object> buffer;
         private final AtomicReference<Observer<? super T>> observerRef;
+        private final NotificationLite<T> nl = NotificationLite.instance();
 
         PassThruObserver(Observer<? super T> actual, ConcurrentLinkedQueue<Object> buffer, AtomicReference<Observer<? super T>> observerRef) {
             this.actual = actual;
@@ -123,67 +237,34 @@ public void onNext(T t) {
         }
 
         private void drainIfNeededAndSwitchToActual() {
-            Object o = null;
+            Object o;
             while ((o = buffer.poll()) != null) {
-                emit(this, o);
+                nl.accept(this, o);
             }
             // now we can safely change over to the actual and get rid of the pass-thru
-            observerRef.set(actual);
+            observerRef.compareAndSet(this, actual);
         }
 
     }
 
     private static class BufferedObserver<T> extends Subscriber<T> {
         private final ConcurrentLinkedQueue<Object> buffer = new ConcurrentLinkedQueue<Object>();
+        private final NotificationLite<T> nl = NotificationLite.instance();
 
         @Override
         public void onCompleted() {
-            buffer.add(COMPLETE_SENTINEL);
+            buffer.add(nl.completed());
         }
 
         @Override
         public void onError(Throwable e) {
-            buffer.add(new ErrorSentinel(e));
+            buffer.add(nl.error(e));
         }
 
         @Override
         public void onNext(T t) {
-            if (t == null) {
-                buffer.add(NULL_SENTINEL);
-            } else {
-                buffer.add(t);
-            }
-        }
-
-    }
-
-    private final static <T> void emit(Observer<T> s, Object v) {
-        if (v instanceof Sentinel) {
-            if (v == NULL_SENTINEL) {
-                s.onNext(null);
-            } else if (v == COMPLETE_SENTINEL) {
-                s.onCompleted();
-            } else if (v instanceof ErrorSentinel) {
-                s.onError(((ErrorSentinel) v).e);
-            }
-        } else {
-            s.onNext((T) v);
+            buffer.add(nl.next(t));
         }
-    }
-
-    private static class Sentinel {
 
     }
-
-    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) {
-            this.e = e;
-        }
-    }
-
 }
diff --git a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java b/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
deleted file mode 100644
index e8c5c80f15..0000000000
--- a/rxjava-core/src/main/java/rx/operators/ChunkedOperation.java
+++ /dev/null
@@ -1,675 +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.List;
-import java.util.Queue;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import rx.Observable;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Scheduler.Worker;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Func0;
-import rx.functions.Func1;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.MultipleAssignmentSubscription;
-
-/**
- * The base class for operations that break observables into "chunks". Currently buffers and windows.
- */
-public class ChunkedOperation {
-    /**
-     * This interface defines a way which specifies when to create a new internal {@link rx.operators.ChunkedOperation.Chunk} object.
-     * 
-     */
-    protected interface ChunkCreator {
-        /**
-         * Signifies a onNext event.
-         */
-        void onValuePushed();
-
-        /**
-         * Signifies a onCompleted or onError event. Should be used to clean up open
-         * subscriptions and other still running background tasks.
-         */
-        void stop();
-    }
-
-    /**
-     * This class represents a single chunk: A sequence of recorded values.
-     * 
-     * @param <T>
-     *            The type of objects which this {@link Chunk} can hold.
-     * @param <C>
-     *            The type of object being tracked by the {@link Chunk}
-     */
-    protected abstract static class Chunk<T, C> {
-        protected final List<T> contents = new ArrayList<T>();
-
-        /**
-         * Appends a specified value to the {@link Chunk}.
-         * 
-         * @param value
-         *            The value to append to the {@link Chunk}.
-         */
-        public void pushValue(T value) {
-            contents.add(value);
-        }
-
-        /**
-         * @return
-         *         The mutable underlying {@code C} which contains all the
-         *         recorded values in this {@link Chunk} object.
-         */
-        abstract public C getContents();
-
-        /**
-         * @return
-         *         The size of the underlying {@link List} which contains all the
-         *         recorded values in this {@link Chunk} object.
-         */
-        public int size() {
-            return contents.size();
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class which only supports one
-     * active (not yet emitted) internal {@link rx.operators.ChunkedOperation.Chunks} object.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class NonOverlappingChunks<T, C> extends Chunks<T, C> {
-
-        private final Object lock = new Object();
-
-        public NonOverlappingChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker) {
-            super(observer, chunkMaker);
-        }
-
-        public Chunk<T, C> emitAndReplaceChunk() {
-            synchronized (lock) {
-                emitChunk(getChunk());
-                return createChunk();
-            }
-        }
-
-        @Override
-        public void pushValue(T value) {
-            synchronized (lock) {
-                super.pushValue(value);
-            }
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class which actually has no additional
-     * behavior than its super class. Classes extending this class, are expected to support
-     * two or more active (not yet emitted) internal {@link rx.operators.ChunkedOperation.Chunks} objects.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunks} objects record.
-     *            <C> The type of object being tracked by the {@link rx.operators.ChunkedOperation.Chunk}
-     */
-    protected static class OverlappingChunks<T, C> extends Chunks<T, C> {
-        public OverlappingChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker) {
-            super(observer, chunkMaker);
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
-     * a has a maximum time to live and a maximum internal capacity. When the chunk has
-     * reached the end of its life, or reached its maximum internal capacity it is
-     * automatically emitted.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class TimeAndSizeBasedChunks<T, C> extends Chunks<T, C> implements Subscription {
-
-        private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
-
-        private final Scheduler.Worker scheduler;
-        private final long maxTime;
-        private final TimeUnit unit;
-        private final int maxSize;
-        private volatile boolean unsubscribed = false;
-
-        public TimeAndSizeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker, int maxSize, long maxTime, TimeUnit unit, Scheduler scheduler) {
-            super(observer, chunkMaker);
-            this.maxSize = maxSize;
-            this.maxTime = maxTime;
-            this.unit = unit;
-            this.scheduler = scheduler.createWorker();
-        }
-
-        @Override
-        public Chunk<T, C> createChunk() {
-            final Chunk<T, C> chunk = super.createChunk();
-            subscriptions.put(chunk, scheduler.schedule(new Action0() {
-                @Override
-                public void call() {
-                    emitChunk(chunk);
-                }
-            }, maxTime, unit));
-            return chunk;
-        }
-
-        @Override
-        public void emitChunk(Chunk<T, C> chunk) {
-            Subscription subscription = subscriptions.remove(chunk);
-            if (subscription == null) {
-                // Chunk was already emitted.
-                return;
-            }
-
-            // Fixed issue 428.
-            // As unsubscribe will cancel the Future, and the currrent thread's interrupt status
-            // will be set. So we need to emit the chunk before unsubscribe.
-            super.emitChunk(chunk);
-            subscription.unsubscribe();
-            createChunk();
-        }
-
-        @Override
-        public void pushValue(T value) {
-            super.pushValue(value);
-
-            Chunk<T, C> chunk;
-            while ((chunk = getChunk()) != null) {
-                if (chunk.size() >= maxSize) {
-                    emitChunk(chunk);
-                } else {
-                    // Chunk is not at full capacity yet, and neither will remaining chunks be so we can terminate.
-                    break;
-                }
-            }
-        }
-
-        @Override
-        public void unsubscribe() {
-            unsubscribed = true;
-            for (Subscription s : subscriptions.values()) {
-                s.unsubscribe();
-            }
-            scheduler.unsubscribe();
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return unsubscribed;
-        }
-    }
-
-    /**
-     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
-     * a has a maximum time to live. When the chunk has reached the end of its life it is
-     * automatically emitted.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class TimeBasedChunks<T, C> extends OverlappingChunks<T, C> implements Subscription {
-
-        private final ConcurrentMap<Chunk<T, C>, Subscription> subscriptions = new ConcurrentHashMap<Chunk<T, C>, Subscription>();
-
-        private final Scheduler.Worker scheduler;
-        private final long time;
-        private final TimeUnit unit;
-        private volatile boolean unsubscribed = false;
-
-        public TimeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker, long time, TimeUnit unit, Scheduler scheduler) {
-            super(observer, chunkMaker);
-            this.time = time;
-            this.unit = unit;
-            this.scheduler = scheduler.createWorker();
-        }
-
-        @Override
-        public Chunk<T, C> createChunk() {
-            final Chunk<T, C> chunk = super.createChunk();
-            subscriptions.put(chunk, scheduler.schedule(new Action0() {
-                @Override
-                public void call() {
-                    emitChunk(chunk);
-                }
-            }, time, unit));
-            return chunk;
-        }
-
-        @Override
-        public void emitChunk(Chunk<T, C> chunk) {
-            subscriptions.remove(chunk);
-            super.emitChunk(chunk);
-        }
-
-        @Override
-        public void unsubscribe() {
-            unsubscribed = true;
-            for (Subscription s : subscriptions.values()) {
-                s.unsubscribe();
-            }
-            scheduler.unsubscribe();
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return unsubscribed;
-        }
-
-    }
-
-    /**
-     * This class is an extension on the {@link rx.operators.ChunkedOperation.Chunks} class. Every internal chunk has
-     * a fixed maximum capacity. When the chunk has reached its maximum capacity it is
-     * automatically emitted.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class SizeBasedChunks<T, C> extends Chunks<T, C> {
-
-        private final int size;
-
-        public SizeBasedChunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker, int size) {
-            super(observer, chunkMaker);
-            this.size = size;
-        }
-
-        @Override
-        public void pushValue(T value) {
-            super.pushValue(value);
-
-            Chunk<T, C> chunk;
-            while ((chunk = getChunk()) != null) {
-                if (chunk.size() >= size) {
-                    emitChunk(chunk);
-                } else {
-                    // Chunk is not at full capacity yet, and neither will remaining chunks be so we can terminate.
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     * This class represents an object which contains and manages multiple {@link rx.operators.ChunkedOperation.Chunk} objects.
-     * 
-     * @param <T>
-     *            The type of objects which the internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class Chunks<T, C> {
-
-        private final Queue<Chunk<T, C>> chunks = new ConcurrentLinkedQueue<Chunk<T, C>>();
-        private final Observer<? super C> observer;
-        private final Func0<? extends Chunk<T, C>> chunkMaker;
-
-        /**
-         * Constructs a new {@link ChunkedOperation.Chunks} object for the specified {@link rx.Observer}.
-         * 
-         * @param observer
-         *            The {@link rx.Observer} to which this object will emit its internal {@link rx.operators.ChunkedOperation.Chunk} objects to when requested.
-         */
-        public Chunks(Observer<? super C> observer, Func0<? extends Chunk<T, C>> chunkMaker) {
-            this.observer = observer;
-            this.chunkMaker = chunkMaker;
-        }
-
-        /**
-         * This method will instantiate a new {@link rx.operators.ChunkedOperation.Chunk} object and register it internally.
-         * 
-         * @return
-         *         The constructed empty {@link rx.operators.ChunkedOperation.Chunk} object.
-         */
-        public Chunk<T, C> createChunk() {
-            Chunk<T, C> chunk = chunkMaker.call();
-            chunks.add(chunk);
-            return chunk;
-        }
-
-        /**
-         * This method emits all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
-         */
-        public void emitAllChunks() {
-            Chunk<T, C> chunk;
-            while ((chunk = chunks.poll()) != null) {
-                observer.onNext(chunk.getContents());
-            }
-        }
-
-        /**
-         * This method emits the specified {@link rx.operators.ChunkedOperation.Chunk} object.
-         * 
-         * @param chunk
-         *            The {@link rx.operators.ChunkedOperation.Chunk} to emit.
-         */
-        public void emitChunk(Chunk<T, C> chunk) {
-            if (!chunks.remove(chunk)) {
-                // Concurrency issue: Chunk is already emitted!
-                return;
-            }
-            observer.onNext(chunk.getContents());
-        }
-
-        /**
-         * @return
-         *         The oldest (in case there are multiple) {@link rx.operators.ChunkedOperation.Chunk} object.
-         */
-        public Chunk<T, C> getChunk() {
-            return chunks.peek();
-        }
-
-        /**
-         * This method pushes a value to all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
-         * 
-         * @param value
-         *            The value to push to all not yet emitted {@link rx.operators.ChunkedOperation.Chunk} objects.
-         */
-        public void pushValue(T value) {
-            List<Chunk<T, C>> copy = new ArrayList<Chunk<T, C>>(chunks);
-            for (Chunk<T, C> chunk : copy) {
-                chunk.pushValue(value);
-            }
-        }
-    }
-
-    /**
-     * This {@link rx.operators.ChunkedOperation.ChunkObserver} object can be constructed using a {@link rx.operators.ChunkedOperation.Chunks} object,
-     * a {@link rx.Observer} object, and a {@link rx.operators.ChunkedOperation.ChunkCreator} object. The {@link rx.operators.ChunkedOperation.ChunkCreator} will manage the creation, and in some rare
-     * cases emission of internal {@link rx.operators.ChunkedOperation.Chunk} objects
-     * in the specified {@link rx.operators.ChunkedOperation.Chunks} object. Under normal circumstances the {@link rx.operators.ChunkedOperation.Chunks} object specifies when a created
-     * {@link rx.operators.ChunkedOperation.Chunk} is emitted.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class ChunkObserver<T, C> extends Subscriber<T> {
-
-        private final Chunks<T, C> chunks;
-        private final Observer<? super C> observer;
-        private final ChunkCreator creator;
-
-        public ChunkObserver(Chunks<T, C> chunks, Observer<? super C> observer, ChunkCreator creator) {
-            this.observer = observer;
-            this.creator = creator;
-            this.chunks = chunks;
-        }
-
-        @Override
-        public void onCompleted() {
-            creator.stop();
-            chunks.emitAllChunks();
-            observer.onCompleted();
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            creator.stop();
-            chunks.emitAllChunks();
-            observer.onError(e);
-        }
-
-        @Override
-        public void onNext(T args) {
-            creator.onValuePushed();
-            chunks.pushValue(args);
-        }
-    }
-
-    /**
-     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} when it is initialized, but
-     * provides no additional functionality. This class should primarily be used when the
-     * internal {@link rx.operators.ChunkedOperation.Chunk} is closed externally.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class SingleChunkCreator<T, C> implements ChunkCreator {
-
-        public SingleChunkCreator(Chunks<T, C> chunks) {
-            chunks.createChunk();
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Do nothing.
-        }
-
-        @Override
-        public void stop() {
-            // Do nothing.
-        }
-    }
-
-    /**
-     * 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.functions.Func0}.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class ObservableBasedSingleChunkCreator<T, C, TClosing> implements ChunkCreator {
-
-        private final SafeObservableSubscription subscription = new SafeObservableSubscription();
-        private final Func0<? extends Observable<? extends TClosing>> chunkClosingSelector;
-        private final NonOverlappingChunks<T, C> chunks;
-
-        public ObservableBasedSingleChunkCreator(NonOverlappingChunks<T, C> chunks, Func0<? extends Observable<? extends TClosing>> chunkClosingSelector) {
-            this.chunks = chunks;
-            this.chunkClosingSelector = chunkClosingSelector;
-
-            chunks.createChunk();
-            listenForChunkEnd();
-        }
-
-        private void listenForChunkEnd() {
-            Observable<? extends TClosing> closingObservable = chunkClosingSelector.call();
-            closingObservable.unsafeSubscribe(new Subscriber<TClosing>() {
-
-                @Override
-                public void onCompleted() {
-
-                }
-
-                @Override
-                public void onError(Throwable e) {
-
-                }
-
-                @Override
-                public void onNext(TClosing t) {
-                    chunks.emitAndReplaceChunk();
-                    listenForChunkEnd();
-                }
-
-            });
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Ignore value pushes.
-        }
-
-        @Override
-        public void stop() {
-            subscription.unsubscribe();
-        }
-    }
-
-    /**
-     * 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.functions.Func1}.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class ObservableBasedMultiChunkCreator<T, C, TOpening, TClosing> implements ChunkCreator {
-
-        private final CompositeSubscription subscription = new CompositeSubscription();
-
-        public ObservableBasedMultiChunkCreator(final OverlappingChunks<T, C> chunks, Observable<? extends TOpening> openings, final Func1<? super TOpening, ? extends Observable<? extends TClosing>> chunkClosingSelector) {
-            openings.unsafeSubscribe(new Subscriber<TOpening>(subscription) {
-
-                @Override
-                public void onCompleted() {
-
-                }
-
-                @Override
-                public void onError(Throwable e) {
-
-                }
-
-                @Override
-                public void onNext(TOpening opening) {
-                    final Chunk<T, C> chunk = chunks.createChunk();
-                    Observable<? extends TClosing> closingObservable = chunkClosingSelector.call(opening);
-
-                    closingObservable.unsafeSubscribe(new Subscriber<TClosing>() {
-
-                        @Override
-                        public void onCompleted() {
-
-                        }
-
-                        @Override
-                        public void onError(Throwable e) {
-
-                        }
-
-                        @Override
-                        public void onNext(TClosing t) {
-                            chunks.emitChunk(chunk);
-                        }
-
-                    });
-                }
-
-            });
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Ignore value pushes.
-        }
-
-        @Override
-        public void stop() {
-            subscription.unsubscribe();
-        }
-    }
-
-    /**
-     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} every time after a fixed
-     * period of time has elapsed.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class TimeBasedChunkCreator<T, C> implements ChunkCreator {
-
-        private final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription();
-
-        public TimeBasedChunkCreator(final NonOverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            Worker inner = scheduler.createWorker();
-            this.subscription.set(inner);
-            inner.schedulePeriodically(new Action0() {
-                @Override
-                public void call() {
-                    chunks.emitAndReplaceChunk();
-                }
-            }, 0, time, unit);
-        }
-
-        public TimeBasedChunkCreator(final OverlappingChunks<T, C> chunks, long time, TimeUnit unit, Scheduler scheduler) {
-            Worker inner = scheduler.createWorker();
-            this.subscription.set(inner);
-            inner.schedulePeriodically(new Action0() {
-                @Override
-                public void call() {
-                    chunks.createChunk();
-                }
-            }, 0, time, unit);
-        }
-
-        @Override
-        public void onValuePushed() {
-            // Do nothing: chunks are created periodically.
-        }
-
-        @Override
-        public void stop() {
-            subscription.unsubscribe();
-        }
-    }
-
-    /**
-     * This {@link rx.operators.ChunkedOperation.ChunkCreator} creates a new {@link rx.operators.ChunkedOperation.Chunk} every time after it has
-     * seen a certain amount of elements.
-     * 
-     * @param <T>
-     *            The type of object all internal {@link rx.operators.ChunkedOperation.Chunk} objects record.
-     *            <C> The type of object being tracked by the {@link Chunk}
-     */
-    protected static class SkippingChunkCreator<T, C> implements ChunkCreator {
-
-        private final AtomicInteger skipped = new AtomicInteger(1);
-        private final Chunks<T, C> chunks;
-        private final int skip;
-
-        public SkippingChunkCreator(Chunks<T, C> chunks, int skip) {
-            this.chunks = chunks;
-            this.skip = skip;
-        }
-
-        @Override
-        public void onValuePushed() {
-            if (skipped.decrementAndGet() == 0) {
-                skipped.set(skip);
-                chunks.createChunk();
-            }
-        }
-
-        @Override
-        public void stop() {
-            // Nothing to stop: we're not using a Scheduler.
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationWindow.java b/rxjava-core/src/main/java/rx/operators/OperationWindow.java
deleted file mode 100644
index 054be1f29b..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationWindow.java
+++ /dev/null
@@ -1,527 +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 rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscriber;
-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;
-
-public final class OperationWindow extends ChunkedOperation {
-
-    public static <T> Func0<Window<T>> windowMaker() {
-        return new Func0<Window<T>>() {
-            @Override
-            public Window<T> call() {
-                return new Window<T>();
-            }
-        };
-    }
-
-    /**
-     * 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.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.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param windowClosingSelector
-     *            a {@link rx.functions.Func0} object that 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.functions.Func1} object representing the specified window operation
-     */
-    public static <T, TClosing> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final Func0<? extends Observable<? extends TClosing>> windowClosingSelector) {
-        return new OnSubscribeFunc<Observable<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker());
-                ChunkCreator creator = new ObservableBasedSingleChunkCreator<T, Observable<T>, TClosing>(windows, windowClosingSelector);
-                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
-            }
-
-        };
-    }
-
-    /**
-     * 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.
-     * <p>
-     * Windows can be created by pushing a {@link rx.util.TOpening} value to the {@code windowOpenings}
-     * {@link rx.Observable}. This creates a new window which will then start recording values which are
-     * produced by the {@code source} {@link rx.Observable}. Additionally the {@code windowClosingSelector}
-     * will be used to construct an {@link rx.Observable} which can produce values. When it does so it will
-     * close this (and only this) newly created window. When the source {@link rx.Observable} completes or
-     * produces an error, all windows are emitted, and the event is propagated to all subscribed
-     * {@link rx.Observer}s.
-     * </p><p>
-     * Note that when using this operation <strong>multiple overlapping windows</strong> could be active at any
-     * one point.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param windowOpenings
-     *            an {@link rx.Observable} which when it produces a {@link rx.util.TOpening} value will create a
-     *            new window which instantly starts recording the {@code source} {@link rx.Observable}
-     * @param windowClosingSelector
-     *            a {@link rx.functions.Func0} object that 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.functions.Func1} object representing the specified window operation
-     */
-    public static <T, TOpening, TClosing> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final Observable<? extends TOpening> windowOpenings, final Func1<? super TOpening, ? extends Observable<? extends TClosing>> windowClosingSelector) {
-        return new OnSubscribeFunc<Observable<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                OverlappingChunks<T, Observable<T>> windows = new OverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker());
-                ChunkCreator creator = new ObservableBasedMultiChunkCreator<T, Observable<T>, TOpening, TClosing>(windows, windowOpenings, windowClosingSelector);
-                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
-            }
-        };
-    }
-
-    /**
-     * 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 the event is propagated to all subscribed {@link rx.Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param count
-     *            the number of elements a window should have before being emitted and replaced
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, int count) {
-        return window(source, count, count);
-    }
-
-    /**
-     * 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 currently active windows are emitted, and the event is propagated to
-     * all subscribed {@link rx.Observer}s.
-     * <p>
-     * Note that this operation can produce <strong>non-connected, connected non-overlapping, or overlapping
-     * windows</strong> depending on the input parameters.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param count
-     *            the number of elements a window should have before being emitted
-     * @param skip
-     *            the interval with which windows have to be created. Note that when {@code skip == count} that
-     *            this is the same as calling {@link rx.operators.OperationWindow#window(rx.Observable, int)}.
-     *            If {@code skip < count}, this window operation will produce overlapping windows and if
-     *            {@code skip > count} non-overlapping windows will be created and some values will not be
-     *            pushed into a window at all!
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final int count, final int skip) {
-        return new OnSubscribeFunc<Observable<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                Chunks<T, Observable<T>> chunks = new SizeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker(), count);
-                ChunkCreator creator = new SkippingChunkCreator<T, Observable<T>>(chunks, skip);
-                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
-            }
-        };
-    }
-
-    /**
-     * 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 the event is propagated to all subscribed {@link rx.Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param timespan
-     *            the amount of time all windows must be actively collect values before being emitted
-     * @param unit
-     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit) {
-        return window(source, timespan, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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 the event is propagated to all subscribed {@link rx.Observer}s.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param timespan
-     *            the amount of time all windows must be actively collect values before being emitted
-     * @param unit
-     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
-     * @param scheduler
-     *            the {@link rx.Scheduler} to use for timing windows
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<Observable<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                NonOverlappingChunks<T, Observable<T>> windows = new NonOverlappingChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker());
-                ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timespan, unit, scheduler);
-                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
-            }
-        };
-    }
-
-    /**
-     * 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. 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.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param timespan
-     *            the amount of time all windows must be actively collect values before being emitted
-     * @param unit
-     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
-     * @param count
-     *            the maximum size of the window. Once a window reaches this size, it is emitted
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, TimeUnit unit, int count) {
-        return window(source, timespan, unit, count, Schedulers.computation());
-    }
-
-    /**
-     * 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. 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.
-     * <p>
-     * Note that this operation only produces <strong>non-overlapping windows</strong>. At all times there is
-     * exactly one window actively storing values.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param timespan
-     *            the amount of time all windows must be actively collect values before being emitted
-     * @param unit
-     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
-     * @param count
-     *            the maximum size of the window. Once a window reaches this size, it is emitted
-     * @param scheduler
-     *            the {@link rx.Scheduler} to use for timing windows
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final TimeUnit unit, final int count, final Scheduler scheduler) {
-        return new OnSubscribeFunc<Observable<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                Chunks<T, Observable<T>> chunks = new TimeAndSizeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker(), count, timespan, unit, scheduler);
-                ChunkCreator creator = new SingleChunkCreator<T, Observable<T>>(chunks);
-                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(chunks, observer, creator));
-            }
-        };
-    }
-
-    /**
-     * 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. 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.
-     * <p>
-     * Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending on
-     * the input parameters.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param timespan
-     *            the amount of time all windows must be actively collect values before being emitted
-     * @param timeshift
-     *            the amount of time between creating windows
-     * @param unit
-     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, long timespan, long timeshift, TimeUnit unit) {
-        return window(source, timespan, timeshift, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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. 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.
-     * <p>
-     * Note that this operation can produce <strong>non-connected, or overlapping windows</strong> depending on
-     * the input parameters.
-     * </p>
-     * 
-     * @param source
-     *            the {@link rx.Observable} which produces values
-     * @param timespan
-     *            the amount of time all windows must be actively collect values before being emitted
-     * @param timeshift
-     *            the amount of time between creating windows
-     * @param unit
-     *            the {@link java.util.concurrent.TimeUnit} defining the unit of time for the timespan
-     * @param scheduler
-     *            the {@link rx.Scheduler} to use for timing windows
-     * @return
-     *         the {@link rx.functions.Func1} object representing the specified window operation
-     */
-    public static <T> OnSubscribeFunc<Observable<T>> window(final Observable<? extends T> source, final long timespan, final long timeshift, final TimeUnit unit, final Scheduler scheduler) {
-        return new OnSubscribeFunc<Observable<T>>() {
-            @Override
-            public Subscription onSubscribe(final Observer<? super Observable<T>> observer) {
-                OverlappingChunks<T, Observable<T>> windows = new TimeBasedChunks<T, Observable<T>>(observer, OperationWindow.<T> windowMaker(), timespan, unit, scheduler);
-                ChunkCreator creator = new TimeBasedChunkCreator<T, Observable<T>>(windows, timeshift, unit, scheduler);
-                return source.unsafeSubscribe(new ChunkObserver<T, Observable<T>>(windows, observer, creator));
-            }
-        };
-    }
-
-    /**
-     * This class represents a single window: A sequence of recorded values.
-     * 
-     * @param <T>
-     *            the type of objects which this {@link Window} can hold
-     */
-    protected static class Window<T> extends Chunk<T, Observable<T>> {
-        /**
-         * @return
-         *         the mutable underlying {@link Observable} which contains all the recorded values in this
-         *         {@link Window} object
-         */
-        @Override
-        public Observable<T> 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.
-     *
-     * @param source
-     * @param boundary
-     * @return
-     */
-    public static <T, U> OnSubscribeFunc<Observable<T>> window(Observable<? extends T> source, Observable<U> boundary) {
-        return new WindowViaObservable<T, U>(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<T, U> implements OnSubscribeFunc<Observable<T>> {
-        final Observable<? extends T> source;
-        final Observable<U> boundary;
-
-        public WindowViaObservable(Observable<? extends T> source, Observable<U> boundary) {
-            this.source = source;
-            this.boundary = boundary;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super Observable<T>> t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            final SourceObserver<T> so = new SourceObserver<T>(t1, csub);
-            try {
-                t1.onNext(so.subject);
-            } catch (Throwable t) {
-                t1.onError(t);
-                return Subscriptions.empty();
-            }
-            csub.add(source.unsafeSubscribe(so));
-
-            if (!csub.isUnsubscribed()) {
-                csub.add(boundary.unsafeSubscribe(new BoundaryObserver<T, U>(so)));
-            }
-
-            return csub;
-        }
-
-        /**
-         * Observe the source and emit the values into the current window.
-         */
-        private static final class SourceObserver<T> extends Subscriber<T> {
-            final Observer<? super Observable<T>> observer;
-            final Subscription cancel;
-            final Object guard;
-            Subject<T, T> subject;
-
-            public SourceObserver(Observer<? super Observable<T>> observer, Subscription cancel) {
-                this.observer = observer;
-                this.cancel = cancel;
-                this.guard = new Object();
-                this.subject = create();
-            }
-
-            Subject<T, T> 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<T, T> s = subject;
-                    subject = null;
-
-                    s.onError(e);
-                    observer.onError(e);
-                }
-                cancel.unsubscribe();
-            }
-
-            @Override
-            public void onCompleted() {
-                synchronized (guard) {
-                    if (subject == null) {
-                        return;
-                    }
-                    Subject<T, T> s = subject;
-                    subject = null;
-
-                    s.onCompleted();
-                    observer.onCompleted();
-                }
-                cancel.unsubscribe();
-            }
-
-            public void replace() {
-                try {
-                    synchronized (guard) {
-                        if (subject == null) {
-                            return;
-                        }
-                        Subject<T, T> 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<T, U> extends Subscriber<U> {
-            final SourceObserver<T> so;
-
-            public BoundaryObserver(SourceObserver<T> 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/main/java/rx/operators/OperatorBufferWithTime.java b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithTime.java
index 98a3efd654..bed97c3c7c 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithTime.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithTime.java
@@ -253,6 +253,7 @@ public void onError(Throwable e) {
                 chunk = null;
             }
             child.onError(e);
+            unsubscribe();
         }
 
         @Override
@@ -274,6 +275,7 @@ public void onCompleted() {
                 return;
             }
             child.onCompleted();
+            unsubscribe();
         }
         void scheduleExact() {
             inner.schedulePeriodically(new Action0() {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorWindowWithObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithObservable.java
new file mode 100644
index 0000000000..bcf5e2b538
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithObservable.java
@@ -0,0 +1,303 @@
+/**
+ * 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.Collections;
+import java.util.List;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Subscriber;
+import rx.functions.Func0;
+import rx.observers.SerializedSubscriber;
+import rx.observers.Subscribers;
+
+/**
+ * Creates non-overlapping windows of items where each window is terminated by
+ * an event from a secondary observable and a new window is started immediately.
+ * 
+ * @param <T> the value type
+ * @param <U> the boundary value type
+ */
+public final class OperatorWindowWithObservable<T, U> implements Operator<Observable<T>, T> {
+    final Func0<? extends Observable<? extends U>> otherFactory;
+
+    public OperatorWindowWithObservable(Func0<? extends Observable<? extends U>> otherFactory) {
+        this.otherFactory = otherFactory;
+    }
+    public OperatorWindowWithObservable(final Observable<U> other) {
+        this.otherFactory = new Func0<Observable<U>>() {
+
+            @Override
+            public Observable<U> call() {
+                return other;
+            }
+            
+        };
+    }
+    
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
+        
+        Observable<? extends U> other;
+        try {
+            other = otherFactory.call();
+        } catch (Throwable e) {
+            child.onError(e);
+            return Subscribers.empty();
+        }
+        
+        SourceSubscriber<T> sub = new SourceSubscriber<T>(child);
+        BoundarySubscriber<T, U> bs = new BoundarySubscriber<T, U>(child, sub);
+        
+        sub.replaceWindow();
+        
+        other.unsafeSubscribe(bs);
+        
+        return sub;
+    }
+    /** Indicate the current subject should complete and a new subject be emitted. */
+    static final Object NEXT_SUBJECT = new Object();
+    /** For error and completion indication. */
+    static final NotificationLite<Object> nl = NotificationLite.instance();
+    /** Observes the source. */
+    static final class SourceSubscriber<T> extends Subscriber<T> {
+        final Subscriber<? super Observable<T>> child;
+        final Object guard;
+        /** Accessed from the serialized part. */
+        Observer<T> consumer;
+        /** Accessed from the serialized part. */
+        Observable<T> producer;
+        /** Guarded by guard. */
+        boolean emitting;
+        /** Guarded by guard. */
+        List<Object> queue;
+        
+        public SourceSubscriber(Subscriber<? super Observable<T>> child) {
+            super(child);
+            this.child = new SerializedSubscriber<Observable<T>>(child);
+            this.guard = new Object();
+        }
+        @Override
+        public void onNext(T t) {
+            List<Object> localQueue;
+            synchronized (guard) {
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new ArrayList<Object>();
+                    }
+                    queue.add(t);
+                    return;
+                }
+                localQueue = queue;
+                queue = null;
+                emitting = true;
+            }
+            boolean once = true;
+            boolean skipFinal = false;
+            try {
+                do {
+                    drain(localQueue);
+                    if (once) {
+                        once = true;
+                        emitValue(t);
+                    }
+                    
+                    synchronized (guard) {
+                        localQueue = queue;
+                        queue = null;
+                        if (localQueue == null) {
+                            emitting = false;
+                            skipFinal = true;
+                            return;
+                        }
+                    }
+                } while (!child.isUnsubscribed());
+            } finally {
+                if (!skipFinal) {
+                    synchronized (guard) {
+                        emitting = false;
+                    }
+                }
+            }
+        }
+
+        void drain(List<Object> queue) {
+            if (queue == null) {
+                return;
+            }
+            for (Object o : queue) {
+                if (o == NEXT_SUBJECT) {
+                    replaceSubject();
+                } else
+                if (nl.isError(o)) {
+                    error(nl.getError(o));
+                    break;
+                } else
+                if (nl.isCompleted(o)) {
+                    complete();
+                    break;
+                } else {
+                    @SuppressWarnings("unchecked")
+                    T t = (T)o;
+                    emitValue(t);
+                }
+            }
+        }
+        void replaceSubject() {
+            Observer<T> s = consumer;
+            if (s != null) {
+                s.onCompleted();
+            }
+            createNewWindow();
+            child.onNext(producer);
+        }
+        void createNewWindow() {
+            BufferUntilSubscriber<T> bus = BufferUntilSubscriber.create();
+            consumer = bus;
+            producer = bus;
+        }
+        void emitValue(T t) {
+            Observer<T> s = consumer;
+            if (s != null) {
+                s.onNext(t);
+            }
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            synchronized (guard) {
+                if (emitting) {
+                    queue = Collections.singletonList(nl.error(e));
+                    return;
+                }
+                queue = null;
+                emitting = true;
+            }
+            error(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            List<Object> localQueue;
+            synchronized (guard) {
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new ArrayList<Object>();
+                    }
+                    queue.add(nl.completed());
+                    return;
+                }
+                localQueue = queue;
+                queue = null;
+                emitting = true;
+            }
+            try {
+                drain(localQueue);
+            } catch (Throwable e) {
+                error(e);
+                return;
+            }
+            complete();
+        }
+        void replaceWindow() {
+            List<Object> localQueue;
+            synchronized (guard) {
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new ArrayList<Object>();
+                    }
+                    queue.add(NEXT_SUBJECT);
+                    return;
+                }
+                localQueue = queue;
+                queue = null;
+                emitting = true;
+            }
+            boolean once = true;
+            boolean skipFinal = false;
+            try {
+                do {
+                    drain(localQueue);
+                    if (once) {
+                        once = false;
+                        replaceSubject();
+                    }
+                    synchronized (guard) {
+                        localQueue = queue;
+                        queue = null;
+                        if (localQueue == null) {
+                            emitting = false;
+                            skipFinal = true;
+                            return;
+                        }
+                    }
+                } while (!child.isUnsubscribed());
+            } finally {
+                if (!skipFinal) {
+                    synchronized (guard) {
+                        emitting = false;
+                    }
+                }
+            }
+        }
+        void complete() {
+            Observer<T> s = consumer;
+            consumer = null;
+            producer = null;
+            
+            if (s != null) {
+                s.onCompleted();
+            }
+            child.onCompleted();
+            unsubscribe();
+        }
+        void error(Throwable e) {
+            Observer<T> s = consumer;
+            consumer = null;
+            producer = null;
+            
+            if (s != null) {
+                s.onError(e);
+            }
+            child.onError(e);
+            unsubscribe();
+        }
+    }
+    /** Observes the boundary. */
+    static final class BoundarySubscriber<T, U> extends Subscriber<U> {
+        final SourceSubscriber<T> sub;
+        public BoundarySubscriber(Subscriber<?> child, SourceSubscriber<T> sub) {
+            super(child);
+            this.sub = sub;
+        }
+        @Override
+        public void onNext(U t) {
+            sub.replaceWindow();
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            sub.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            sub.onCompleted();
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorWindowWithSize.java b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithSize.java
new file mode 100644
index 0000000000..2f68e9c10f
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithSize.java
@@ -0,0 +1,165 @@
+/**
+ * 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.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Subscriber;
+
+/**
+ * Creates windows of values into the source sequence with skip frequency and size bounds.
+ * 
+ * If skip == size then the windows are non-overlapping, otherwise, windows may overlap
+ * or can be discontinuous. The returned Observable sequence is cold and need to be
+ * consumed while the window operation is in progress.
+ * 
+ * <p>Note that this conforms the Rx.NET behavior, but does not match former RxJava
+ * behavior, which operated as a regular buffer and mapped its lists to Observables.</p>
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorWindowWithSize<T> implements Operator<Observable<T>, T> {
+    final int size;
+    final int skip;
+
+    public OperatorWindowWithSize(int size, int skip) {
+        this.size = size;
+        this.skip = skip;
+    }
+
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
+        if (skip == size) {
+            return new ExactSubscriber(child);
+        }
+        return new InexactSubscriber(child);
+    }
+    /** Subscriber with exact, non-overlapping window bounds. */
+    final class ExactSubscriber extends Subscriber<T> {
+        final Subscriber<? super Observable<T>> child;
+        int count;
+        Observer<T> consumer;
+        Observable<T> producer;
+        public ExactSubscriber(Subscriber<? super Observable<T>> child) {
+            super(child);
+            this.child = child;
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (count++ % size == 0) {
+                if (consumer != null) {
+                    consumer.onCompleted();
+                }
+                createNewWindow();
+                child.onNext(producer);
+            }
+            consumer.onNext(t);
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            if (consumer != null) {
+                consumer.onError(e);
+            }
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            if (consumer != null) {
+                consumer.onCompleted();
+            }
+            child.onCompleted();
+        }
+        void createNewWindow() {
+            final BufferUntilSubscriber<T> bus = BufferUntilSubscriber.create();
+            consumer = bus;
+            producer = bus;
+        }
+    }
+    /** Subscriber with inexact, possibly overlapping or skipping windows. */
+    final class InexactSubscriber extends Subscriber<T> {
+        final Subscriber<? super Observable<T>> child;
+        int count;
+        final List<CountedSubject<T>> chunks;
+        public InexactSubscriber(Subscriber<? super Observable<T>> child) {
+            this.child = child;
+            this.chunks = new LinkedList<CountedSubject<T>>();
+        }
+
+        @Override
+        public void onNext(T t) {
+            if (count++ % skip == 0) {
+                CountedSubject<T> cs = createCountedSubject();
+                chunks.add(cs);
+                child.onNext(cs.producer);
+            }
+            Iterator<CountedSubject<T>> it = chunks.iterator();
+            while (it.hasNext()) {
+                CountedSubject<T> cs = it.next();
+                cs.consumer.onNext(t);
+                if (++cs.count == size) {
+                    it.remove();
+                    cs.consumer.onCompleted();
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            List<CountedSubject<T>> list = new ArrayList<CountedSubject<T>>(chunks);
+            chunks.clear();
+            for (CountedSubject<T> cs : list) {
+                cs.consumer.onError(e);
+            }
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            List<CountedSubject<T>> list = new ArrayList<CountedSubject<T>>(chunks);
+            chunks.clear();
+            for (CountedSubject<T> cs : list) {
+                cs.consumer.onCompleted();
+            }
+            child.onCompleted();
+        }
+        CountedSubject<T> createCountedSubject() {
+            final BufferUntilSubscriber<T> bus = BufferUntilSubscriber.create();
+            return new CountedSubject<T>(bus, bus);
+        }
+    }
+    /** 
+     * Record to store the subject and the emission count. 
+     * @param <T> the subject's in-out type
+     */
+    static final class CountedSubject<T> {
+        final Observer<T> consumer;
+        final Observable<T> producer;
+        int count;
+
+        public CountedSubject(Observer<T> consumer, Observable<T> producer) {
+            this.consumer = consumer;
+            this.producer = producer;
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorWindowWithStartEndObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithStartEndObservable.java
new file mode 100644
index 0000000000..24fb55d805
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithStartEndObservable.java
@@ -0,0 +1,220 @@
+/**
+ * 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.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Subscriber;
+import rx.functions.Func1;
+import rx.observers.SerializedObserver;
+import rx.observers.SerializedSubscriber;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Creates potentially overlapping windows of the source items where each window is
+ * started by a value emitted by an observable and closed when an associated Observable emits 
+ * a value or completes.
+ * 
+ * @param <T> the value type
+ * @param <U> the type of the window opening event
+ * @param <V> the type of the window closing event
+ */
+public final class OperatorWindowWithStartEndObservable<T, U, V> implements Operator<Observable<T>, T> {
+    final Observable<? extends U> windowOpenings;
+    final Func1<? super U, ? extends Observable<? extends V>> windowClosingSelector;
+
+    public OperatorWindowWithStartEndObservable(Observable<? extends U> windowOpenings, 
+            Func1<? super U, ? extends Observable<? extends V>> windowClosingSelector) {
+        this.windowOpenings = windowOpenings;
+        this.windowClosingSelector = windowClosingSelector;
+    }
+    
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
+        final SourceSubscriber sub = new SourceSubscriber(child);
+        
+        Subscriber<U> open = new Subscriber<U>(child) {
+
+            @Override
+            public void onNext(U t) {
+                sub.beginWindow(t);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                sub.onError(e);
+            }
+
+            @Override
+            public void onCompleted() {
+                sub.onCompleted();
+            }
+        };
+           
+        windowOpenings.unsafeSubscribe(open);
+        
+        return sub;
+    }
+    /** Serialized access to the subject. */
+    static final class SerializedSubject<T> {
+        final Observer<T> consumer;
+        final Observable<T> producer;
+
+        public SerializedSubject(Observer<T> consumer, Observable<T> producer) {
+            this.consumer = new SerializedObserver<T>(consumer);
+            this.producer = producer;
+        }
+        
+    }
+    final class SourceSubscriber extends Subscriber<T> {
+        final Subscriber<? super Observable<T>> child;
+        final CompositeSubscription csub;
+        final Object guard;
+        /** Guarded by guard. */
+        final List<SerializedSubject<T>> chunks;
+        /** Guarded by guard. */
+        boolean done;
+        public SourceSubscriber(Subscriber<? super Observable<T>> child) {
+            super(child);
+            this.child = new SerializedSubscriber<Observable<T>>(child);
+            this.guard = new Object();
+            this.chunks = new LinkedList<SerializedSubject<T>>();
+            this.csub = new CompositeSubscription();
+            child.add(csub);
+        }
+        @Override
+        public void onNext(T t) {
+            List<SerializedSubject<T>> list;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                list = new ArrayList<SerializedSubject<T>>(chunks);
+            }
+            for (SerializedSubject<T> cs : list) {
+                cs.consumer.onNext(t);
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            List<SerializedSubject<T>> list;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                list = new ArrayList<SerializedSubject<T>>(chunks);
+                chunks.clear();
+            }
+            for (SerializedSubject<T> cs : list) {
+                cs.consumer.onError(e);
+            }
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            List<SerializedSubject<T>> list;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                list = new ArrayList<SerializedSubject<T>>(chunks);
+                chunks.clear();
+            }
+            for (SerializedSubject<T> cs : list) {
+                cs.consumer.onCompleted();
+            }
+            child.onCompleted();
+        }
+        
+        void beginWindow(U token) {
+            final SerializedSubject<T> s = createSerializedSubject();
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                chunks.add(s);
+            }
+            child.onNext(s.producer);
+            
+            Observable<? extends V> end;
+            try {
+                end = windowClosingSelector.call(token);
+            } catch (Throwable e) {
+                onError(e);
+                return;
+            }
+            
+            Subscriber<V> v = new Subscriber<V>() {
+                boolean once = true;
+                @Override
+                public void onNext(V t) {
+                    onCompleted();
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    
+                }
+
+                @Override
+                public void onCompleted() {
+                    if (once) {
+                        once = false;
+                        endWindow(s);
+                        csub.remove(this);
+                    }
+                }
+                
+            };
+            csub.add(v);
+            
+            end.unsafeSubscribe(v);
+        }
+        void endWindow(SerializedSubject<T> window) {
+            boolean terminate = false;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                Iterator<SerializedSubject<T>> it = chunks.iterator();
+                while (it.hasNext()) {
+                    SerializedSubject<T> s = it.next();
+                    if (s == window) {
+                        terminate = true;
+                        it.remove();
+                        break;
+                    }
+                }
+            }
+            if (terminate) {
+                window.consumer.onCompleted();
+            }
+        }
+        SerializedSubject<T> createSerializedSubject() {
+            BufferUntilSubscriber<T> bus = BufferUntilSubscriber.create();
+            return new SerializedSubject<T>(bus, bus);
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorWindowWithTime.java b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithTime.java
new file mode 100644
index 0000000000..528aa65373
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorWindowWithTime.java
@@ -0,0 +1,470 @@
+ /**
+  * 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.Collections;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import rx.Observable;
+import rx.Observable.Operator;
+import rx.Observer;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.observers.SerializedObserver;
+import rx.observers.SerializedSubscriber;
+
+/**
+ * Creates windows of values into the source sequence with timed window creation, length and size bounds.
+ * If timespan == timeshift, windows are non-overlapping but may not be continuous if size number of items were already
+ * emitted. If more items arrive after the window has reached its size bound, those items are dropped.
+ *
+ * <p>Note that this conforms the Rx.NET behavior, but does not match former RxJava
+ * behavior, which operated as a regular buffer and mapped its lists to Observables.</p>
+ *
+ * @param <T> the value type
+ */
+public final class OperatorWindowWithTime<T> implements Operator<Observable<T>, T> {
+    /** Length of each window. */
+    final long timespan;
+    /** Period of creating new windows. */
+    final long timeshift;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+    final int size;
+    
+    public OperatorWindowWithTime(long timespan, long timeshift, TimeUnit unit, int size, Scheduler scheduler) {
+        this.timespan = timespan;
+        this.timeshift = timeshift;
+        this.unit = unit;
+        this.size = size;
+        this.scheduler = scheduler;
+    }
+    
+    
+    @Override
+    public Subscriber<? super T> call(Subscriber<? super Observable<T>> child) {
+        Worker worker = scheduler.createWorker();
+        child.add(worker);
+        
+        if (timespan == timeshift) {
+            ExactSubscriber s = new ExactSubscriber(child, worker);
+            s.scheduleExact();
+            return s;
+        }
+        
+        InexactSubscriber s = new InexactSubscriber(child, worker);
+        s.startNewChunk();
+        s.scheduleChunk();
+        return s;
+    }
+    /** Indicate the current subject should complete and a new subject be emitted. */
+    static final Object NEXT_SUBJECT = new Object();
+    /** For error and completion indication. */
+    static final NotificationLite<Object> nl = NotificationLite.instance();
+    
+    /** The immutable windowing state with one subject. */
+    static final class State<T> {
+        final Observer<T> consumer;
+        final Observable<T> producer;
+        final int count;
+        static final State<Object> EMPTY = new State<Object>(null, null, 0);
+        
+        public State(Observer<T> consumer, Observable<T> producer, int count) {
+            this.consumer = consumer;
+            this.producer = producer;
+            this.count = count;
+        }
+        public State<T> next() {
+            return new State<T>(consumer, producer, count + 1);
+        }
+        public State<T> create(Observer<T> consumer, Observable<T> producer) {
+            return new State<T>(consumer, producer, 0);
+        }
+        public State<T> clear() {
+            return empty();
+        }
+        @SuppressWarnings("unchecked")
+        public static <T> State<T> empty() {
+            return (State<T>)EMPTY;
+        }
+    }
+    /** Subscriber with exact, non-overlapping windows. */
+    final class ExactSubscriber extends Subscriber<T> {
+        final Subscriber<? super Observable<T>> child;
+        final Worker worker;
+        final Object guard;
+        /** Guarded by guard. */
+        List<Object> queue;
+        /** Guarded by guard. */
+        boolean emitting;
+        volatile State<T> state;
+        
+        public ExactSubscriber(Subscriber<? super Observable<T>> child, Worker worker) {
+            super(child);
+            this.child = new SerializedSubscriber<Observable<T>>(child);
+            this.worker = worker;
+            this.guard = new Object();
+            this.state = State.empty();
+        }
+        @Override
+        public void onNext(T t) {
+            List<Object> localQueue;
+            synchronized (guard) {
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new ArrayList<Object>();
+                    }
+                    queue.add(t);
+                    return;
+                }
+                localQueue = queue;
+                queue = null;
+                emitting = true;
+            }
+            boolean once = true;
+            boolean skipFinal = false;
+            try {
+                do {
+                    drain(localQueue);
+                    if (once) {
+                        once = false;
+                        emitValue(t);
+                    }
+                    synchronized (guard) {
+                        localQueue = queue;
+                        queue = null;
+                        if (localQueue == null) {
+                            emitting = false;
+                            skipFinal = true;
+                            return;
+                        }
+                    }
+                } while (!child.isUnsubscribed());
+            } finally {
+                if (!skipFinal) {
+                    synchronized (guard) {
+                        emitting = false;
+                    }
+                }
+            }
+        }
+        void drain(List<Object> queue) {
+            if (queue == null) {
+                return;
+            }
+            for (Object o : queue) {
+                if (o == NEXT_SUBJECT) {
+                    replaceSubject();
+                } else
+                if (nl.isError(o)) {
+                    error(nl.getError(o));
+                    break;
+                } else
+                if (nl.isCompleted(o)) {
+                    complete();
+                    break;
+                } else {
+                    @SuppressWarnings("unchecked")
+                    T t = (T)o;
+                    emitValue(t);
+                }
+            }
+        }
+        void replaceSubject() {
+            Observer<T> s = state.consumer;
+            if (s != null) {
+                s.onCompleted();
+            }
+            BufferUntilSubscriber<T> bus = BufferUntilSubscriber.create();
+            state = state.create(bus, bus);
+            child.onNext(bus);
+        }
+        void emitValue(T t) {
+            State<T> s = state;
+            
+            if (s.consumer != null) {
+                s.consumer.onNext(t);
+                if (s.count == size) {
+                    s.consumer.onCompleted();
+                    s = s.clear();
+                } else {
+                    s = s.next();
+                }
+            }
+            
+            state = s;
+        }
+        
+        @Override
+        public void onError(Throwable e) {
+            synchronized (guard) {
+                if (emitting) {
+                    // drop any queued action and terminate asap
+                    queue = Collections.<Object>singletonList(nl.error(e));
+                    return;
+                }
+                queue = null;
+                emitting = true;
+            }
+            error(e);
+        }
+        void error(Throwable e) {
+            Observer<T> s = state.consumer;
+            state = state.clear();
+            if (s != null) {
+                s.onError(e);
+            }
+            child.onError(e);
+            unsubscribe();
+        }
+        void complete() {
+            Observer<T> s = state.consumer;
+            state = state.clear();
+            if (s != null) {
+                s.onCompleted();
+            }
+            child.onCompleted();
+            unsubscribe();
+        }
+        @Override
+        public void onCompleted() {
+            List<Object> localQueue;
+            synchronized (guard) {
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new ArrayList<Object>();
+                    }
+                    queue.add(nl.completed());
+                    return;
+                }
+                localQueue = queue;
+                queue = null;
+                emitting = true;
+            }
+            try {
+                drain(localQueue);
+            } catch (Throwable e) {
+                error(e);
+                return;
+            }
+            complete();
+        }
+        
+        void scheduleExact() {
+            worker.schedulePeriodically(new Action0() {
+                
+                @Override
+                public void call() {
+                    nextWindow();
+                }
+                
+            }, 0, timespan, unit);
+        }
+        void nextWindow() {
+            List<Object> localQueue;
+            synchronized (guard) {
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new ArrayList<Object>();
+                    }
+                    queue.add(NEXT_SUBJECT);
+                    return;
+                }
+                localQueue = queue;
+                queue = null;
+                emitting = true;
+            }
+            boolean once = true;
+            boolean skipFinal = false;
+            try {
+                do {
+                    drain(localQueue);
+                    if (once) {
+                        once = false;
+                        replaceSubject();
+                    }
+                    synchronized (guard) {
+                        localQueue = queue;
+                        queue = null;
+                        if (localQueue == null) {
+                            emitting = false;
+                            skipFinal = true;
+                            return;
+                        }
+                    }
+                } while (!child.isUnsubscribed());
+            } finally {
+                if (!skipFinal) {
+                    synchronized (guard) {
+                        emitting = false;
+                    }
+                }
+            }
+        }
+    }
+    /** 
+     * Record to store the subject and the emission count. 
+     * @param <T> the subject's in-out type
+     */
+    static final class CountedSerializedSubject<T> {
+        final Observer<T> consumer;
+        final Observable<T> producer;
+        int count;
+
+        public CountedSerializedSubject(Observer<T> consumer, Observable<T> producer) {
+            this.consumer = new SerializedObserver<T>(consumer);
+            this.producer = producer;
+        }
+    }
+    /** Subscriber with inexact, potentially overlapping or discontinuous windows. */
+    final class InexactSubscriber extends Subscriber<T> {
+        final Subscriber<? super Observable<T>> child;
+        final Worker worker;
+        final Object guard;
+        /** Guarded by this. */
+        final List<CountedSerializedSubject<T>> chunks;
+        /** Guarded by this. */
+        boolean done;
+        public InexactSubscriber(Subscriber<? super Observable<T>> child, Worker worker) {
+            super(child);
+            this.child = child;
+            this.worker = worker;
+            this.guard = new Object();
+            this.chunks = new LinkedList<CountedSerializedSubject<T>>();
+        }
+
+        @Override
+        public void onNext(T t) {
+            List<CountedSerializedSubject<T>> list;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                list = new ArrayList<CountedSerializedSubject<T>>(chunks);
+                Iterator<CountedSerializedSubject<T>> it = chunks.iterator();
+                while (it.hasNext()) {
+                    CountedSerializedSubject<T> cs = it.next();
+                    if (++cs.count == size) {
+                        it.remove();
+                    }
+                }
+            }
+            for (CountedSerializedSubject<T> cs : list) {
+                cs.consumer.onNext(t);
+                if (cs.count == size) {
+                    cs.consumer.onCompleted();
+                }
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            List<CountedSerializedSubject<T>> list;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                list = new ArrayList<CountedSerializedSubject<T>>(chunks);
+                chunks.clear();
+            }
+            for (CountedSerializedSubject<T> cs : list) {
+                cs.consumer.onError(e);
+            }
+            child.onError(e);
+        }
+
+        @Override
+        public void onCompleted() {
+            List<CountedSerializedSubject<T>> list;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                list = new ArrayList<CountedSerializedSubject<T>>(chunks);
+                chunks.clear();
+            }
+            for (CountedSerializedSubject<T> cs : list) {
+                cs.consumer.onCompleted();
+            }
+            child.onCompleted();
+        }
+        void scheduleChunk() {
+            worker.schedulePeriodically(new Action0() {
+
+                @Override
+                public void call() {
+                    startNewChunk();
+                }
+                
+            }, timeshift, timeshift, unit);
+        }
+        void startNewChunk() {
+            final CountedSerializedSubject<T> chunk = createCountedSerializedSubject();
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                chunks.add(chunk);
+            }
+            try {
+                child.onNext(chunk.producer);
+            } catch (Throwable e) {
+                onError(e);
+                return;
+            }
+            
+            worker.schedule(new Action0() {
+
+                @Override
+                public void call() {
+                    terminateChunk(chunk);
+                }
+                
+            }, timespan, unit);
+        }
+        void terminateChunk(CountedSerializedSubject<T> chunk) {
+            boolean terminate = false;
+            synchronized (guard) {
+                if (done) {
+                    return;
+                }
+                Iterator<CountedSerializedSubject<T>> it = chunks.iterator();
+                while (it.hasNext()) {
+                    CountedSerializedSubject<T> cs = it.next();
+                    if (cs == chunk) {
+                        terminate = true;
+                        it.remove();
+                        break;
+                    }
+                }
+            }
+            if (terminate) {
+                chunk.consumer.onCompleted();
+            }
+        }
+        CountedSerializedSubject<T> createCountedSerializedSubject() {
+            BufferUntilSubscriber<T> bus = BufferUntilSubscriber.create();
+            return new CountedSerializedSubject<T>(bus, bus);
+        }
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
similarity index 88%
rename from rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
index 38376a06c9..34f20933fb 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
@@ -21,7 +21,6 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
-import static rx.operators.OperationWindow.window;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -33,7 +32,7 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func0;
@@ -41,9 +40,8 @@
 import rx.schedulers.Schedulers;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
 
-public class OperationWindowTest {
+public class OperatorWindowTest {
 
     private TestScheduler scheduler;
     private Scheduler.Worker innerScheduler;
@@ -76,7 +74,7 @@ public void call(List<T> xs) {
     @Test
     public void testNonOverlappingWindows() {
         Observable<String> subject = Observable.from("one", "two", "three", "four", "five");
-        Observable<Observable<String>> windowed = Observable.create(window(subject, 3));
+        Observable<Observable<String>> windowed = subject.window(3);
 
         List<List<String>> windows = toLists(windowed);
 
@@ -88,7 +86,7 @@ public void testNonOverlappingWindows() {
     @Test
     public void testSkipAndCountGaplessWindows() {
         Observable<String> subject = Observable.from("one", "two", "three", "four", "five");
-        Observable<Observable<String>> windowed = Observable.create(window(subject, 3, 3));
+        Observable<Observable<String>> windowed = subject.window(3, 3);
 
         List<List<String>> windows = toLists(windowed);
 
@@ -100,7 +98,7 @@ public void testSkipAndCountGaplessWindows() {
     @Test
     public void testOverlappingWindows() {
         Observable<String> subject = Observable.from(new String[] { "zero", "one", "two", "three", "four", "five" }, Schedulers.trampoline());
-        Observable<Observable<String>> windowed = Observable.create(window(subject, 3, 1));
+        Observable<Observable<String>> windowed = subject.window(3, 1);
 
         List<List<String>> windows = toLists(windowed);
 
@@ -116,7 +114,7 @@ public void testOverlappingWindows() {
     @Test
     public void testSkipAndCountWindowsWithGaps() {
         Observable<String> subject = Observable.from("one", "two", "three", "four", "five");
-        Observable<Observable<String>> windowed = Observable.create(window(subject, 2, 3));
+        Observable<Observable<String>> windowed = subject.window(2, 3);
 
         List<List<String>> windows = toLists(windowed);
 
@@ -130,20 +128,19 @@ public void testTimedAndCount() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
                 push(observer, "two", 90);
                 push(observer, "three", 110);
                 push(observer, "four", 190);
                 push(observer, "five", 210);
                 complete(observer, 250);
-                return Subscriptions.empty();
             }
         });
 
-        Observable<Observable<String>> windowed = Observable.create(window(source, 100, TimeUnit.MILLISECONDS, 2, scheduler));
+        Observable<Observable<String>> windowed = source.window(100, TimeUnit.MILLISECONDS, 2, scheduler);
         windowed.subscribe(observeWindow(list, lists));
 
         scheduler.advanceTimeTo(100, TimeUnit.MILLISECONDS);
@@ -164,20 +161,19 @@ public void testTimed() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 98);
                 push(observer, "two", 99);
                 push(observer, "three", 100);
                 push(observer, "four", 101);
                 push(observer, "five", 102);
                 complete(observer, 150);
-                return Subscriptions.empty();
             }
         });
 
-        Observable<Observable<String>> windowed = Observable.create(window(source, 100, TimeUnit.MILLISECONDS, scheduler));
+        Observable<Observable<String>> windowed = source.window(100, TimeUnit.MILLISECONDS, scheduler);
         windowed.subscribe(observeWindow(list, lists));
 
         scheduler.advanceTimeTo(101, TimeUnit.MILLISECONDS);
@@ -194,44 +190,41 @@ public void testObservableBasedOpenerAndCloser() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
                 push(observer, "two", 60);
                 push(observer, "three", 110);
                 push(observer, "four", 160);
                 push(observer, "five", 210);
                 complete(observer, 500);
-                return Subscriptions.empty();
             }
         });
 
-        Observable<Object> openings = Observable.create(new Observable.OnSubscribeFunc<Object>() {
+        Observable<Object> openings = Observable.create(new Observable.OnSubscribe<Object>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Object> observer) {
+            public void call(Subscriber<? super Object> observer) {
                 push(observer, new Object(), 50);
                 push(observer, new Object(), 200);
                 complete(observer, 250);
-                return Subscriptions.empty();
             }
         });
 
         Func1<Object, Observable<Object>> closer = new Func1<Object, Observable<Object>>() {
             @Override
             public Observable<Object> call(Object opening) {
-                return Observable.create(new Observable.OnSubscribeFunc<Object>() {
+                return Observable.create(new Observable.OnSubscribe<Object>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super Object> observer) {
+                    public void call(Subscriber<? super Object> observer) {
                         push(observer, new Object(), 100);
                         complete(observer, 101);
-                        return Subscriptions.empty();
                     }
                 });
             }
         };
 
-        Observable<Observable<String>> windowed = Observable.create(window(source, openings, closer));
+        Observable<Observable<String>> windowed = source.window(openings, closer);
         windowed.subscribe(observeWindow(list, lists));
 
         scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS);
@@ -245,34 +238,33 @@ public void testObservableBasedCloser() {
         final List<String> list = new ArrayList<String>();
         final List<List<String>> lists = new ArrayList<List<String>>();
 
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
                 push(observer, "two", 60);
                 push(observer, "three", 110);
                 push(observer, "four", 160);
                 push(observer, "five", 210);
                 complete(observer, 250);
-                return Subscriptions.empty();
             }
         });
 
         Func0<Observable<Object>> closer = new Func0<Observable<Object>>() {
             @Override
             public Observable<Object> call() {
-                return Observable.create(new Observable.OnSubscribeFunc<Object>() {
+                return Observable.create(new Observable.OnSubscribe<Object>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super Object> observer) {
+                    public void call(Subscriber<? super Object> observer) {
                         push(observer, new Object(), 100);
-                        complete(observer, 101);
-                        return Subscriptions.empty();
+                        push(observer, new Object(), 200);
+                        complete(observer, 301);
                     }
                 });
             }
         };
 
-        Observable<Observable<String>> windowed = Observable.create(window(source, closer));
+        Observable<Observable<String>> windowed = source.window(closer);
         windowed.subscribe(observeWindow(list, lists));
 
         scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS);
@@ -502,7 +494,7 @@ public void onCompleted() {
     }
 
     @Test
-    public void testWindowViaObservableourceThrows() {
+    public void testWindowViaObservableSourceThrows() {
         PublishSubject<Integer> source = PublishSubject.create();
         PublishSubject<Integer> boundary = PublishSubject.create();
 
@@ -552,4 +544,4 @@ public void onCompleted() {
         verify(o, never()).onCompleted();
         verify(o).onError(any(OperationReduceTest.CustomException.class));
     }
-}
+}
\ No newline at end of file

From aac1903239682d11bc7945df5934b6339dc7a946 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Thu, 1 May 2014 09:31:35 +0800
Subject: [PATCH 324/422] Update the signature of lift

---
 .../src/main/scala/rx/lang/scala/JavaConversions.scala          | 2 +-
 .../rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala  | 2 +-
 .../src/test/scala/rx/lang/scala/CompletenessTest.scala         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

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 eb6fbec4dc..df86c08f80 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
@@ -55,7 +55,7 @@ object JavaConversions {
     }
   }
 
-  implicit def toJavaOperator[T, R](operator: Subscriber[R] => Subscriber[_ >: T]): rx.Observable.Operator[R, T] = {
+  implicit def toJavaOperator[T, R](operator: Subscriber[R] => Subscriber[T]): rx.Observable.Operator[R, T] = {
     new rx.Observable.Operator[R, T] {
       override def call(subscriber: rx.Subscriber[_ >: R]): rx.Subscriber[_ >: T] = {
         toJavaSubscriber[T](operator(toScalaSubscriber[R](subscriber)))
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 531333450c..35eae53767 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
@@ -2572,7 +2572,7 @@ trait Observable[+T]
    * @return an Observable that emits values that are the result of applying the bind function to the values
    *         of the current Observable
    */
-  def lift[R](operator: Subscriber[R] => Subscriber[_ >: T]): Observable[R] = {
+  def lift[R](operator: Subscriber[R] => Subscriber[T]): Observable[R] = {
     toScalaObservable(asJavaObservable.lift(toJavaOperator[T, R](operator)))
   }
 }
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 ee82c26e26..eca5168da5 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
@@ -79,7 +79,7 @@ class CompletenessTest extends JUnitSuite {
       "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`]",
-      "lift(Operator[_ <: R, _ >: T])" -> "lift(Subscriber[R] => Subscriber[_ >: T])",
+      "lift(Operator[_ <: R, _ >: T])" -> "lift(Subscriber[R] => Subscriber[T])",
       "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])",

From 129e531a0d3b7cb5b3989e6e2a5e9b633a2cc11a Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 30 Apr 2014 17:37:32 +0800
Subject: [PATCH 325/422] Use NotificationLite

---
 .../java/rx/operators/OperatorTakeUntil.java  | 65 ++++++++-----------
 1 file changed, 26 insertions(+), 39 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorTakeUntil.java b/rxjava-core/src/main/java/rx/operators/OperatorTakeUntil.java
index c9d987a48b..2821302170 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorTakeUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorTakeUntil.java
@@ -43,84 +43,71 @@ public final class OperatorTakeUntil {
      * @return An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.
      */
     public static <T, E> Observable<T> takeUntil(final Observable<? extends T> source, final Observable<? extends E> other) {
-        Observable<Notification<T>> s = source.lift(new SourceObservable<T>());
-        Observable<Notification<T>> o = other.lift(new OtherObservable<T, E>());
+        Observable<Object> s = source.lift(new SourceObservable<T>());
+        Observable<Object> o = other.lift(new OtherObservable<E>());
 
-        Observable<Notification<T>> result = Observable.merge(s, o);
+        Observable<Object> result = Observable.merge(s, o);
 
-        return result.takeWhile(new Func1<Notification<T>, Boolean>() {
+        final NotificationLite<T> notification = NotificationLite.instance();
+
+        return result.takeWhile(new Func1<Object, Boolean>() {
             @Override
-            public Boolean call(Notification<T> notification) {
-                return !notification.halt;
+            public Boolean call(Object args) {
+                return !notification.isCompleted(args);
             }
-        }).map(new Func1<Notification<T>, T>() {
+        }).map(new Func1<Object, T>() {
             @Override
-            public T call(Notification<T> notification) {
-                return notification.value;
+            public T call(Object args) {
+                return notification.getValue(args);
             }
         });
     }
 
-    private static class Notification<T> {
-        private final boolean halt;
-        private final T value;
-
-        public static <T> Notification<T> value(T value) {
-            return new Notification<T>(false, value);
-        }
-
-        public static <T> Notification<T> halt() {
-            return new Notification<T>(true, null);
-        }
-
-        private Notification(boolean halt, T value) {
-            this.halt = halt;
-            this.value = value;
-        }
+    private final static class SourceObservable<T> implements Operator<Object, T> {
 
-    }
-
-    private static class SourceObservable<T> implements Operator<Notification<T>, T> {
+        private final NotificationLite<T> notification = NotificationLite.instance();
 
         @Override
-        public Subscriber<? super T> call(final Subscriber<? super Notification<T>> notificationObserver) {
-            return new Subscriber<T>(notificationObserver) {
+        public Subscriber<? super T> call(final Subscriber<? super Object> subscriber) {
+            return new Subscriber<T>(subscriber) {
                 @Override
                 public void onCompleted() {
-                    notificationObserver.onNext(Notification.<T>halt());
+                    subscriber.onNext(notification.completed());
                 }
 
                 @Override
                 public void onError(Throwable e) {
-                    notificationObserver.onError(e);
+                    subscriber.onError(e);
                 }
 
                 @Override
                 public void onNext(T args) {
-                    notificationObserver.onNext(Notification.value(args));
+                    subscriber.onNext(notification.next(args));
                 }
             };
         }
     }
 
-    private static class OtherObservable<T, E> implements Operator<Notification<T>, E> {
+    private final static class OtherObservable<E> implements Operator<Object, E> {
+
+        private final NotificationLite<E> notification = NotificationLite.instance();
 
         @Override
-        public Subscriber<? super E> call(final Subscriber<? super Notification<T>> notificationObserver) {
-            return new Subscriber<E>(notificationObserver) {
+        public Subscriber<? super E> call(final Subscriber<? super Object> subscriber) {
+            return new Subscriber<E>(subscriber) {
                 @Override
                 public void onCompleted() {
-                    notificationObserver.onNext(Notification.<T>halt());
+                    subscriber.onNext(notification.completed());
                 }
 
                 @Override
                 public void onError(Throwable e) {
-                    notificationObserver.onError(e);
+                    subscriber.onError(e);
                 }
 
                 @Override
                 public void onNext(E args) {
-                    notificationObserver.onNext(Notification.<T>halt());
+                    subscriber.onNext(notification.completed());
                 }
             };
         }

From 7cb90f19920e41bd72dbe321a920573f9b58b8a9 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sat, 3 May 2014 16:12:37 +0800
Subject: [PATCH 326/422] Update 'contains' signature to 'contains(Object)'

---
 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 52d9cd5e09..c8ce28c9e8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3213,7 +3213,7 @@ public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<?
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-contains">RxJava Wiki: contains()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh228965.aspx">MSDN: Observable.Contains</a>
      */
-    public final Observable<Boolean> contains(final T element) {
+    public final Observable<Boolean> contains(final Object element) {
         return exists(new Func1<T, Boolean>() {
             public final Boolean call(T t1) {
                 return element == null ? t1 == null : element.equals(t1);

From b1effc786b6281c2adfa704228c07a31ea6c64b0 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 5 May 2014 07:26:22 +0200
Subject: [PATCH 327/422] Modified BufferUntilSubscriber to onError for any
 subscriber but the first

---
 .../rx/operators/BufferUntilSubscriber.java   | 86 +------------------
 1 file changed, 3 insertions(+), 83 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index 7687d8bb04..1392bb6de6 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -15,8 +15,6 @@
  */
 package rx.operators;
 
-import java.util.LinkedHashSet;
-import java.util.Set;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
@@ -59,14 +57,8 @@ static final class State<T> {
         final NotificationLite<T> nl = NotificationLite.instance();
         /** The first observer or the one which buffers until the first arrives. */
         final AtomicReference<Observer<? super T>> observerRef = new AtomicReference<Observer<? super T>>(new BufferedObserver<T>());
-        /** How many subscribers. */
+        /** Allow a single subscriber only. */
         final AtomicBoolean first = new AtomicBoolean();
-        /** The rest of the subscribers without buffering. Guarded by this. */
-        final Set<Subscriber<? super T>> subscribers = new LinkedHashSet<Subscriber<? super T>>();
-        /** Guarded by this. */
-        boolean done;
-        /** Guarded by this. */
-        Throwable exception;
     }
     
     static final class OnSubscribeAction<T> implements OnSubscribe<T> {
@@ -95,33 +87,7 @@ public void call() {
                     }
                 }));
             } else {
-                Throwable e = null;
-                boolean done;
-                synchronized (state) {
-                    done = state.done;
-                    if (!done) {
-                        state.subscribers.add(s);
-                    } else {
-                        e = state.exception;
-                    }
-                }
-                if (done) {
-                    if (e != null) {
-                        s.onError(e);
-                    } else {
-                        s.onCompleted();
-                    }
-                    return;
-                }
-                s.add(Subscriptions.create(new Action0() { 
-
-                    @Override
-                    public void call() {
-                        synchronized (state) {
-                            state.subscribers.remove(s);
-                        }
-                    }
-                }));
+                s.onError(new IllegalStateException("Only one subscriber allowed!"));
             }
         }
         
@@ -136,64 +102,17 @@ private BufferUntilSubscriber(State<T> state) {
     @Override
     public void onCompleted() {
         state.observerRef.get().onCompleted();
-        // notify the rest
-        Subscriber<?>[] list;
-        synchronized (state) {
-            if (!state.done) {
-                return;
-            }
-            state.done = true;
-            if (state.subscribers.isEmpty()) {
-                return;
-            }
-            list = state.subscribers.toArray(new Subscriber<?>[state.subscribers.size()]);
-            state.subscribers.clear();
-        }
-        for (Subscriber<?> s : list) {
-            s.onCompleted();
-        }
     }
 
     @Override
     public void onError(Throwable e) {
         state.observerRef.get().onError(e);
-        // notify the rest
-        Subscriber<?>[] list;
-        synchronized (state) {
-            if (!state.done) {
-                return;
-            }
-            state.done = true;
-            state.exception = e;
-            if (state.subscribers.isEmpty()) {
-                return;
-            }
-            list = state.subscribers.toArray(new Subscriber<?>[state.subscribers.size()]);
-            state.subscribers.clear();
-        }
-        for (Subscriber<?> s : list) {
-            s.onError(e);
-        }
     }
 
     @Override
     @SuppressWarnings({ "unchecked", "rawtypes" })
     public void onNext(T t) {
         state.observerRef.get().onNext(t);
-        // notify the rest
-        Subscriber[] list;
-        synchronized (state) {
-            if (state.done) {
-                return;
-            }
-            if (state.subscribers.isEmpty()) {
-                return;
-            }
-            list = state.subscribers.toArray(new Subscriber[state.subscribers.size()]);
-        }
-        for (Subscriber s : list) {
-            s.onNext(t);
-        }
     }
 
     /**
@@ -242,6 +161,7 @@ private void drainIfNeededAndSwitchToActual() {
                 nl.accept(this, o);
             }
             // now we can safely change over to the actual and get rid of the pass-thru
+            // but only if not unsubscribed
             observerRef.compareAndSet(this, actual);
         }
 

From 5b728bf234d8e11a87ea3d666c831018a8e1cf60 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 5 May 2014 07:49:51 +0200
Subject: [PATCH 328/422] Operator Delay rebase & fixes

---
 rxjava-core/src/main/java/rx/Observable.java  | 15110 ++++++++--------
 .../java/rx/operators/OperationDelay.java     |   307 -
 .../main/java/rx/operators/OperatorDelay.java |   106 +
 .../operators/OperatorDelaySubscription.java  |    59 +
 .../operators/OperatorDelayWithSelector.java  |   134 +
 ...nDelayTest.java => OperatorDelayTest.java} |   104 +-
 6 files changed, 7950 insertions(+), 7870 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationDelay.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDelay.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDelaySubscription.java
 create mode 100644 rxjava-core/src/main/java/rx/operators/OperatorDelayWithSelector.java
 rename rxjava-core/src/test/java/rx/operators/{OperationDelayTest.java => OperatorDelayTest.java} (84%)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 52d9cd5e09..694b0b1b30 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1,7555 +1,7555 @@
-/**
- * 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 static rx.functions.Functions.alwaysFalse;
-
-import java.util.*;
-import java.util.concurrent.*;
-
-import rx.exceptions.*;
-import rx.functions.*;
-import rx.observables.*;
-import rx.observers.SafeSubscriber;
-import rx.operators.*;
-import rx.plugins.*;
-import rx.schedulers.*;
-import rx.subjects.*;
-import rx.subscriptions.Subscriptions;
-
-/**
- * The Observable class that implements the Reactive Pattern.
- * <p>
- * This class provides methods for subscribing to the Observable as well as delegate methods to the various
- * Observers.
- * <p>
- * The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
- * <p>
- * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/legend.png">
- * <p>
- * For more information see the <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
- * 
- * @param <T>
- *            the type of the items emitted by the Observable
- */
-public class Observable<T> {
-
-    final OnSubscribe<T> onSubscribe;
-
-    /**
-     * Observable with Function to execute when subscribed to.
-     * <p>
-     * <em>Note:</em> 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
-     */
-    protected Observable(OnSubscribe<T> f) {
-        this.onSubscribe = f;
-    }
-
-    private static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
-
-    /**
-     * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
-     * it.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/create.png">
-     * <p>
-     * 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.
-     * <p>
-     * A well-formed Observable must invoke either the Subscriber's {@code onCompleted} method exactly once or
-     * its {@code onError} method exactly once.
-     * <p>
-     * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
-     * information.
-     * 
-     * @param <T>
-     *            the type of the items that this Observable emits
-     * @param f
-     *            a function that accepts an {@code Subscriber<T>}, 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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-create">RxJava Wiki: create()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.create.aspx">MSDN: Observable.Create</a>
-     */
-    public final static <T> Observable<T> create(OnSubscribe<T> f) {
-        return new Observable<T>(hook.onCreate(f));
-    }
-
-    /**
-     * Invoked when Obserable.subscribe is called.
-     */
-    public static interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
-        // cover for generics insanity
-    }
-
-    /**
-     * Operator function for lifting into an Observable.
-     */
-    public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> {
-        // cover for generics insanity
-    }
-
-    /**
-     * @deprecated use {@link #create(OnSubscribe)}
-     */
-    @Deprecated
-    public final static <T> Observable<T> create(final OnSubscribeFunc<T> f) {
-        return new Observable<T>(new OnSubscribe<T>() {
-
-            @Override
-            public void call(Subscriber<? super T> observer) {
-                Subscription s = f.onSubscribe(observer);
-                if (s != null && s != observer) {
-                    observer.add(s);
-                }
-            }
-
-        });
-    }
-
-    /**
-     * @deprecated use {@link #OnSubscribe}
-     */
-    @Deprecated
-    public static interface OnSubscribeFunc<T> extends Function {
-
-        public Subscription onSubscribe(Observer<? super T> op);
-
-    }
-
-    /**
-     * 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.
-     * <p>
-     * In other words, this allows chaining Observers together on an Observable for acting on the values within
-     * the Observable.
-     * <p> {@code
-     * observable.map(...).filter(...).take(5).lift(new ObserverA()).lift(new ObserverB(...)).subscribe()
-     * }
-     * 
-     * @param lift
-     * @return an Observable that emits values that are the result of applying the bind function to the values
-     *         of the current Observable
-     */
-    public final <R> Observable<R> lift(final Operator<? extends R, ? super T> lift) {
-        return new Observable<R>(new OnSubscribe<R>() {
-            @Override
-            public void call(Subscriber<? super R> o) {
-                try {
-                    onSubscribe.call(hook.onLift(lift).call(o));
-                } catch (Throwable e) {
-                    // localized capture of errors rather than it skipping all operators 
-                    // and ending up in the try/catch of the subscribe method which then
-                    // prevents onErrorResumeNext and other similar approaches to error handling
-                    if (e instanceof OnErrorNotImplementedException) {
-                        throw (OnErrorNotImplementedException) e;
-                    }
-                    o.onError(e);
-                }
-            }
-        });
-    }
-
-    /* *********************************************************************************************************
-     * Observers Below Here
-     * *********************************************************************************************************
-     */
-
-    /**
-     * Mirror the one Observable in an Iterable of several Observables that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229115.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>> sources) {
-        return create(OperatorAmb.amb(sources));
-    }
-
-    /**
-     * Given two Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @param o1
-     *            an Observable competing to react first
-     * @param o2
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {
-        return create(OperatorAmb.amb(o1, o2));
-    }
-
-    /**
-     * Given three Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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 emits the same sequence of items as whichever of the source Observables first
-     *         emitted an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) {
-        return create(OperatorAmb.amb(o1, o2, o3));
-    }
-
-    /**
-     * Given four Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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 emits the same sequence of items as whichever of the source Observables first
-     *         emitted an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) {
-        return create(OperatorAmb.amb(o1, o2, o3, o4));
-    }
-
-    /**
-     * Given five Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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 emits the same sequence of items as whichever of the source Observables first
-     *         emitted an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) {
-        return create(OperatorAmb.amb(o1, o2, o3, o4, o5));
-    }
-
-    /**
-     * Given six Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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 emits the same sequence of items as whichever of the source Observables first
-     *         emitted an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) {
-        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6));
-    }
-
-    /**
-     * Given seven Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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 emits the same sequence of items as whichever of the source Observables first
-     *         emitted an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) {
-        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7));
-    }
-
-    /**
-     * Given eight Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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 emits the same sequence of items as whichever of the source Observables first
-     *         emitted an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) {
-        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
-    }
-
-    /**
-     * Given nine Observables, mirror the one that first emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
-     * 
-     * @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 emits the same sequence of items as whichever of the source Observables first
-     *         emitted an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
-     */
-    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> o9) {
-        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2), Functions.fromFunc(combineFunction));
-    }
-
-    /**
-     * Combines three 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2, o3), Functions.fromFunc(combineFunction));
-    }
-
-    /**
-     * Combines four 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4,
-            Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(combineFunction));
-    }
-
-    /**
-     * Combines five 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5,
-            Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(combineFunction));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
-            Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(combineFunction));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
-            Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(combineFunction));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
-            Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(combineFunction));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
-     * 
-     * @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 that emits items that are the result of combining the items emitted by the source
-     *         Observables by means of the given aggregation function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    @SuppressWarnings("unchecked")
-    public static final <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
-            Observable<? extends T9> o9,
-            Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> combineFunction) {
-        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8, o9), Functions.fromFunc(combineFunction));
-    }
-    /**
-     * 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.
-     * @param <T> the common base type of source values
-     * @param <R> the result type
-     * @param sources the list of observable sources
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
-     */
-    public static final <T, R> Observable<R> combineLatest(List<? extends Observable<? extends T>> sources, FuncN<? extends R> combineFunction) {
-        return create(new OperatorCombineLatest<T, R>(sources, combineFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by each of the Observables emitted by an Observable,
-     * one after the other, without interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends Observable<? extends T>> observables) {
-        return observables.lift(new OperatorConcat<T>());
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by two Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @param t1
-     *            an Observable to be concatenated
-     * @param t2
-     *            an Observable to be concatenated
-     * @return an Observable that emits items emitted by the two source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2) {
-        return concat(from(t1, t2));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by three Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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 emitted by the three source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
-        return concat(from(t1, t2, t3));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by four Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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 emitted by the four source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
-        return concat(from(t1, t2, t3, t4));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by five Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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 emitted by the five source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
-        return concat(from(t1, t2, t3, t4, t5));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by six Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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 emitted by the six source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
-        return concat(from(t1, t2, t3, t4, t5, t6));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by seven Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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 emitted by the seven source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
-        return concat(from(t1, t2, t3, t4, t5, t6, t7));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by eight Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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 emitted by the eight source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
-        return concat(from(t1, t2, t3, t4, t5, t6, t7, t8));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by nine Observables, one after the other, without
-     * interleaving them.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
-     * 
-     * @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 emitted by the nine source Observables, one after the other,
-     *         without interleaving them
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
-     */
-    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
-        return concat(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/defer.png">
-     * <p>
-     * 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
-     * @param <T>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-defer">RxJava Wiki: defer()</a>
-     */
-    public final static <T> Observable<T> defer(Func0<? extends Observable<? extends T>> observableFactory) {
-        return create(new OperatorDefer<T>(observableFactory));
-    }
-
-    /**
-     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its {@link Observer#onCompleted onCompleted} method.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/empty.png">
-     * 
-     * @param <T>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: empty()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229670.aspx">MSDN: Observable.Empty</a>
-     */
-    public final static <T> Observable<T> empty() {
-        return from(new ArrayList<T>());
-    }
-
-    /**
-     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its {@link Observer#onCompleted onCompleted} method on the specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/empty.s.png">
-     * 
-     * @param scheduler
-     *            the Scheduler to use to call the {@link Observer#onCompleted onCompleted} method
-     * @param <T>
-     *            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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: empty()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229066.aspx">MSDN: Observable.Empty Method (IScheduler)</a>
-     */
-    public final static <T> Observable<T> empty(Scheduler scheduler) {
-        return Observable.<T> empty().subscribeOn(scheduler);
-    }
-
-    /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the
-     * Observer subscribes to it.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/error.png">
-     * 
-     * @param exception
-     *            the particular Throwable to pass to {@link Observer#onError onError}
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: error()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244299.aspx">MSDN: Observable.Throw</a>
-     */
-    public final static <T> Observable<T> error(Throwable exception) {
-        return new ThrowObservable<T>(exception);
-    }
-
-    /**
-     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method on the
-     * specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/error.s.png">
-     * 
-     * @param exception
-     *            the particular Throwable to pass to {@link Observer#onError onError}
-     * @param scheduler
-     *            the Scheduler on which to call {@link Observer#onError onError}
-     * @param <T>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: error()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211711.aspx">MSDN: Observable.Throw</a>
-     */
-    public final static <T> Observable<T> error(Throwable exception, Scheduler scheduler) {
-        return Observable.<T> error(exception).subscribeOn(scheduler);
-    }
-
-    /**
-     * Converts a {@link Future} into an Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.png">
-     * <p>
-     * 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.
-     * <p>
-     * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
-     * 
-     * @param future
-     *            the source {@link Future}
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    public final static <T> Observable<T> from(Future<? extends T> future) {
-        return create(OperatorToObservableFuture.toObservableFuture(future));
-    }
-
-    /**
-     * Converts a {@link Future} into an Observable, with a timeout on the Future.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.png">
-     * <p>
-     * 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.
-     * <p>
-     * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
-     * 
-     * @param future
-     *            the source {@link Future}
-     * @param timeout
-     *            the maximum time to wait before calling {@code get()}
-     * @param unit
-     *            the {@link TimeUnit} of the {@code timeout} argument
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    public final static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
-        return create(OperatorToObservableFuture.toObservableFuture(future, timeout, unit));
-    }
-
-    /**
-     * Converts a {@link Future}, operating on a specified {@link Scheduler}, into an Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.s.png">
-     * <p>
-     * 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.
-     * <p>
-     * 
-     * @param future
-     *            the source {@link Future}
-     * @param scheduler
-     *            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 <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    public final static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler) {
-        return create(OperatorToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
-    }
-
-    /**
-     * Converts an {@link Iterable} sequence into an Observable that emits the items in the sequence.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param iterable
-     *            the source {@link Iterable} sequence
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    public final static <T> Observable<T> from(Iterable<? extends T> iterable) {
-        return create(new OnSubscribeFromIterable<T>(iterable));
-    }
-
-    /**
-     * Converts an {@link Iterable} sequence into an Observable that operates on the specified Scheduler,
-     * emitting each item from the sequence.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.s.png">
-     * 
-     * @param iterable
-     *            the source {@link Iterable} sequence
-     * @param scheduler
-     *            the Scheduler on which the Observable is to emit the items of the Iterable
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212140.aspx">MSDN: Observable.ToObservable</a>
-     */
-    public final static <T> Observable<T> from(Iterable<? extends T> iterable, Scheduler scheduler) {
-        return create(new OnSubscribeFromIterable<T>(iterable)).subscribeOn(scheduler);
-    }
-
-    /**
-     * Converts an item into an Observable that emits that item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param t1
-     *            the item
-     * @param <T>
-     *            the type of the item
-     * @return an Observable that emits the item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1) {
-        return from(Arrays.asList(t1));
-    }
-
-    /**
-     * Converts two items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param t1
-     *            first item
-     * @param t2
-     *            second item
-     * @param <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1, T t2) {
-        return from(Arrays.asList(t1, t2));
-    }
-
-    /**
-     * Converts three items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param t1
-     *            first item
-     * @param t2
-     *            second item
-     * @param t3
-     *            third item
-     * @param <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1, T t2, T t3) {
-        return from(Arrays.asList(t1, t2, t3));
-    }
-
-    /**
-     * Converts four items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param t1
-     *            first item
-     * @param t2
-     *            second item
-     * @param t3
-     *            third item
-     * @param t4
-     *            fourth item
-     * @param <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4) {
-        return from(Arrays.asList(t1, t2, t3, t4));
-    }
-
-    /**
-     * Converts five items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param t1
-     *            first item
-     * @param t2
-     *            second item
-     * @param t3
-     *            third item
-     * @param t4
-     *            fourth item
-     * @param t5
-     *            fifth item
-     * @param <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5) {
-        return from(Arrays.asList(t1, t2, t3, t4, t5));
-    }
-
-    /**
-     * Converts six items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @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 <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6) {
-        return from(Arrays.asList(t1, t2, t3, t4, t5, t6));
-    }
-
-    /**
-     * Converts seven items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @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 <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
-        return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7));
-    }
-
-    /**
-     * Converts eight items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @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 <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
-        return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8));
-    }
-
-    /**
-     * Converts nine items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @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 <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> 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 ten items into an Observable that emits those items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * <p>
-     * 
-     * @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 <T>
-     *            the type of these items
-     * @return an Observable that emits each item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> 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));
-    }
-
-    /**
-     * Converts an Array into an Observable that emits the items in the Array.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param t1
-     *            the source Array
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    public final static <T> Observable<T> from(T... t1) {
-        return from(Arrays.asList(t1));
-    }
-
-    /**
-     * Converts an Array into an Observable that emits the items in the Array on a specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
-     * 
-     * @param items
-     *            the source Array
-     * @param scheduler
-     *            the Scheduler on which the Observable emits the items of the Array
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
-     */
-    public final static <T> Observable<T> from(T[] items, Scheduler scheduler) {
-        return from(Arrays.asList(items), scheduler);
-    }
-
-    /**
-     * Returns an Observable that emits a sequential number every specified interval of time.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/interval.png">
-     * 
-     * @param interval
-     *            interval size in time units (see below)
-     * @param unit
-     *            time units to use for the interval size
-     * @return an Observable that emits a sequential number each time interval
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-interval">RxJava Wiki: interval()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229027.aspx">MSDN: Observable.Interval</a>
-     */
-    public final static Observable<Long> interval(long interval, TimeUnit unit) {
-        return create(new OperatorTimerPeriodically(interval, interval, unit, Schedulers.computation()));
-    }
-
-    /**
-     * Returns an Observable that emits a sequential number every specified interval of time, on a
-     * specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/interval.s.png">
-     * 
-     * @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 a sequential number each time interval
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-interval">RxJava Wiki: interval()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228911.aspx">MSDN: Observable.Interval</a>
-     */
-    public final static Observable<Long> interval(long interval, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperatorTimerPeriodically(interval, interval, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that emits a single item and then completes.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/just.png">
-     * <p>
-     * To convert any object into an Observable that emits that object, pass that object into the {@code just} method.
-     * <p>
-     * 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
-     * @param <T>
-     *            the type of that item
-     * @return an Observable that emits {@code value} as a single item and then completes
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-just">RxJava Wiki: just()</a>
-     */
-    public final static <T> Observable<T> just(final T value) {
-        return Observable.create(new OnSubscribe<T>() {
-
-            @Override
-            public void call(Subscriber<? super T> s) {
-                if (!s.isUnsubscribed()) {
-                    s.onNext(value);
-                    s.onCompleted();
-                }
-            }
-
-        });
-    }
-
-    /**
-     * Returns an Observable that emits a single item and then completes, on a specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/just.s.png">
-     * <p>
-     * This is a scheduler version of {@link #just(Object)}.
-     * 
-     * @param value
-     *            the item to emit
-     * @param <T>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-just">RxJava Wiki: just()</a>
-     */
-    public final static <T> Observable<T> just(T value, Scheduler scheduler) {
-        return just(value).subscribeOn(scheduler);
-    }
-
-    /**
-     * Flattens an Iterable of Observables into one Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229590.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences) {
-        return merge(from(sequences));
-    }
-
-    /**
-     * Flattens an Iterable of Observables into one Observable, without any transformation, while limiting the
-     * number of concurrent subscriptions to these Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @throws IllegalArgumentException
-     *             if {@code maxConcurrent} is less than or equal to 0
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229923.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences, int maxConcurrent) {
-        return merge(from(sequences), maxConcurrent);
-    }
-
-    /**
-     * Flattens an Iterable of Observables into one Observable, without any transformation, while limiting the
-     * number of concurrent subscriptions to these Observables, and subscribing to these Observables on a
-     * specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @throws IllegalArgumentException
-     *             if {@code maxConcurrent} is less than or equal to 0
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244329.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences, int maxConcurrent, Scheduler scheduler) {
-        return merge(from(sequences, scheduler), maxConcurrent);
-    }
-
-    /**
-     * Flattens an Iterable of Observables into one Observable, without any transformation, subscribing to these
-     * Observables on a specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244336.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences, Scheduler scheduler) {
-        return merge(from(sequences, scheduler));
-    }
-
-    /**
-     * Flattens an Observable that emits Observables into a single Observable that emits the items emitted by
-     * those Observables, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.oo.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source) {
-        return source.lift(new OperatorMerge<T>());
-    }
-
-    /**
-     * Flattens an Observable that emits Observables into a single Observable that emits the items emitted by
-     * those Observables, without any transformation, while limiting the maximum number of concurrent
-     * subscriptions to these Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.oo.png">
-     * <p>
-     * 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
-     * @throws IllegalArgumentException
-     *             if {@code maxConcurrent} is less than or equal to 0
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211914.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source, int maxConcurrent) {
-        return source.lift(new OperatorMergeMaxConcurrent<T>(maxConcurrent));
-    }
-
-    /**
-     * Flattens two Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @param t2
-     *            an Observable to be merged
-     * @return an Observable that emits all of the items emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2) {
-        return merge(from(Arrays.asList(t1, t2)));
-    }
-
-    /**
-     * Flattens three Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @param t2
-     *            an Observable to be merged
-     * @param t3
-     *            an Observable to be merged
-     * @return an Observable that emits all of the items emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
-        return merge(from(Arrays.asList(t1, t2, t3)));
-    }
-
-    /**
-     * Flattens four Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @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 all of the items emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
-        return merge(from(Arrays.asList(t1, t2, t3, t4)));
-    }
-
-    /**
-     * Flattens five Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @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 all of the items emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
-        return merge(from(Arrays.asList(t1, t2, t3, t4, t5)));
-    }
-
-    /**
-     * Flattens six Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @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 all of the items emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
-        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6)));
-    }
-
-    /**
-     * Flattens seven Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @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 all of the items emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
-        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7)));
-    }
-
-    /**
-     * Flattens eight Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @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
-     * @return an Observable that emits all of the items emitted by the source Observables
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
-        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8)));
-    }
-
-    /**
-     * Flattens nine Observables into a single Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
-     * <p>
-     * 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
-     * @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 all of the items emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
-        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9)));
-    }
-
-    /**
-     * Flattens an Array of Observables into one Observable, without any transformation.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.io.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Observable<? extends T>[] sequences) {
-        return merge(from(sequences));
-    }
-
-    /**
-     * Flattens an Array of Observables into one Observable, without any transformation, traversing the array on
-     * a specified Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.ios.png">
-     * <p>
-     * 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
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229061.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> merge(Observable<? extends T>[] sequences, Scheduler scheduler) {
-        return merge(from(sequences, scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends Observable<? extends T>> source) {
-        return source.lift(new OperatorMergeDelayError<T>());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2) {
-        return mergeDelayError(from(t1, t2));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @param t2
-     *            an Observable to be merged
-     * @param t3
-     *            an Observable to be merged
-     * @return an Observable that emits all of the items that are emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
-        return mergeDelayError(from(t1, t2, t3));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @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 all of the items that are emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
-        return mergeDelayError(from(t1, t2, t3, t4));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @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 all of the items that are emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
-        return mergeDelayError(from(t1, t2, t3, t4, t5));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @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 all of the items that are emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
-        return mergeDelayError(from(t1, t2, t3, t4, t5, t6));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @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 all of the items that are emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
-        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @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 all of the items that are emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    @SuppressWarnings("unchecked")
-    // suppress because the types are checked by the method signature before using a vararg
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
-        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7, t8));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
-     * <p>
-     * 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
-     * @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 all of the items that are emitted by the source Observables
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
-     */
-    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
-        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
-    }
-
-    /**
-     * Convert the current {@code Observable<T>} into an {@code Observable<Observable<T>>}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/nest.png">
-     * 
-     * @return an Observable that emits a single item: the source Observable
-     */
-    public final Observable<Observable<T>> nest() {
-        return just(this);
-    }
-
-    /**
-     * Returns an Observable that never sends any items or notifications to an {@link Observer}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/never.png">
-     * <p>
-     * This Observable is useful primarily for testing purposes.
-     * 
-     * @param <T>
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: never()</a>
-     */
-    public final static <T> Observable<T> never() {
-        return new NeverObservable<T>();
-    }
-
-    /**
-     * Converts an {@code Observable<Observable<T>>} into another {@code Observable<Observable<T>>} whose
-     * emitted Observables emit the same items, but the number of such Observables is restricted by {@code parallelObservables}.
-     * <p>
-     * For example, if the original {@code Observable<Observable<T>>} 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallelMerge.png">
-     * <p>
-     * This is a mechanism for efficiently processing <i>n</i> number of Observables on a smaller <i>m</i>
-     * number of resources (typically CPU cores).
-     * 
-     * @param parallelObservables
-     *            the number of Observables to merge into
-     * @return an Observable of Observables constrained in number by {@code parallelObservables}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-parallelmerge">RxJava Wiki: parallelMerge()</a>
-     */
-    public final static <T> Observable<Observable<T>> parallelMerge(Observable<Observable<T>> source, int parallelObservables) {
-        return OperatorParallelMerge.parallelMerge(source, parallelObservables);
-    }
-
-    /**
-     * Converts an {@code Observable<Observable<T>>} into another {@code Observable<Observable<T>>} 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.
-     * <p>
-     * For example, if the original {@code Observable<Observable<T>>} 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallelMerge.png">
-     * <p>
-     * This is a mechanism for efficiently processing <i>n</i> number of Observables on a smaller <i>m</i>
-     * number of resources (typically CPU cores).
-     * 
-     * @param parallelObservables
-     *            the number of Observables to merge into
-     * @param scheduler
-     *            the {@link Scheduler} to run each Observable on
-     * @return an Observable of Observables constrained in number by {@code parallelObservables}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-parallelmerge">RxJava Wiki: parallelMerge()</a>
-     */
-    public final static <T> Observable<Observable<T>> parallelMerge(Observable<Observable<T>> source, int parallelObservables, Scheduler scheduler) {
-        return OperatorParallelMerge.parallelMerge(source, parallelObservables, scheduler);
-    }
-
-    /**
-     * Pivot GroupedObservable streams without serializing/synchronizing to a single stream first.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/pivot.png">
-     *
-     * For example an Observable such as this =&gt;
-     * 
-     * {@code Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>>}:
-     * <ul>
-     * <li>o1.odd: 1, 3, 5, 7, 9 on Thread 1</li>
-     * <li>o1.even: 2, 4, 6, 8, 10 on Thread 1</li>
-     * <li>o2.odd: 11, 13, 15, 17, 19 on Thread 2</li>
-     * <li>o2.even: 12, 14, 16, 18, 20 on Thread 2</li>
-     * </ul>
-     * is pivoted to become this =&gt;
-     * 
-     * {@code Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>>}:
-     * <ul>
-     * <li>odd.o1: 1, 3, 5, 7, 9 on Thread 1</li>
-     * <li>odd.o2: 11, 13, 15, 17, 19 on Thread 2</li>
-     * <li>even.o1: 2, 4, 6, 8, 10 on Thread 1</li>
-     * <li>even.o2: 12, 14, 16, 18, 20 on Thread 2</li>
-     * </ul>
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/pivot.ex.png">
-     * 
-     * @param groups
-     * @return
-     */
-    public static final <K1, K2, T> Observable<GroupedObservable<K2, GroupedObservable<K1, T>>> pivot(Observable<GroupedObservable<K1, GroupedObservable<K2, T>>> groups) {
-        return groups.lift(new OperatorPivot<K1, K2, T>());
-    }
-
-    /**
-     * Returns an Observable that emits a sequence of Integers within a specified range.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/range.png">
-     * 
-     * @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
-     * @throws IllegalArgumentException
-     *             if {@code count} is less than zero
-     * @throws IllegalArgumentException
-     *             if {@code start} + {@code count} exceeds {@code Integer.MAX_VALUE}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-range">RxJava Wiki: range()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229460.aspx">MSDN: Observable.Range</a>
-     */
-    public final static Observable<Integer> range(int start, int count) {
-        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");
-        }
-        return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
-    }
-
-    /**
-     * Returns an Observable that emits a sequence of Integers within a specified range, on a specified
-     * Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/range.s.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-range">RxJava Wiki: range()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211896.aspx">MSDN: Observable.Range</a>
-     */
-    public final static Observable<Integer> range(int start, int count, Scheduler scheduler) {
-        return range(start, count).subscribeOn(scheduler);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sequenceEqual.png">
-     * 
-     * @param first
-     *            the first Observable to compare
-     * @param second
-     *            the second Observable to compare
-     * @param <T>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-sequenceequal">RxJava Wiki: sequenceEqual()</a>
-     */
-    public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second) {
-        return sequenceEqual(first, second, new Func2<T, T, Boolean>() {
-            @Override
-            public final Boolean call(T first, T second) {
-                if (first == null) {
-                    return second == null;
-                }
-                return first.equals(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sequenceEqual.png">
-     * 
-     * @param first
-     *            the first Observable to compare
-     * @param second
-     *            the second Observable to compare
-     * @param equality
-     *            a function used to compare items emitted by each Observable
-     * @param <T>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-sequenceequal">RxJava Wiki: sequenceEqual()</a>
-     */
-    public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
-        return OperatorSequenceEqual.sequenceEqual(first, second, equality);
-    }
-
-    /**
-     * Given an Observable that emits Observables, returns an Observable that emits the items emitted by the
-     * most recently emitted of those Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchDo.png">
-     * <p> {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-switchonnext">RxJava Wiki: switchOnNext()</a>
-     * 
-     * @param <T> the element type
-     */
-    public final static <T> Observable<T> switchOnNext(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
-        return sequenceOfSequences.lift(new OperatorSwitch<T>());
-    }
-
-    /**
-     * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after
-     * each {@code period} of time thereafter.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.p.png">
-     * 
-     * @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 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava Wiki: timer()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229435.aspx">MSDN: Observable.Timer</a>
-     */
-    public final static Observable<Long> timer(long initialDelay, long period, TimeUnit unit) {
-        return timer(initialDelay, period, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.ps.png">
-     * 
-     * @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 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 Scheduler
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava Wiki: timer()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229652.aspx">MSDN: Observable.Timer</a>
-     */
-    public final static Observable<Long> timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperatorTimerPeriodically(initialDelay, period, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that emits one item after a specified delay, and then completes.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.png">
-     * 
-     * @param delay
-     *            the initial delay before emitting a single 0L
-     * @param unit
-     *            time units to use for {@code delay}
-     * @return an Observable that emits one item after a specified delay, and then completes
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava wiki: timer()</a>
-     */
-    public final static Observable<Long> timer(long delay, TimeUnit unit) {
-        return timer(delay, unit, Schedulers.computation());
-    }
-
-    /**
-     * Returns an Observable that emits one item after a specified delay, on a specified Scheduler, and then
-     * completes.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.s.png">
-     * 
-     * @param delay
-     *            the initial delay before emitting a single 0L
-     * @param unit
-     *            time units to use for {@code delay}
-     * @param scheduler
-     *            the Scheduler to use for scheduling the item
-     * @return Observable that emits one item after a specified delay, on a specified Scheduler, and then
-     * completes
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava wiki: timer()</a>
-     */
-    public final static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) {
-        return create(new OperatorTimerOnce(delay, unit, scheduler));
-    }
-
-    /**
-     * Constructs an Observable that creates a dependent resource object.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/using.png">
-     * 
-     * @param resourceFactory
-     *            the factory function to create 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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-using">RxJava Wiki: using()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229585.aspx">MSDN: Observable.Using</a>
-     */
-    public final static <T, Resource extends Subscription> Observable<T> using(Func0<Resource> resourceFactory, Func1<Resource, ? extends Observable<? extends T>> observableFactory) {
-        return create(new OperatorUsing<T, Resource>(resourceFactory, observableFactory));
-    }
-
-    /**
-     * 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.
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * 
-     * @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
-     * @return an Observable that emits the zipped results
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<? extends R> zipFunction) {
-        List<Observable<?>> os = new ArrayList<Observable<?>>();
-        for (Observable<?> o : ws) {
-            os.add(o);
-        }
-        return Observable.just(os.toArray(new Observable<?>[os.size()])).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
-     * <i>n</i> items emitted, in sequence, by the <i>n</i> Observables emitted by a specified Observable.
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.o.png">
-     * 
-     * @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
-     * @return an Observable that emits the zipped results
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, final FuncN<? extends R> zipFunction) {
-        return ws.toList().map(new Func1<List<? extends Observable<?>>, Observable<?>[]>() {
-
-            @Override
-            public Observable<?>[] call(List<? extends Observable<?>> o) {
-                return o.toArray(new Observable<?>[o.size()]);
-            }
-
-        }).lift(new OperatorZip<R>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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
-     * @return an Observable that emits the zipped results
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, final Func2<? super T1, ? super T2, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2 }).lift(new OperatorZip<R>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2, o3 }).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
-     * four items emitted, in sequence, by four other Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2, o3, o4 }).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
-     * five items emitted, in sequence, by five other Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2, o3, o4, o5 }).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
-     * six items emitted, in sequence, by six other Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
-            Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6 }).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
-     * seven items emitted, in sequence, by seven other Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
-            Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7 }).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
-     * eight items emitted, in sequence, by eight other Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
-            Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8 }).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
-     * nine items emitted, in sequence, by nine other Observables.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * <p> {@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.
-     * <p>
-     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
-     */
-    public final static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
-            Observable<? extends T9> o9, Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> zipFunction) {
-        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8, o9 }).lift(new OperatorZip<R>(zipFunction));
-    }
-
-    /**
-     * Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source
-     * Observable satisfy a condition.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/all.png">
-     * 
-     * @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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-all">RxJava Wiki: all()</a>
-     */
-    public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
-        return lift(new OperatorAll<T>(predicate));
-    }
-
-    /**
-     * 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
-     */
-    public final Observable<T> asObservable() {
-        return lift(new OperatorAsObservable<T>());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer1.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final <TClosing> Observable<List<T>> buffer(Func0<? extends Observable<? extends TClosing>> bufferClosingSelector) {
-        return lift(new OperatorBufferWithSingleObservable<T, TClosing>(bufferClosingSelector, 16));
-    }
-
-    /**
-     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
-     * Observable emits connected, non-overlapping buffers, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer3.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(int count) {
-        return lift(new OperatorBufferWithSize<T>(count, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer4.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(int count, int skip) {
-        return lift(new OperatorBufferWithSize<T>(count, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer7.png">
-     * 
-     * @param timespan
-     *            the period of time each buffer collects items before it is 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 {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit) {
-        return lift(new OperatorBufferWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, Schedulers.computation()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer7.s.png">
-     * 
-     * @param timespan
-     *            the period of time each buffer collects items before it is 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 {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorBufferWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer5.png">
-     * 
-     * @param timespan
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(long timespan, TimeUnit unit) {
-        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, Schedulers.computation()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer6.png">
-     * 
-     * @param timespan
-     *            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)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count) {
-        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, count, Schedulers.computation()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer6.s.png">
-     * 
-     * @param timespan
-     *            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)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
-        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, count, scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer5.s.png">
-     * 
-     * @param timespan
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer2.png">
-     * 
-     * @param bufferOpenings
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final <TOpening, TClosing> Observable<List<T>> buffer(Observable<? extends TOpening> bufferOpenings, Func1<? super TOpening, ? extends Observable<? extends TClosing>> bufferClosingSelector) {
-        return lift(new OperatorBufferWithStartEndObservable<T, TOpening, TClosing>(bufferOpenings, bufferClosingSelector));
-    }
-
-    /**
-     * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the
-     * specified boundary Observable emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer8.png">
-     * <p>
-     * Completion of either the source or the boundary Observable causes the returned Observable to emit the
-     * latest buffer and complete.
-     * 
-     * @param <B>
-     *            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
-     * @see #buffer(rx.Observable, int)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     */
-    public final <B> Observable<List<T>> buffer(Observable<B> boundary) {
-        return lift(new OperatorBufferWithSingleObservable<T, B>(boundary, 16));
-    }
-
-    /**
-     * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the
-     * specified boundary Observable emits an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer8.png">
-     * <p>
-     * Completion of either the source or the boundary Observable causes the returned Observable to emit the
-     * latest buffer and complete.
-     * 
-     * @param <B>
-     *            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 from the source Observable when the boundary Observable
-     *         emits an item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
-     * @see #buffer(rx.Observable, int)
-     */
-    public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialCapacity) {
-        return lift(new OperatorBufferWithSingleObservable<T, B>(boundary, initialCapacity));
-    }
-
-    /**
-     * This method has similar behavior to {@link #replay} except that this auto-subscribes to the source
-     * Observable rather than returning a {@link ConnectableObservable}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/cache.png">
-     * <p>
-     * 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.
-     * <p>
-     * 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()}.
-     * <p>
-     *
-     * <!-- IS THE FOLLOWING NOTE STILL VALID??? -->
-     *
-     * <em>Note:</em> 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-cache">RxJava Wiki: cache()</a>
-     */
-    public final Observable<T> cache() {
-        return create(new OperatorCache<T>(this));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by the source Observable, converted to the specified
-     * type.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/cast.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-cast">RxJava Wiki: cast()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211842.aspx">MSDN: Observable.Cast</a>
-     */
-    public final <R> Observable<R> cast(final Class<R> klass) {
-        return lift(new OperatorCast<T, R>(klass));
-    }
-
-    /**
-     * Collect values into a single mutable data structure.
-     * <p>
-     * This is a simplified version of {@code reduce} that does not need to return the state on each pass.
-     * <p>
-     * 
-     * @param state
-     *            FIXME FIXME FIXME
-     * @param collector
-     *            FIXME FIXME FIXME
-     * @return FIXME FIXME FIXME
-     */
-    public final <R> Observable<R> collect(R state, final Action2<R, ? super T> collector) {
-        Func2<R, T, R> accumulator = new Func2<R, T, R>() {
-
-            @Override
-            public final R call(R state, T value) {
-                collector.call(state, value);
-                return state;
-            }
-
-        };
-        return reduce(state, accumulator);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concatMap.png">
-     * 
-     * @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
-     */
-    public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<? extends R>> func) {
-        return concat(map(func));
-    }
-
-    /**
-     * Returns an Observable that emits a Boolean that indicates whether the source Observable emitted a
-     * specified item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/contains.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-contains">RxJava Wiki: contains()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228965.aspx">MSDN: Observable.Contains</a>
-     */
-    public final Observable<Boolean> contains(final T element) {
-        return exists(new Func1<T, Boolean>() {
-            public final Boolean call(T t1) {
-                return element == null ? t1 == null : element.equals(t1);
-            }
-        });
-    }
-
-    /**
-     * Returns an Observable that emits the count of the total number of items emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/count.png">
-     * 
-     * @return an Observable that emits a single item: the number of elements emitted by the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-count-and-longcount">RxJava Wiki: count()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229470.aspx">MSDN: Observable.Count</a>
-     * @see #longCount()
-     */
-    public final Observable<Integer> count() {
-        return reduce(0, new Func2<Integer, T, Integer>() {
-            @Override
-            public final Integer call(Integer t1, T t2) {
-                return t1 + 1;
-            }
-        });
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/debounce.f.png">
-     * 
-     * @param <U>
-     *            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
-     */
-    public final <U> Observable<T> debounce(Func1<? super T, ? extends Observable<U>> debounceSelector) {
-        return lift(new OperatorDebounceWithSelector<T, U>(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.
-     * <p>
-     * <em>Note:</em> If items keep being emitted by the source Observable faster than the timeout then no items
-     * will be emitted by the resulting Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/debounce.png">
-     * <p>
-     * Information on debounce vs throttle:
-     * <p>
-     * <ul>
-     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
-     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
-     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
-     * </ul>
-     * 
-     * @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
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: debounce()</a>
-     * @see #throttleWithTimeout(long, TimeUnit)
-     */
-    public final Observable<T> debounce(long timeout, TimeUnit unit) {
-        return lift(new OperatorDebounceWithTime<T>(timeout, unit, Schedulers.computation()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <em>Note:</em> If items keep being emitted by the source Observable faster than the timeout then no items
-     * will be emitted by the resulting Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/debounce.s.png">
-     * <p>
-     * Information on debounce vs throttle:
-     * <p>
-     * <ul>
-     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
-     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
-     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
-     * </ul>
-     * 
-     * @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
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: debounce()</a>
-     * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
-     */
-    public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorDebounceWithTime<T>(timeout, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that emits the items emitted by the source Observable or a specified default item
-     * if the source Observable is empty.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/defaultIfEmpty.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-defaultifempty">RxJava Wiki: defaultIfEmpty()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229624.aspx">MSDN: Observable.DefaultIfEmpty</a>
-     */
-    public final Observable<T> defaultIfEmpty(T defaultValue) {
-        return lift(new OperatorDefaultIfEmpty<T>(defaultValue));
-    }
-
-    /**
-     * Returns an Observable that delays the subscription to and emissions from the souce Observable via another
-     * Observable on a per-item basis.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.oo.png">
-     * <p>
-     * <em>Note:</em> the resulting Observable will immediately propagate any {@code onError} notification
-     * from the source Observable.
-     * 
-     * @param <U>
-     *            the subscription delay value type (ignored)
-     * @param <V>
-     *            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
-     * @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
-     */
-    public final <U, V> Observable<T> delay(
-            Func0<? extends Observable<U>> subscriptionDelay,
-            Func1<? super T, ? extends Observable<V>> itemDelay) {
-        return create(OperationDelay.delay(this, subscriptionDelay, itemDelay));
-    }
-
-    /**
-     * Returns an Observable that delays the emissions of the source Observable via another Observable on a
-     * per-item basis.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.o.png">
-     * <p>
-     * <em>Note:</em> the resulting Observable will immediately propagate any {@code onError} notification
-     * from the source Observable.
-     * 
-     * @param <U>
-     *            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
-     */
-    public final <U> Observable<T> delay(Func1<? super T, ? extends Observable<U>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.png">
-     * 
-     * @param delay
-     *            the delay to shift the source by
-     * @param unit
-     *            the {@link TimeUnit} in which {@code period} is defined
-     * @return the source Observable shifted in time by the specified delay
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-delay">RxJava Wiki: delay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229810.aspx">MSDN: Observable.Delay</a>
-     */
-    public final Observable<T> delay(long delay, TimeUnit unit) {
-        return OperationDelay.delay(this, delay, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.s.png">
-     * 
-     * @param delay
-     *            the delay to shift the source by
-     * @param unit
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-delay">RxJava Wiki: delay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229280.aspx">MSDN: Observable.Delay</a>
-     */
-    public final Observable<T> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delaySubscription.png">
-     * 
-     * @param delay
-     *            the time to delay the subscription
-     * @param unit
-     *            the time unit of {@code delay}
-     * @return an Observable that delays the subscription to the source Observable by the given amount
-     */
-    public final Observable<T> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delaySubscription.s.png">
-     * 
-     * @param delay
-     *            the time to delay the subscription
-     * @param unit
-     *            the time unit of {@code delay}
-     * @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 final Observable<T> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/dematerialize.png">
-     * 
-     * @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<Notification<T>>}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dematerialize">RxJava Wiki: dematerialize()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229047.aspx">MSDN: Observable.dematerialize</a>
-     */
-    @SuppressWarnings({"unchecked", "rawtypes"})
-    public final <T2> Observable<T2> dematerialize() {
-        return lift(new OperatorDematerialize());
-    }
-
-    /**
-     * Returns an Observable that emits all items emitted by the source Observable that are distinct.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinct.png">
-     * 
-     * @return an Observable that emits only those items emitted by the source Observable that are distinct from
-     *         each other
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinct">RxJava Wiki: distinct()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229764.aspx">MSDN: Observable.distinct</a>
-     */
-    public final Observable<T> distinct() {
-        return lift(new OperatorDistinct<T, T>(Functions.<T>identity()));
-    }
-
-    /**
-     * Returns an Observable that emits all items emitted by the source Observable that are distinct according
-     * to a key selector function.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinct.key.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinct">RxJava Wiki: distinct()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244310.aspx">MSDN: Observable.distinct</a>
-     */
-    public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelector) {
-        return lift(new OperatorDistinct<T, U>(keySelector));
-    }
-
-    /**
-     * Returns an Observable that emits all items emitted by the source Observable that are distinct from their
-     * immediate predecessors.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinctUntilChanged.png">
-     * 
-     * @return an Observable that emits those items from the source Observable that are distinct from their
-     *         immediate predecessors
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinctuntilchanged">RxJava Wiki: distinctUntilChanged()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229494.aspx">MSDN: Observable.distinctUntilChanged</a>
-     */
-    public final Observable<T> distinctUntilChanged() {
-        return lift(new OperatorDistinctUntilChanged<T, T>(Functions.<T>identity()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinctUntilChanged.key.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinctuntilchanged">RxJava Wiki: distinctUntilChanged()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229508.aspx">MSDN: Observable.distinctUntilChanged</a>
-     */
-    public final <U> Observable<T> distinctUntilChanged(Func1<? super T, ? extends U> keySelector) {
-        return lift(new OperatorDistinctUntilChanged<T, U>(keySelector));
-    }
-
-    /**
-     * Modifies an Observable so that it invokes an action when it calls {@code onCompleted}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnCompleted.png">
-     * 
-     * @param onCompleted
-     *            the action to invoke when the source Observable calls {@code onCompleted}
-     * @return the source Observable with the side-effecting behavior applied
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooncompleted">RxJava Wiki: doOnCompleted()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
-     */
-    public final Observable<T> doOnCompleted(final Action0 onCompleted) {
-        Observer<T> observer = new Observer<T>() {
-            @Override
-            public final void onCompleted() {
-                onCompleted.call();
-            }
-
-            @Override
-            public final void onError(Throwable e) {
-            }
-
-            @Override
-            public final void onNext(T args) {
-            }
-
-        };
-
-        return lift(new OperatorDoOnEach<T>(observer));
-    }
-
-    /**
-     * Modifies an Observable so that it invokes an action for each item it emits.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnEach.png">
-     * 
-     * @param onNotification
-     *            the action to invoke for each item emitted by the source Observable
-     * @return the source Observable with the side-effecting behavior applied
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooneach">RxJava Wiki: doOnEach()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229307.aspx">MSDN: Observable.Do</a>
-     */
-    public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNotification) {
-        Observer<T> observer = new Observer<T>() {
-            @Override
-            public final void onCompleted() {
-                onNotification.call(Notification.createOnCompleted());
-            }
-
-            @Override
-            public final void onError(Throwable e) {
-                onNotification.call(Notification.createOnError(e));
-            }
-
-            @Override
-            public final void onNext(T v) {
-                onNotification.call(Notification.createOnNext(v));
-            }
-
-        };
-
-        return lift(new OperatorDoOnEach<T>(observer));
-    }
-
-    /**
-     * Modifies an Observable so that it notifies an Observer for each item it emits.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnEach.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooneach">RxJava Wiki: doOnEach()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229307.aspx">MSDN: Observable.Do</a>
-     */
-    public final Observable<T> doOnEach(Observer<? super T> observer) {
-        return lift(new OperatorDoOnEach<T>(observer));
-    }
-
-    /**
-     * Modifies an Observable so that it invokes an action if it calls {@code onError}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnError.png">
-     * 
-     * @param onError
-     *            the action to invoke if the source Observable calls {@code onError}
-     * @return the source Observable with the side-effecting behavior applied
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-doonerror">RxJava Wiki: doOnError()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
-     */
-    public final Observable<T> doOnError(final Action1<Throwable> onError) {
-        Observer<T> observer = new Observer<T>() {
-            @Override
-            public final void onCompleted() {
-            }
-
-            @Override
-            public final void onError(Throwable e) {
-                onError.call(e);
-            }
-
-            @Override
-            public final void onNext(T args) {
-            }
-
-        };
-
-        return lift(new OperatorDoOnEach<T>(observer));
-    }
-
-    /**
-     * Modifies an Observable so that it invokes an action when it calls {@code onNext}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnNext.png">
-     * 
-     * @param onNext
-     *            the action to invoke when the source Observable calls {@code onNext}
-     * @return the source Observable with the side-effecting behavior applied
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooneach">RxJava Wiki: doOnNext()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
-     */
-    public final Observable<T> doOnNext(final Action1<? super T> onNext) {
-        Observer<T> observer = new Observer<T>() {
-            @Override
-            public final void onCompleted() {
-            }
-
-            @Override
-            public final void onError(Throwable e) {
-            }
-
-            @Override
-            public final void onNext(T args) {
-                onNext.call(args);
-            }
-
-        };
-
-        return lift(new OperatorDoOnEach<T>(observer));
-    }
-
-    /**
-     * Modifies an Observable so that it invokes an action when it calls {@code onCompleted} or {@code onError}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnTerminate.png">
-     * <p>
-     * This differs from {@code finallyDo} in that this happens BEFORE onCompleted/onError are emitted.
-     * 
-     * @param onTerminate
-     *            the action to invoke when the source Observable calls {@code onCompleted} or {@code onError}
-     * @return the source Observable with the side-effecting behavior applied
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-doonterminate">RxJava Wiki: doOnTerminate()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
-     */
-    public final Observable<T> doOnTerminate(final Action0 onTerminate) {
-        Observer<T> observer = new Observer<T>() {
-            @Override
-            public final void onCompleted() {
-                onTerminate.call();
-            }
-
-            @Override
-            public final void onError(Throwable e) {
-                onTerminate.call();
-            }
-
-            @Override
-            public final void onNext(T args) {
-            }
-
-        };
-
-        return lift(new OperatorDoOnEach<T>(observer));
-    }
-
-    /**
-     * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
-     * source Observbable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAt.png">
-     * 
-     * @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
-     * @throws IndexOutOfBoundsException
-     *             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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementat">RxJava Wiki: elementAt()</a>
-     */
-    public final Observable<T> elementAt(int index) {
-        return lift(new OperatorElementAt<T>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAtOrDefault.png">
-     * 
-     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementatordefault">RxJava Wiki: elementAtOrDefault()</a>
-     */
-    public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
-        return lift(new OperatorElementAt<T>(index, defaultValue));
-    }
-
-    /**
-     * Returns an Observable that emits {@code true} if any item emitted by the source Observable satisfies a
-     * specified condition, otherwise {@code false}. <em>Note:</em> this always emits {@code false} if the
-     * source Observable is empty.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/exists.png">
-     * <p>
-     * 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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-exists-and-isempty">RxJava Wiki: exists()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211993.aspx">MSDN: Observable.Any (Note: the description in this page was wrong at the time of this writing)</a>
-     */
-    public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
-        return lift(new OperatorAny<T>(predicate, false));
-    }
-
-    /**
-     * Filter items emitted by an Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/filter.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-filter-or-where">RxJava Wiki: filter()</a>
-     */
-    public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
-        return lift(new OperatorFilter<T>(predicate));
-    }
-
-    /**
-     * Registers an {@link Action0} to be called when this Observable invokes either {@link Observer#onCompleted onCompleted} or {@link Observer#onError onError}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/finallyDo.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-finallydo">RxJava Wiki: finallyDo()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212133.aspx">MSDN: Observable.Finally</a>
-     */
-    public final Observable<T> finallyDo(Action0 action) {
-        return lift(new OperatorFinally<T>(action));
-    }
-
-    /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable, or raises an {@code NoSuchElementException} if the source Observable is empty.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
-     * 
-     * @return an Observable that emits only the very first item emitted by the source Observable, or raises an {@code NoSuchElementException} if the source Observable is empty
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see "MSDN: Observable.firstAsync()"
-     */
-    public final Observable<T> first() {
-        return take(1).single();
-    }
-
-    /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
-     * a specified condition, or raises an {@code NoSuchElementException} if no such items are emitted.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/firstN.png">
-     * 
-     * @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 NoSuchElementException} if no such items are emitted
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see "MSDN: Observable.firstAsync()"
-     */
-    public final Observable<T> first(Func1<? super T, Boolean> predicate) {
-        return takeFirst(predicate).single();
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/firstOrDefault.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-firstordefault">RxJava Wiki: firstOrDefault()</a>
-     * @see "MSDN: Observable.firstOrDefaultAsync()"
-     */
-    public final Observable<T> 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 specified condition, or a default item if the source Observable emits no such items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/firstOrDefaultN.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-firstordefault">RxJava Wiki: firstOrDefault()</a>
-     * @see "MSDN: Observable.firstOrDefaultAsync()"
-     */
-    public final Observable<T> firstOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
-        return takeFirst(predicate).singleOrDefault(defaultValue);
-    }
-
-    /**
-     * Returns an Observable that emits items based on 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/flatMap.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-mapmany-or-flatmap-and-mapmanydelayerror">RxJava Wiki: flatMap()</a>
-     */
-    public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupBy.png">
-     * 
-     * @param keySelector
-     *            a function that extracts the key for each item
-     * @param <K>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-groupby-and-groupbyuntil">RxJava Wiki: groupBy</a>
-     */
-    public final <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorGroupBy<K, T>(keySelector));
-    }
-
-    /**
-     * Groups the items emitted by an Observable according to a specified key selector function until the
-     * duration Observable expires for the key.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupByUntil.png">
-     * 
-     * @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 {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-groupby-and-groupbyuntil">RxJava Wiki: groupByUntil()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211932.aspx">MSDN: Observable.GroupByUntil</a>
-     */
-    public final <TKey, TDuration> Observable<GroupedObservable<TKey, T>> groupByUntil(Func1<? super T, ? extends TKey> keySelector, Func1<? super GroupedObservable<TKey, T>, ? extends Observable<? extends TDuration>> durationSelector) {
-        return groupByUntil(keySelector, Functions.<T> identity(), durationSelector);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupByUntil.png">
-     * 
-     * @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
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-groupby-and-groupbyuntil">RxJava Wiki: groupByUntil()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229433.aspx">MSDN: Observable.GroupByUntil</a>
-     */
-    public final <TKey, TValue, TDuration> Observable<GroupedObservable<TKey, TValue>> groupByUntil(Func1<? super T, ? extends TKey> keySelector, Func1<? super T, ? extends TValue> valueSelector, Func1<? super GroupedObservable<TKey, TValue>, ? extends Observable<? extends TDuration>> durationSelector) {
-        return lift(new OperatorGroupByUntil<T, TKey, TValue, TDuration>(keySelector, valueSelector, durationSelector));
-    }
-
-    /**
-     * Return an Observable that correlates two Observables when they overlap in time and groups the results.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupJoin.png">
-     * 
-     * @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
-     * @param rightDuration
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-join-and-groupjoin">RxJava Wiiki: groupJoin</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244235.aspx">MSDN: Observable.GroupJoin</a>
-     */
-    public final <T2, D1, D2, R> Observable<R> groupJoin(Observable<T2> right, Func1<? super T, ? extends Observable<D1>> leftDuration,
-            Func1<? super T2, ? extends Observable<D2>> rightDuration,
-            Func2<? super T, ? super Observable<T2>, ? extends R> resultSelector) {
-        return create(new OperatorGroupJoin<T, T2, D1, D2, R>(this, right, leftDuration, rightDuration, resultSelector));
-    }
-
-    /**
-     * Ignores all items emitted by the source Observable and only calls {@code onCompleted} or {@code onError}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/ignoreElements.png">
-     * 
-     * @return an empty Observable that only calls {@code onCompleted} or {@code onError}, based on which one is
-     *         called by the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-ignoreelements">RxJava Wiki: ignoreElements()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229242.aspx">MSDN: Observable.IgnoreElements</a>
-     */
-    public final Observable<T> ignoreElements() {
-        return filter(alwaysFalse());
-    }
-
-    /**
-     * Returns an Observable that emits {@code true} if the source Observable is empty, otherwise {@code false}.
-     * <p>
-     * In Rx.Net this is negated as the {@code any} Observer but we renamed this in RxJava to better match Java
-     * naming idioms.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/isEmpty.png">
-     * 
-     * @return an Observable that emits a Boolean
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-exists-and-isempty">RxJava Wiki: isEmpty()</a>
-     * @see <a href= "http://msdn.microsoft.com/en-us/library/hh229905.aspx">MSDN: Observable.Any</a>
-     */
-    public final Observable<Boolean> isEmpty() {
-        return lift(new OperatorAny<T>(Functions.alwaysTrue(), true));
-    }
-
-    /**
-     * Correlates the items emitted by two Observables based on overlapping durations.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/join_.png">
-     * 
-     * @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
-     * @param rightDurationSelector
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-join">RxJava Wiki: join()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229750.aspx">MSDN: Observable.Join</a>
-     */
-    public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> join(Observable<TRight> right, Func1<T, Observable<TLeftDuration>> leftDurationSelector,
-            Func1<TRight, Observable<TRightDuration>> rightDurationSelector,
-            Func2<T, TRight, R> resultSelector) {
-        return create(new OperatorJoin<T, TRight, TLeftDuration, TRightDuration, R>(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
-    }
-
-    /**
-     * Returns an Observable that emits the last item emitted by the source Observable or notifies observers of
-     * an {@code NoSuchElementException} if the source Observable is empty.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.png">
-     * 
-     * @return an Observable that emits the last item from the source Observable or notifies observers of an
-     *         error
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
-     * @see "MSDN: Observable.lastAsync()"
-     */
-    public final Observable<T> last() {
-        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 {@code NoSuchElementException} if no such items are emitted.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.p.png">
-     * 
-     * @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 NoSuchElementException} if no such items are emitted
-     * @throws IllegalArgumentException
-     *             if no items that match the predicate are emitted by the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
-     * @see "MSDN: Observable.lastAsync()"
-     */
-    public final Observable<T> last(Func1<? super T, Boolean> 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 Observable completes without emitting any items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/lastOrDefault.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-lastOrDefault">RxJava Wiki: lastOrDefault()</a>
-     * @see "MSDN: Observable.lastOrDefaultAsync()"
-     */
-    public final Observable<T> 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
-     * specified condition, or a default item if no such item is emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/lastOrDefault.p.png">
-     * 
-     * @param defaultValue
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-lastOrDefault">RxJava Wiki: lastOrDefault()</a>
-     * @see "MSDN: Observable.lastOrDefaultAsync()"
-     */
-    public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
-        return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
-    }
-
-    /**
-     * Returns an Observable that counts the total number of items emitted by the source Observable and emits
-     * this count as a 64-bit Long.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/longCount.png">
-     * 
-     * @return an Observable that emits a single item: the number of items emitted by the source Observable as a
-     *         64-bit Long item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-count-and-longcount">RxJava Wiki: count()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229120.aspx">MSDN: Observable.LongCount</a>
-     * @see #count()
-     */
-    public final Observable<Long> longCount() {
-        return reduce(0L, new Func2<Long, T, Long>() {
-            @Override
-            public final Long call(Long t1, T t2) {
-                return t1 + 1;
-            }
-        });
-    }
-
-    /**
-     * Returns an Observable that applies a specified function to each item emitted by the source Observable and
-     * emits the results of these function applications.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/map.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-map">RxJava Wiki: map()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244306.aspx">MSDN: Observable.Select</a>
-     */
-    public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
-        return lift(new OperatorMap<T, R>(func));
-    }
-
-    /**
-     * Turns all of the emissions and notifications from a source Observable into emissions marked with their
-     * original types within {@link Notification} objects.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/materialize.png">
-     * 
-     * @return an Observable that emits items that are the result of materializing the items and notifications
-     *         of the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-materialize">RxJava Wiki: materialize()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229453.aspx">MSDN: Observable.materialize</a>
-     */
-    public final Observable<Notification<T>> materialize() {
-        return lift(new OperatorMaterialize<T>());
-    }
-
-    /**
-     * Returns an Observable that emits the results of applying a specified function 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMap.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-mapmany-or-flatmap-and-mapmanydelayerror">RxJava Wiki: flatMap()</a>
-     * @see #flatMap(Func1)
-     */
-    public final <R> Observable<R> mergeMap(Func1<? super T, ? extends Observable<? extends R>> func) {
-        return merge(map(func));
-    }
-
-    /**
-     * Returns an Observable that applies a function to each item emitted or notification raised by the source
-     * Observable and then flattens the Observables returned from these functions and emits the resulting items.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMap.nce.png">
-     * 
-     * @param <R>
-     *            the result type
-     * @param onNext
-     *            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
-     * @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
-     */
-    public final <R> Observable<R> mergeMap(
-            Func1<? super T, ? extends Observable<? extends R>> onNext,
-            Func1<? super Throwable, ? extends Observable<? extends R>> onError,
-            Func0<? extends Observable<? extends R>> onCompleted) {
-        return lift(new OperatorMergeMapTransform<T, R>(onNext, onError, onCompleted));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMap.r.png">
-     * 
-     * @param <U>
-     *            the type of items emitted by the collection Observable
-     * @param <R>
-     *            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
-     * @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
-     */
-    public final <U, R> Observable<R> mergeMap(Func1<? super T, ? extends Observable<? extends U>> collectionSelector,
-            Func2<? super T, ? super U, ? extends R> resultSelector) {
-        return lift(new OperatorMergeMapPair<T, U, R>(collectionSelector, resultSelector));
-    }
-
-    /**
-     * Returns an Observable that merges each item emitted by the source Observable with the values in an
-     * Iterable corresponding to that item that is generated by a selector.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMapIterable.png">
-     * 
-     * @param <R>
-     *            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}
-     */
-    public final <R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector) {
-        return merge(map(OperatorMergeMapPair.convertSelector(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMapIterable.r.png">
-     * 
-     * @param <U>
-     *            the collection element type
-     * @param <R>
-     *            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
-     * @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
-     */
-    public final <U, R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Iterable<? extends U>> collectionSelector,
-            Func2<? super T, ? super U, ? extends R> resultSelector) {
-        return mergeMap(OperatorMergeMapPair.convertSelector(collectionSelector), resultSelector);
-    }
-
-    /**
-     * Returns an Observable that emits items produced by multicasting the source Observable within a selector
-     * function.
-     * 
-     * @param subjectFactory
-     *            the {@link Subject} factory
-     * @param selector
-     *            the selector function, which can use the multicasted source Observable subject to the policies
-     *            enforced by the created {@code Subject}
-     * @return an Observable that emits the items produced by multicasting the source Observable within a
-     *         selector function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava: Observable.publish() and Observable.multicast()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229708.aspx">MSDN: Observable.Multicast</a>
-     */
-    public final <TIntermediate, TResult> Observable<TResult> multicast(
-            final Func0<? extends Subject<? super T, ? extends TIntermediate>> subjectFactory,
-            final Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> selector) {
-        return create(new OperatorMulticastSelector<T, TIntermediate, TResult>(this, subjectFactory, selector));
-    }
-
-    /**
-     * 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 <R>
-     *            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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: Observable.publish() and
-     *      Observable.multicast()</a>
-     */
-    public final <R> ConnectableObservable<R> multicast(Subject<? super T, ? extends R> subject) {
-        return new OperatorMulticast<T, R>(this, subject);
-    }
-
-    /**
-     * Move notifications to the specified {@link Scheduler} asynchronously with an unbounded buffer.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/observeOn.png">
-     * 
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-observeon">RxJava Wiki: observeOn()</a>
-     */
-    public final Observable<T> observeOn(Scheduler scheduler) {
-        return lift(new OperatorObserveOn<T>(scheduler));
-    }
-
-    /**
-     * Filters the items emitted by an Observable, only emitting those of the specified type.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/ofClass.png">
-     * 
-     * @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 {@code klass}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-oftype">RxJava Wiki: ofType()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229380.aspx">MSDN: Observable.OfType</a>
-     */
-    public final <R> Observable<R> ofType(final Class<R> klass) {
-        return filter(new Func1<T, Boolean>() {
-            public final Boolean call(T t) {
-                return klass.isInstance(t);
-            }
-        }).cast(klass);
-    }
-
-    /**
-     * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorResumeNext.png">
-     * <p>
-     * 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.
-     * <p>
-     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorresumenext">RxJava Wiki: onErrorResumeNext()</a>
-     */
-    public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
-        return lift(new OperatorOnErrorResumeNextViaFunction<T>(resumeFunction));
-    }
-
-    /**
-     * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorResumeNext.png">
-     * <p>
-     * 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.
-     * <p>
-     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorresumenext">RxJava Wiki: onErrorResumeNext()</a>
-     */
-    public final Observable<T> onErrorResumeNext(final Observable<? extends T> resumeSequence) {
-        return lift(new OperatorOnErrorResumeNextViaObservable<T>(resumeSequence));
-    }
-
-    /**
-     * Instruct an Observable to emit an item (returned by a specified function) rather than invoking {@link Observer#onError onError} if it encounters an error.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorReturn.png">
-     * <p>
-     * 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}.
-     * <p>
-     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorreturn">RxJava Wiki: onErrorReturn()</a>
-     */
-    public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
-        return lift(new OperatorOnErrorReturn<T>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorFlatMap.png">
-     *
-     * @param resumeFunction
-     *            a function that accepts an {@link OnErrorThrowable} representing the Throwable issued by the
-     *            source Observable, and returns an Observable that issues items that will be emitted in place
-     *            of the error
-     * @return the original Observable, with appropriately modified behavior
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#onerrorflatmap">RxJava Wiki: onErrorFlatMap()</a>
-     */
-    public final Observable<T> onErrorFlatMap(final Func1<OnErrorThrowable, ? extends Observable<? extends T>> resumeFunction) {
-        return lift(new OperatorOnErrorFlatMap<T>(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}.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onExceptionResumeNextViaObservable.png">
-     * <p>
-     * 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.
-     * <p>
-     * 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
-     * @return the original Observable, with appropriately modified behavior
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onexceptionresumenext">RxJava Wiki: onExceptionResumeNext()</a>
-     */
-    public final Observable<T> onExceptionResumeNext(final Observable<? extends T> resumeSequence) {
-        return lift(new OperatorOnExceptionResumeNextViaObservable<T>(resumeSequence));
-    }
-
-    /**
-     * Perform work on the source {@code Observable<T>} in parallel by sharding it on a {@link Schedulers#computation()} {@link Scheduler}, and return the resulting {@code Observable<R>}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallel.png">
-     * 
-     * @param f
-     *            a {@link Func1} that applies Observable Observers to {@code Observable<T>} in parallel and
-     *            returns an {@code Observable<R>}
-     * @return an Observable that emits the results of applying {@code f} to the items emitted by the source
-     *         Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-parallel">RxJava Wiki: parallel()</a>
-     */
-    public final <R> Observable<R> parallel(Func1<Observable<T>, Observable<R>> f) {
-        return lift(new OperatorParallel<T, R>(f, Schedulers.computation()));
-    }
-
-    /**
-     * Perform work on the source {@code Observable<T>} in parallel by sharding it on a {@link Scheduler}, and
-     * return the resulting {@code Observable<R>}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallel.png">
-     * 
-     * @param f
-     *            a {@link Func1} that applies Observable Observers to {@code Observable<T>} in parallel and
-     *            returns an {@code Observable<R>}
-     * @param s
-     *            a {@link Scheduler} to perform the work on
-     * @return an Observable that emits the results of applying {@code f} to the items emitted by the source
-     *         Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-parallel">RxJava Wiki: parallel()</a>
-     */
-    public final <R> Observable<R> parallel(final Func1<Observable<T>, Observable<R>> f, final Scheduler s) {
-        return lift(new OperatorParallel<T, R>(f, s));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.png">
-     * 
-     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit items
-     *         to its {@link Observer}s
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: publish()</a>
-     */
-    public final ConnectableObservable<T> publish() {
-        return new OperatorMulticast<T, T>(this, PublishSubject.<T> create());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.f.png">
-     * 
-     * @param <R>
-     *            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
-     */
-    public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
-        return multicast(new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return PublishSubject.create();
-            }
-        }, selector);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.if.png">
-     * 
-     * @param <R>
-     *            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
-     * @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 {@link ConnectableObservable} that shares a single subscription to the underlying Observable
-     */
-    public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Observable<R>> selector, final T initialValue) {
-        return multicast(new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return BehaviorSubject.create(initialValue);
-            }
-        }, selector);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.i.png">
-     * 
-     * @param 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<T> publish(T initialValue) {
-        return new OperatorMulticast<T, T>(this, BehaviorSubject.<T> create(initialValue));
-    }
-
-    /**
-     * Returns a {@link ConnectableObservable} that emits only the last item emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishLast.png">
-     * 
-     * @return a {@link ConnectableObservable} that emits only the last item emitted by the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublishlast">RxJava Wiki: publishLast()</a>
-     */
-    public final ConnectableObservable<T> publishLast() {
-        return new OperatorMulticast<T, T>(this, AsyncSubject.<T> create());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishLast.f.png">
-     * 
-     * @param <R>
-     *            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 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 <R> Observable<R> publishLast(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
-        return multicast(new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/reduce.png">
-     * <p>
-     * 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
-     * @throws IllegalArgumentException
-     *             if the source Observable emits no items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-reduce">RxJava Wiki: reduce()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229154.aspx">MSDN: Observable.Aggregate</a>
-     * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
-     */
-    public final Observable<T> reduce(Func2<T, T, T> 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 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/reduceSeed.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-reduce">RxJava Wiki: reduce()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229154.aspx">MSDN: Observable.Aggregate</a>
-     * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
-     */
-    public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> accumulator) {
-        return scan(initialValue, accumulator).takeLast(1);
-    }
-
-    /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.o.png">
-     * 
-     * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
-     */
-    public final Observable<T> repeat() {
-        return nest().lift(new OperatorRepeat<T>());
-    }
-
-    /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely,
-     * on a particular Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.os.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
-     */
-    public final Observable<T> repeat(Scheduler scheduler) {
-        return nest().lift(new OperatorRepeat<T>(scheduler));
-    }
-
-    /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most {@code count} times.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.on.png">
-     * 
-     * @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
-     * @throws IllegalArgumentException
-     *             if {@code count} is less than zero
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
-     */
-    public final Observable<T> repeat(long count) {
-        if (count < 0) {
-            throw new IllegalArgumentException("count >= 0 expected");
-        }
-        return nest().lift(new OperatorRepeat<T>(count));
-    }
-
-    /**
-     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most {@code count} times, on a particular Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.ons.png">
-     * 
-     * @param count
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
-     */
-    public final Observable<T> repeat(long count, Scheduler scheduler) {
-        return nest().lift(new OperatorRepeat<T>(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}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.png">
-     * 
-     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit its
-     *         items to its {@link Observer}s
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     */
-    public final ConnectableObservable<T> replay() {
-        return new OperatorMulticast<T, T>(this, ReplaySubject.<T> create());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.f.png">
-     * 
-     * @param <R>
-     *            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 source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229653.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
-        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return ReplaySubject.create();
-            }
-        }, selector));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fn.png">
-     * 
-     * @param <R>
-     *            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
-     * @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 source Observable
-     *         replaying no more than {@code bufferSize} items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211675.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize) {
-        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return OperatorReplay.replayBuffered(bufferSize);
-            }
-        }, selector));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fnt.png">
-     * 
-     * @param <R>
-     *            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
-     * @param bufferSize
-     *            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 source Observable, and
-     *         replays no more than {@code bufferSize} items that were emitted within the window defined by {@code time}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228952.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, int bufferSize, long time, TimeUnit unit) {
-        return replay(selector, bufferSize, time, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fnts.png">
-     * 
-     * @param <R>
-     *            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
-     * @param bufferSize
-     *            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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229404.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
-        if (bufferSize < 0) {
-            throw new IllegalArgumentException("bufferSize < 0");
-        }
-        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return OperatorReplay.replayWindowed(time, unit, bufferSize, scheduler);
-            }
-        }, selector));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fns.png">
-     * 
-     * @param <R>
-     *            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
-     * @param bufferSize
-     *            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 source Observable,
-     *         replaying no more than {@code bufferSize} notifications
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229928.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize, final Scheduler scheduler) {
-        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return OperatorReplay.<T> createScheduledSubject(OperatorReplay.<T> replayBuffered(bufferSize), scheduler);
-            }
-        }, selector));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ft.png">
-     * 
-     * @param <R>
-     *            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
-     * @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 source Observable,
-     *         replaying all items that were emitted within the window defined by {@code time}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229526.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, long time, TimeUnit unit) {
-        return replay(selector, time, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fts.png">
-     * 
-     * @param <R>
-     *            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
-     * @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 source Observable,
-     *         replaying all items that were emitted within the window defined by {@code time}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244327.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final long time, final TimeUnit unit, final Scheduler scheduler) {
-        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return OperatorReplay.replayWindowed(time, unit, -1, scheduler);
-            }
-        }, selector));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fs.png">
-     * 
-     * @param <R>
-     *            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
-     * @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 source Observable,
-     *         replaying all items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211644.aspx">MSDN: Observable.Replay</a>
-     */
-    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final Scheduler scheduler) {
-        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
-            @Override
-            public final Subject<T, T> call() {
-                return OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler);
-            }
-        }, selector));
-    }
-
-    /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable that
-     * replays at most {@code bufferSize} items emitted by that Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.n.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211976.aspx">MSDN: Observable.Replay</a>
-     */
-    public final ConnectableObservable<T> replay(int bufferSize) {
-        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayBuffered(bufferSize));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nt.png">
-     * 
-     * @param bufferSize
-     *            the buffer size that limits the number of items that can be replayed
-     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229874.aspx">MSDN: Observable.Replay</a>
-     */
-    public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit unit) {
-        return replay(bufferSize, time, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nts.png">
-     * 
-     * @param bufferSize
-     *            the buffer size that limits the number of items that can be replayed
-     * @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 used as a time source for the window
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211759.aspx">MSDN: Observable.Replay</a>
-     */
-    public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) {
-        if (bufferSize < 0) {
-            throw new IllegalArgumentException("bufferSize < 0");
-        }
-        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, bufferSize, scheduler));
-    }
-
-    /**
-     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
-     * replays at most {@code bufferSize} items emitted by that Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ns.png">
-     * 
-     * @param bufferSize
-     *            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 source Observable and
-     *         replays at most {@code bufferSize} items that were emitted by the Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229814.aspx">MSDN: Observable.Replay</a>
-     */
-    public final ConnectableObservable<T> replay(int bufferSize, Scheduler scheduler) {
-        return new OperatorMulticast<T, T>(this,
-                OperatorReplay.createScheduledSubject(
-                        OperatorReplay.<T> replayBuffered(bufferSize), 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.t.png">
-     * 
-     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229232.aspx">MSDN: Observable.Replay</a>
-     */
-    public final ConnectableObservable<T> replay(long time, TimeUnit unit) {
-        return replay(time, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ts.png">
-     * 
-     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211811.aspx">MSDN: Observable.Replay</a>
-     */
-    public final ConnectableObservable<T> replay(long time, TimeUnit unit, Scheduler scheduler) {
-        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, -1, 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}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.s.png">
-     * 
-     * @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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211699.aspx">MSDN: Observable.Replay</a>
-     */
-    public final ConnectableObservable<T> replay(Scheduler scheduler) {
-        return new OperatorMulticast<T, T>(this, OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler));
-    }
-
-    /**
-     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} (infinite retry count).
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/retry.png">
-     * <p>
-     * If the source Observable calls {@link Observer#onError}, this method will resubscribe to the source
-     * Observable rather than propagating the {@code onError} call.
-     * <p>
-     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-retry">RxJava Wiki: retry()</a>
-     */
-    public final Observable<T> retry() {
-        return nest().lift(new OperatorRetry<T>());
-    }
-
-    /**
-     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} up to a specified number of retries.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/retry.png">
-     * <p>
-     * 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.
-     * <p>
-     * 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
-     * @return the source Observable modified with retry logic
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-retry">RxJava Wiki: retry()</a>
-     */
-    public final Observable<T> retry(int retryCount) {
-        return nest().lift(new OperatorRetry<T>(retryCount));
-    }
-
-    /**
-     * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable
-     * within periodic time intervals.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.png">
-     * 
-     * @param period
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
-     */
-    public final Observable<T> sample(long period, TimeUnit unit) {
-        return lift(new OperatorSampleWithTime<T>(period, unit, Schedulers.computation()));
-    }
-
-    /**
-     * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable
-     * within periodic time intervals, where the intervals are defined on a particular Scheduler.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.s.png">
-     * 
-     * @param period
-     *            the sampling rate
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
-     */
-    public final Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorSampleWithTime<T>(period, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that, when the specified {@code sampler} Observable emits an item or completes,
-     * emits the most recently emitted item (if any) emitted by the source Observable since the previous
-     * emission from the {@code sampler} Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.o.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
-     */
-    public final <U> Observable<T> sample(Observable<U> sampler) {
-        return lift(new OperatorSampleWithObservable<T, U>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/scan.png">
-     * <p>
-     * 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
-     * @return an Observable that emits the results of each call to the accumulator function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-scan">RxJava Wiki: scan()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665.aspx">MSDN: Observable.Scan</a>
-     */
-    public final Observable<T> scan(Func2<T, T, T> accumulator) {
-        return lift(new OperatorScan<T, T>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/scanSeed.png">
-     * <p>
-     * This sort of function is sometimes called an accumulator.
-     * <p>
-     * 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 {@code initialValue} followed by the results of each call to the
-     *         accumulator function
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-scan">RxJava Wiki: scan()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665.aspx">MSDN: Observable.Scan</a>
-     */
-    public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accumulator) {
-        return lift(new OperatorScan<R, T>(initialValue, accumulator));
-    }
-
-    public final Observable<T> serialize() {
-        return lift(new OperatorSerialize<T>());
-    }
-
-    /**
-     * 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 NoSuchElementException}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.png">
-     * 
-     * @return an Observable that emits the single item emitted by the source Observable
-     * @throws IllegalArgumentException
-     *             if the source emits more than one item
-     * @throws NoSuchElementException
-     *             if the source emits no items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see "MSDN: Observable.singleAsync()"
-     */
-    public final Observable<T> single() {
-        return lift(new OperatorSingle<T>());
-    }
-
-    /**
-     * 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 NoSuchElementException}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.p.png">
-     * 
-     * @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 that matches the predicate
-     * @throws NoSuchElementException
-     *             if the source Observable emits no item that matches the predicate
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see "MSDN: Observable.singleAsync()"
-     */
-    public final Observable<T> single(Func1<? super T, Boolean> predicate) {
-        return filter(predicate).single();
-    }
-
-    /**
-     * 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.} <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/singleOrDefault.png">
-     * 
-     * @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
-     * @throws IllegalArgumentException
-     *             if the source Observable emits more than one item
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see "MSDN: Observable.singleOrDefaultAsync()"
-     */
-    public final Observable<T> singleOrDefault(T defaultValue) {
-        return lift(new OperatorSingle<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}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/singleOrDefault.p.png">
-     * 
-     * @param 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
-     * @throws IllegalArgumentException
-     *             if the source Observable emits more than one item that matches the predicate
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
-     * @see "MSDN: Observable.singleOrDefaultAsync()"
-     */
-    public final Observable<T> singleOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
-        return filter(predicate).singleOrDefault(defaultValue);
-    }
-
-    /**
-     * Returns an Observable that skips the first {@code num} items emitted by the source Observable and emits
-     * the remainder.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
-     */
-    public final Observable<T> skip(int num) {
-        return lift(new OperatorSkip<T>(num));
-    }
-
-    /**
-     * Returns an Observable that skips values emitted by the source Observable before a specified time window
-     * elapses.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.t.png">
-     * 
-     * @param time
-     *            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 and the emits the remainder
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
-     */
-    public final Observable<T> skip(long time, TimeUnit unit) {
-        return skip(time, unit, Schedulers.computation());
-    }
-
-    /**
-     * Returns an Observable that skips values emitted by the source Observable before a specified time window
-     * on a specified {@link Scheduler} elapses.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.ts.png">
-     * 
-     * @param time
-     *            the length of the time window to skip
-     * @param 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, and then emits the remainder
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
-     */
-    public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorSkipTimed<T>(time, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that drops a specified number of items from the end of the sequence emitted by the
-     * source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.png">
-     * <p>
-     * 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
-     * @throws IndexOutOfBoundsException
-     *             if {@code count} is less than zero
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skiplast">RxJava Wiki: skipLast()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
-     */
-    public final Observable<T> skipLast(int count) {
-        return lift(new OperatorSkipLast<T>(count));
-    }
-
-    /**
-     * Returns an Observable that drops items emitted by the source Observable during a specified time window
-     * before the source completes.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.t.png">
-     *
-     * Note: this action will cache the latest items arriving in the specified time window.
-     * 
-     * @param time
-     *            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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skiplast">RxJava Wiki: skipLast()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
-     */
-    public final Observable<T> skipLast(long time, TimeUnit unit) {
-        return skipLast(time, unit, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.ts.png">
-     *
-     * Note: this action will cache the latest items arriving in the specified time window.
-     *
-     * @param time
-     *            the length of the time window
-     * @param 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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skiplast">RxJava Wiki: skipLast()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
-     */
-    public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorSkipLastTimed<T>(time, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that skips items emitted by the source Observable until a second Observable emits
-     * an item.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipUntil.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skipuntil">RxJava Wiki: skipUntil()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229358.aspx">MSDN: Observable.SkipUntil</a>
-     */
-    public final <U> Observable<T> skipUntil(Observable<U> other) {
-        return lift(new OperatorSkipUntil<T, U>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipWhile.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-skipwhile-and-skipwhilewithindex">RxJava Wiki: skipWhile()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229685.aspx">MSDN: Observable.SkipWhile</a>
-     */
-    public final Observable<T> skipWhile(Func1<? super T, Boolean> predicate) {
-        return lift(new OperatorSkipWhile<T>(OperatorSkipWhile.toPredicate2(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipWhileWithIndex.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-skipwhile-and-skipwhilewithindex">RxJava Wiki: skipWhileWithIndex()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211631.aspx">MSDN: Observable.SkipWhile</a>
-     */
-    public final Observable<T> skipWhileWithIndex(Func2<? super T, Integer, Boolean> predicate) {
-        return lift(new OperatorSkipWhile<T>(predicate));
-    }
-
-    /**
-     * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit
-     * items emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.o.png">
-     * 
-     * @param values
-     *            an Observable that contains the items you want the modified Observable to emit first
-     * @return an Observable that emits the items in the specified {@link Observable} and then emits the items
-     *         emitted by the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(Observable<T> values) {
-        return concat(values, this);
-    }
-
-    /**
-     * Returns an Observable that emits the items in a specified {@link Iterable} before it begins to emit items
-     * emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(Iterable<T> values) {
-        return concat(Observable.<T> from(values), this);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.s.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229372.aspx">MSDN: Observable.StartWith</a>
-     */
-    public final Observable<T> startWith(Iterable<T> values, Scheduler scheduler) {
-        return concat(from(values, scheduler), this);
-    }
-
-    /**
-     * Returns an Observable that emits a specified item before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1) {
-        return concat(Observable.<T> from(t1), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2) {
-        return concat(Observable.<T> from(t1, t2), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param t1
-     *            the first item to emit
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2, T t3) {
-        return concat(Observable.<T> from(t1, t2, t3), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param t1
-     *            the first item to emit
-     * @param t2
-     *            the second item to emit
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2, T t3, T t4) {
-        return concat(Observable.<T> from(t1, t2, t3, t4), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param t1
-     *            the first item to emit
-     * @param t2
-     *            the second item to emit
-     * @param t3
-     *            the third item to emit
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5) {
-        return concat(Observable.<T> from(t1, t2, t3, t4, t5), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param t1
-     *            the first item to emit
-     * @param t2
-     *            the second item to emit
-     * @param t3
-     *            the third item to emit
-     * @param t4
-     *            the fourth item to emit
-     * @param t5
-     *            the fifth item to emit
-     * @param t6
-     *            the sixth item to emit
-     * @return an Observable that emits the specified items before it begins to emit items emitted
-     *         by the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
-        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param t1
-     *            the first item to emit
-     * @param t2
-     *            the second item to emit
-     * @param t3
-     *            the third item to emit
-     * @param t4
-     *            the fourth item to emit
-     * @param t5
-     *            the fifth item to emit
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
-        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6, t7), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param t1
-     *            the first item to emit
-     * @param t2
-     *            the second item to emit
-     * @param t3
-     *            the third item to emit
-     * @param t4
-     *            the fourth item to emit
-     * @param t5
-     *            the fifth item to emit
-     * @param t6
-     *            the sixth item to emit
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
-        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6, t7, t8), this);
-    }
-
-    /**
-     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-     * 
-     * @param t1
-     *            the first item to emit
-     * @param t2
-     *            the second item to emit
-     * @param t3
-     *            the third item to emit
-     * @param t4
-     *            the fourth item to emit
-     * @param t5
-     *            the fifth item to emit
-     * @param t6
-     *            the sixth item to emit
-     * @param t7
-     *            the seventh item to emit
-     * @param t8
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     */
-    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) {
-        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6, t7, t8, t9), this);
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.s.png">
-     * 
-     * @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.
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229372.aspx">MSDN: Observable.StartWith</a>
-     */
-    public final Observable<T> startWith(T[] values, Scheduler scheduler) {
-        return startWith(Arrays.asList(values), 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
-     * @throws OnErrorNotImplementedException
-     *             if the Observable tries to call {@code onError}
-     */
-    public final Subscription subscribe() {
-        return subscribe(new Subscriber<T>() {
-
-            @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
-            }
-
-        });
-    }
-
-    /**
-     * 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
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> onNext) {
-        if (onNext == null) {
-            throw new IllegalArgumentException("onNext can not be null");
-        }
-
-        return subscribe(new Subscriber<T>() {
-
-            @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);
-            }
-
-        });
-    }
-
-    /**
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     * @throws IllegalArgumentException
-     *             if {@code onNext} is null
-     * @throws IllegalArgumentException
-     *             if {@code onError} is null
-     */
-    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError) {
-        if (onNext == null) {
-            throw new IllegalArgumentException("onNext can not be null");
-        }
-        if (onError == null) {
-            throw new IllegalArgumentException("onError can not be null");
-        }
-
-        return subscribe(new Subscriber<T>() {
-
-            @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);
-            }
-
-        });
-    }
-
-    /**
-     * 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
-     * @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
-     * @throws IllegalArgumentException
-     *             if {@code onNext} is null
-     * @throws IllegalArgumentException
-     *             if {@code onError} is null
-     * @throws IllegalArgumentException
-     *             if {@code onComplete} is null
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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 subscribe(new Subscriber<T>() {
-
-            @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);
-            }
-
-        });
-    }
-
-    /**
-     * 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
-     * @param onComplete
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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
-     *            FIXME FIXME FIXME
-     * @param onError
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Observer<? super T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Observer<? super T> observer) {
-        return subscribe(new Subscriber<T>() {
-
-            @Override
-            public void onCompleted() {
-                observer.onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                observer.onError(e);
-            }
-
-            @Override
-            public void onNext(T t) {
-                observer.onNext(t);
-            }
-
-        });
-    }
-
-    /**
-     * Subscribe to Observable and invoke {@link OnSubscribe} function without any
-     * contract protection, error handling, unsubscribe, or execution hooks.
-     * <p>
-     * This should only be used for implementing an {@link Operator} that requires nested subscriptions.
-     * <p>
-     * Normal use should use {@link #subscribe(Subscriber)} which ensures the Rx contract and other functionality.
-     * 
-     * @param subscriber
-     * @return Subscription which is the Subscriber passed in
-     */
-    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
-        try {
-            onSubscribe.call(subscriber);
-        } catch (Throwable e) {
-            if (e instanceof OnErrorNotImplementedException) {
-                throw (OnErrorNotImplementedException) e;
-            }
-            // handle broken contracts: https://github.com/Netflix/RxJava/issues/1090
-            subscriber.onError(e);
-        }
-        return subscriber;
-    }
-
-    /**
-     * A {@link Subscriber} must call an Observable's {@code subscribe} method in order to receive items and
-     * notifications from the Observable.
-     * <p>
-     * A typical implementation of {@code subscribe} does the following:
-     * <ol>
-     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>} object.</li>
-     * <li>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.</li>
-     * </ol><p>
-     * An {@code Observable<T>} instance is responsible for accepting all subscriptions and notifying all
-     * Subscribers. Unless the documentation for a particular {@code Observable<T>} implementation indicates
-     * otherwise, Subscriber should make no assumptions about the order in which multiple Subscribers will
-     * receive their notifications.
-     * <p>
-     * For more information see the
-     * <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
-     * 
-     * @param subscriber
-     *            the {@link Subscriber}
-     * @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<? super T> subscriber) {
-        // allow the hook to intercept and/or decorate
-        OnSubscribe<T> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
-        // validate and proceed
-        if (subscriber == 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 Observer"
-             */
-            // if not already wrapped
-            if (!(subscriber instanceof SafeSubscriber)) {
-                // assign to `observer` so we return the protected version
-                subscriber = new SafeSubscriber<T>(subscriber);
-            }
-            onSubscribeFunction.call(subscriber);
-            final Subscription returnSubscription = hook.onSubscribeReturn(subscriber);
-            // 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 (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 {
-                subscriber.onError(hook.onSubscribeError(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);
-                // TODO could the hook be the cause of the error in the on error handling.
-                hook.onSubscribeError(r);
-                // TODO why aren't we throwing the hook's return value.
-                throw r;
-            }
-            return Subscriptions.empty();
-        }
-    }
-
-    /**
-     * A {@link Subscriber} must call an Observable's {@code subscribe} method in order to receive items and
-     * notifications from the Observable.
-     * <p>
-     * A typical implementation of {@code subscribe} does the following:
-     * <ol>
-     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>} object.</li>
-     * <li>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.</li>
-     * </ol><p>
-     * An {@code Observable<T>} instance is responsible for accepting all subscriptions and notifying all
-     * Subscribers. Unless the documentation for a particular {@code Observable<T>} implementation indicates
-     * otherwise, Subscribers should make no assumptions about the order in which multiple Subscribers will
-     * receive their notifications.
-     * <p>
-     * For more information see the
-     * <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
-     * 
-     * @param observer
-     *            the {@link Subscriber}
-     * @param scheduler
-     *            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}
-     */
-    public final Subscription subscribe(Subscriber<? super T> observer, Scheduler scheduler) {
-        return subscribeOn(scheduler).subscribe(observer);
-    }
-
-    /**
-     * Asynchronously subscribes Observers to this Observable on the specified {@link Scheduler}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/subscribeOn.png">
-     * 
-     * @param scheduler
-     *            the {@link Scheduler} to perform subscription actions on
-     * @return the source Observable modified so that its subscriptions happen on the
-     *         specified {@link Scheduler}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-subscribeon">RxJava Wiki: subscribeOn()</a>
-     */
-    public final Observable<T> subscribeOn(Scheduler scheduler) {
-        return nest().lift(new OperatorSubscribeOn<T>(scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchMap.png">
-     * 
-     * @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
-     */
-    public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<? extends R>> func) {
-        return switchOnNext(map(func));
-    }
-
-    /**
-     * Returns an Observable that emits only the first {@code num} items emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
-     */
-    public final Observable<T> take(final int num) {
-        return lift(new OperatorTake<T>(num));
-    }
-
-    /**
-     * Returns an Observable that emits those items emitted by source Observable before a specified time runs
-     * out.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.t.png">
-     * 
-     * @param time
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
-     */
-    public final Observable<T> take(long time, TimeUnit unit) {
-        return take(time, unit, Schedulers.computation());
-    }
-
-    /**
-     * Returns an Observable that emits those items emitted by source Observable before a specified time (on a
-     * specified Scheduler) runs out.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.ts.png">
-     * 
-     * @param time
-     *            the length of the time window
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
-     */
-    public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorTakeTimed<T>(time, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
-     * a specified condition.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeFirstN.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
-     * @see "MSDN: Observable.firstAsync()"
-     */
-    public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
-        return filter(predicate).take(1);
-    }
-
-    /**
-     * Returns an Observable that emits only the last {@code count} items emitted by the source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.n.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-takelast">RxJava Wiki: takeLast()</a>
-     */
-    public final Observable<T> takeLast(final int count) {
-        return create(OperationTakeLast.takeLast(this, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.tn.png">
-     * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            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
-     */
-    public final Observable<T> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.tns.png">
-     * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            the length of the time window
-     * @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 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<T> 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 that emits the items from the source Observable that were emitted in a specified
-     * window of time before the Observable completed.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.t.png">
-     * 
-     * @param time
-     *            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}
-     */
-    public final Observable<T> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.ts.png">
-     * 
-     * @param time
-     *            the length of the time window
-     * @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 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<T> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.png">
-     * 
-     * @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
-     */
-    public final Observable<List<T>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.tn.png">
-     * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            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
-     */
-    public final Observable<List<T>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.tns.png">
-     * 
-     * @param count
-     *            the maximum number of items to emit
-     * @param time
-     *            the length of the time window
-     * @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
-     */
-    public final Observable<List<T>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.t.png">
-     * 
-     * @param time
-     *            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
-     */
-    public final Observable<List<T>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.ts.png">
-     * 
-     * @param time
-     *            the length of the time window
-     * @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 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<List<T>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeUntil.png">
-     * 
-     * @param other
-     *            the Observable whose first emitted item will cause {@code takeUntil} to stop emitting items
-     *            from the source Observable
-     * @param <E>
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takeuntil">RxJava Wiki: takeUntil()</a>
-     */
-    public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
-        return OperationTakeUntil.takeUntil(this, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeWhile.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhile()</a>
-     */
-    public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate) {
-        return lift(new OperatorTakeWhile(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeWhileWithIndex.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhileWithIndex()</a>
-     */
-    public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Integer, Boolean> predicate) {
-        return lift(new OperatorTakeWhile(predicate));
-    }
-
-    /**
-     * Returns an Observable that emits only the first item emitted by the source Observable during sequential
-     * time windows of a specified duration.
-     * <p>
-     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas {@link #throttleLast} ticks at scheduled intervals.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleFirst.png">
-     * 
-     * @param windowDuration
-     *            time to wait before emitting another item after emitting the last item
-     * @param unit
-     *            the unit of time of {@code windowDuration}
-     * @return an Observable that performs the throttle operation
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlefirst">RxJava Wiki: throttleFirst()</a>
-     */
-    public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
-        return lift(new OperatorThrottleFirst<T>(windowDuration, unit, Schedulers.computation()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas {@link #throttleLast} ticks at scheduled intervals.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleFirst.s.png">
-     * 
-     * @param skipDuration
-     *            time to wait before emitting another item after emitting the last item
-     * @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
-     * @return an Observable that performs the throttle operation
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlefirst">RxJava Wiki: throttleFirst()</a>
-     */
-    public final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
-        return lift(new OperatorThrottleFirst<T>(skipDuration, unit, scheduler));
-    }
-
-    /**
-     * Returns an Observable that emits only the last item emitted by the source Observable during sequential
-     * time windows of a specified duration.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleLast.png">
-     * 
-     * @param intervalDuration
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-takelast">RxJava Wiki: throttleLast()</a>
-     * @see #sample(long, TimeUnit)
-     */
-    public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit) {
-        return sample(intervalDuration, 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.
-     * <p>
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleLast.s.png">
-     * 
-     * @param intervalDuration
-     *            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
-     * @return an Observable that performs the throttle operation
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-takelast">RxJava Wiki: throttleLast()</a>
-     * @see #sample(long, TimeUnit, Scheduler)
-     */
-    public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) {
-        return sample(intervalDuration, unit, 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.
-     * <p>
-     * <em>Note:</em> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleWithTimeout.png">
-     * <p>
-     * Information on debounce vs throttle:
-     * <p>
-     * <ul>
-     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
-     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
-     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
-     * </ul>
-     * 
-     * @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
-     * @param unit
-     *            the {@link TimeUnit} of {@code timeout}
-     * @return an Observable that filters out items that are too quickly followed by newer items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: throttleWithTimeout()</a>
-     * @see #debounce(long, TimeUnit)
-     */
-    public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
-        return debounce(timeout, 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.
-     * <p>
-     * <em>Note:</em> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleWithTimeout.s.png">
-     * <p>
-     * Information on debounce vs throttle:
-     * <p>
-     * <ul>
-     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
-     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
-     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
-     * </ul>
-     * 
-     * @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
-     * @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
-     * @return an Observable that filters out items that are too quickly followed by newer items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: throttleWithTimeout()</a>
-     * @see #debounce(long, TimeUnit, Scheduler)
-     */
-    public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
-        return debounce(timeout, unit, scheduler);
-    }
-
-    /**
-     * Returns an Observable that emits records of the time interval between consecutive items emitted by the
-     * source Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeInterval.png">
-     * 
-     * @return an Observable that emits time interval information items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timeinterval">RxJava Wiki: timeInterval()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
-     */
-    public final Observable<TimeInterval<T>> timeInterval() {
-        return lift(new OperatorTimeInterval(Schedulers.immediate()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeInterval.s.png">
-     * 
-     * @param scheduler
-     *            the {@link Scheduler} used to compute time intervals
-     * @return an Observable that emits time interval information items
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timeinterval">RxJava Wiki: timeInterval()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
-     */
-    public final Observable<TimeInterval<T>> timeInterval(Scheduler scheduler) {
-        return lift(new OperatorTimeInterval(scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout5.png">
-     * 
-     * @param <U>
-     *            the first timeout value type (ignored)
-     * @param <V>
-     *            the subsequent timeout value type (ignored)
-     * @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 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 <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout6.png">
-     * 
-     * @param <U>
-     *            the first timeout value type (ignored)
-     * @param <V>
-     *            the subsequent timeout value type (ignored)
-     * @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
-     * @throws NullPointerException
-     *             if {@code timeoutSelector} is null
-     */
-    public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> other) {
-        if (timeoutSelector == null) {
-            throw new NullPointerException("timeoutSelector is null");
-        }
-        return lift(new OperatorTimeoutWithSelector<T, U, V>(firstTimeoutSelector, timeoutSelector, other));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout3.png">
-     * <p>
-     * Note: The arrival of the first source item is never timed out.
-     * 
-     * @param <V>
-     *            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
-     * @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 <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout4.png">
-     * <p>
-     * Note: The arrival of the first source item is never timed out.
-     * 
-     * @param <V>
-     *            the timeout value type (ignored)
-     * @param timeoutSelector
-     *            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 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 <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> 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}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.1.png">
-     * 
-     * @param timeout
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244283.aspx">MSDN: Observable.Timeout</a>
-     */
-    public final Observable<T> timeout(long timeout, TimeUnit timeUnit) {
-        return timeout(timeout, timeUnit, null, Schedulers.computation());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.2.png">
-     * 
-     * @param timeout
-     *            maximum duration between items before a timeout occurs
-     * @param 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229512.aspx">MSDN: Observable.Timeout</a>
-     */
-    public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<? extends T> other) {
-        return timeout(timeout, timeUnit, other, Schedulers.computation());
-    }
-
-    /**
-     * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted
-     * item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration
-     * starting from its predecessor, the resulting Observable begins instead to mirror a fallback Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.2s.png">
-     * 
-     * @param timeout
-     *            maximum duration between items before a timeout occurs
-     * @param timeUnit
-     *            the unit of time that applies to the {@code timeout} argument
-     * @param other
-     *            the Observable to use as the fallback in case of a timeout
-     * @param scheduler
-     *            the {@link 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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211676.aspx">MSDN: Observable.Timeout</a>
-     */
-    public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<? extends T> other, Scheduler scheduler) {
-        return lift(new OperatorTimeout<T>(timeout, timeUnit, other, scheduler));
-    }
-
-    /**
-     * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted
-     * item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the
-     * specified timeout duration starting from its predecessor, the resulting Observable terminates and
-     * notifies observers of a {@code TimeoutException}.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.1s.png">
-     * 
-     * @param timeout
-     *            maximum duration between items before a timeout occurs
-     * @param timeUnit
-     *            the unit of time that applies to the {@code timeout} argument
-     * @param scheduler
-     *            the Scheduler to run the timeout timers on
-     * @return the source Observable modified to notify observers of a {@code TimeoutException} in case of a
-     *         timeout
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228946.aspx">MSDN: Observable.Timeout</a>
-     */
-    public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) {
-        return timeout(timeout, timeUnit, null, scheduler);
-    }
-
-    /**
-     * Returns an Observable that emits each item emitted by the source Observable, wrapped in a {@link Timestamped} object.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timestamp.png">
-     * 
-     * @return an Observable that emits timestamped items from the source Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timestamp">RxJava Wiki: timestamp()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229003.aspx">MSDN: Observable.Timestamp</a>
-     */
-    public final Observable<Timestamped<T>> timestamp() {
-        return timestamp(Schedulers.immediate());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timestamp.s.png">
-     * 
-     * @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}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timestamp">RxJava Wiki: timestamp()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229003.aspx">MSDN: Observable.Timestamp</a>
-     */
-    public final Observable<Timestamped<T>> timestamp(Scheduler scheduler) {
-        return lift(new OperatorTimestamp<T>(scheduler));
-    }
-
-    /**
-     * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking operators).
-     * 
-     * @return a {@code BlockingObservable} version of this Observable
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators">RxJava Wiki: Blocking Observable Observers</a>
-     */
-    public final BlockingObservable<T> toBlockingObservable() {
-        return BlockingObservable.from(this);
-    }
-
-    /**
-     * Returns an Observable that emits a single item, a list composed of all the items emitted by the source
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toList.png">
-     * <p>
-     * 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.
-     * <p>
-     *
-     * <!-- IS THE FOLLOWING NOTE STILL VALID? -->
-     *
-     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tolist">RxJava Wiki: toList()</a>
-     */
-    public final Observable<List<T>> toList() {
-        return lift(new OperatorToObservableList<T>());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229137.aspx">MSDN: Observable.ToDictionary</a>
-     */
-    public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorToMap<T, K, T>(keySelector, Functions.<T>identity()));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
-     * <p>
-     * 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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212075.aspx">MSDN: Observable.ToDictionary</a>
-     */
-    public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
-     * 
-     * @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
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
-     */
-    public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, V>> mapFactory) {
-        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector, mapFactory));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212098.aspx">MSDN: Observable.ToLookup</a>
-     */
-    public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorToMultimap<T, K, T>(keySelector, Functions.<T>identity()));
-    }
-
-    /**
-     * Return an Observable that emits a single HashMap that contains an ArrayList of values extracted by a
-     * specified {@code valueSelector} function from items emitted by the source Observable, keyed by a
-     * specified {@code keySelector} function.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
-     * 
-     * @param keySelector
-     *            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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
-     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229101.aspx">MSDN: Observable.ToLookup</a>
-     */
-    public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
-        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector));
-    }
-
-    /**
-     * Return an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that
-     * contains an ArrayList of values, extracted by a specified {@code valueSelector} function from items
-     * emitted by the source Observable and keyed by the {@code keySelector} function.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
-     * 
-     * @param keySelector
-     *            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
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
-     */
-    public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory) {
-        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory));
-    }
-
-    /**
-     * Return an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that
-     * contains a custom collection of values, extracted by a specified {@code valueSelector} function from
-     * items emitted by the source Observable, and keyed by the {@code keySelector} function.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
-     * 
-     * @param keySelector
-     *            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
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
-     */
-    public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory, Func1<? super K, ? extends Collection<V>> collectionFactory) {
-        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory, collectionFactory));
-    }
-
-    /**
-     * Returns an Observable that emits a list that contains 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toSortedList.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tosortedlist">RxJava Wiki: toSortedList()</a>
-     */
-    public final Observable<List<T>> toSortedList() {
-        return lift(new OperatorToObservableSortedList<T>());
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toSortedList.f.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tosortedlist">RxJava Wiki: toSortedList()</a>
-     */
-    public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Integer> sortFunction) {
-        return lift(new OperatorToObservableSortedList<T>(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<T> unsubscribeOn(Scheduler scheduler) {
-        return lift(new OperatorUnsubscribeOn<T>(scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window1.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final <TClosing> Observable<Observable<T>> window(Func0<? extends Observable<? extends TClosing>> closingSelector) {
-        return create(OperationWindow.window(this, closingSelector));
-    }
-
-    /**
-     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
-     * Observable emits connected, non-overlapping windows, each containing {@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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window3.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(int count) {
-        return create(OperationWindow.window(this, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window4.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(int count, int skip) {
-        return create(OperationWindow.window(this, count, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window7.png">
-     * 
-     * @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 {@code timespan} and {@code timeshift} arguments
-     * @return an Observable that emits new windows periodically as a fixed timespan elapses
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(long timespan, long timeshift, TimeUnit unit) {
-        return create(OperationWindow.window(this, timespan, timeshift, unit));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window7.s.png">
-     * 
-     * @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 {@code timespan} and {@code timeshift} arguments
-     * @param scheduler
-     *            the {@link Scheduler} to use when determining the end and start of a window
-     * @return an Observable that emits new windows periodically as a fixed timespan elapses
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, timeshift, unit, scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window5.png">
-     * 
-     * @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 {@code timespan} argument
-     * @return an Observable that emits connected, non-overlapping windows represending items emitted by the
-     *         source Observable during fixed, consecutive durations
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(long timespan, TimeUnit unit) {
-        return create(OperationWindow.window(this, timespan, 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window6.png">
-     * 
-     * @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 {@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)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int count) {
-        return create(OperationWindow.window(this, timespan, unit, count));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window6.s.png">
-     * 
-     * @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 {@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)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, unit, count, scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window5.s.png">
-     * 
-     * @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 {@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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final Observable<Observable<T>> window(long timespan, TimeUnit unit, Scheduler scheduler) {
-        return create(OperationWindow.window(this, timespan, unit, scheduler));
-    }
-
-    /**
-     * 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window2.png">
-     * 
-     * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
-     */
-    public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<? extends TOpening> windowOpenings, Func1<? super TOpening, ? extends Observable<? extends TClosing>> closingSelector) {
-        return create(OperationWindow.window(this, windowOpenings, closingSelector));
-    }
-
-    /**
-     * Returns an Observable that 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 a specified boundary-governing
-     * Observable.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window8.png">
-     * 
-     * @param <U>
-     *            the window element type (ignored)
-     * @param boundary
-     *            an Observable whose emitted items close and open windows
-     * @return an Observable that 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 {@code boundary} Observable
-     */
-    public final <U> Observable<Observable<T>> window(Observable<U> 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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.i.png">
-     * <p>
-     * 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 <T2>
-     *            the type of items in the {@code other} Iterable
-     * @param <R>
-     *            the type of items emitted by the resulting Observable
-     * @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
-     */
-    public final <T2, R> Observable<R> zip(Iterable<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
-        return lift(new OperatorZipIterable<T, T2, R>(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.
-     * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
-     * 
-     * @param <T2>
-     *            the type of items emitted by the {@code other} Observable
-     * @param <R>
-     *            the type of items emitted by the resulting Observable
-     * @param other
-     *            the other Observable
-     * @param zipFunction
-     *            a function that combines the pairs of items from the two Observables 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} Observable
-     *         and emits the results of {@code zipFunction} applied to these pairs
-     */
-    public final <T2, R> Observable<R> zip(Observable<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
-        return zip(this, other, zipFunction);
-    }
-
-    /**
-     * An Observable that never sends any information to an {@link Observer}.
-     * 
-     * This Observable is useful primarily for testing purposes.
-     * 
-     * @param <T>
-     *            the type of item (not) emitted by the Observable
-     */
-    private static class NeverObservable<T> extends Observable<T> {
-        public NeverObservable() {
-            super(new OnSubscribe<T>() {
-
-                @Override
-                public void call(Subscriber<? super T> observer) {
-                    // do nothing
-                }
-
-            });
-        }
-    }
-
-    /**
-     * An Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it.
-     * 
-     * @param <T>
-     *            the type of item (ostensibly) emitted by the Observable
-     */
-    private static class ThrowObservable<T> extends Observable<T> {
-
-        public ThrowObservable(final Throwable exception) {
-            super(new OnSubscribe<T>() {
-
-                /**
-                 * 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 void call(Subscriber<? super T> observer) {
-                    observer.onError(exception);
-                }
-
-            });
-        }
-    }
-}
+/**
+ * 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 static rx.functions.Functions.alwaysFalse;
+
+import java.util.*;
+import java.util.concurrent.*;
+
+import rx.exceptions.*;
+import rx.functions.*;
+import rx.observables.*;
+import rx.observers.SafeSubscriber;
+import rx.operators.*;
+import rx.plugins.*;
+import rx.schedulers.*;
+import rx.subjects.*;
+import rx.subscriptions.Subscriptions;
+
+/**
+ * The Observable class that implements the Reactive Pattern.
+ * <p>
+ * This class provides methods for subscribing to the Observable as well as delegate methods to the various
+ * Observers.
+ * <p>
+ * The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
+ * <p>
+ * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/legend.png">
+ * <p>
+ * For more information see the <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
+ * 
+ * @param <T>
+ *            the type of the items emitted by the Observable
+ */
+public class Observable<T> {
+
+    final OnSubscribe<T> onSubscribe;
+
+    /**
+     * Observable with Function to execute when subscribed to.
+     * <p>
+     * <em>Note:</em> 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
+     */
+    protected Observable(OnSubscribe<T> f) {
+        this.onSubscribe = f;
+    }
+
+    private static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();
+
+    /**
+     * Returns an Observable that will execute the specified function when a {@link Subscriber} subscribes to
+     * it.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/create.png">
+     * <p>
+     * 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.
+     * <p>
+     * A well-formed Observable must invoke either the Subscriber's {@code onCompleted} method exactly once or
+     * its {@code onError} method exactly once.
+     * <p>
+     * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
+     * information.
+     * 
+     * @param <T>
+     *            the type of the items that this Observable emits
+     * @param f
+     *            a function that accepts an {@code Subscriber<T>}, 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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-create">RxJava Wiki: create()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.create.aspx">MSDN: Observable.Create</a>
+     */
+    public final static <T> Observable<T> create(OnSubscribe<T> f) {
+        return new Observable<T>(hook.onCreate(f));
+    }
+
+    /**
+     * Invoked when Obserable.subscribe is called.
+     */
+    public static interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
+        // cover for generics insanity
+    }
+
+    /**
+     * Operator function for lifting into an Observable.
+     */
+    public interface Operator<R, T> extends Func1<Subscriber<? super R>, Subscriber<? super T>> {
+        // cover for generics insanity
+    }
+
+    /**
+     * @deprecated use {@link #create(OnSubscribe)}
+     */
+    @Deprecated
+    public final static <T> Observable<T> create(final OnSubscribeFunc<T> f) {
+        return new Observable<T>(new OnSubscribe<T>() {
+
+            @Override
+            public void call(Subscriber<? super T> observer) {
+                Subscription s = f.onSubscribe(observer);
+                if (s != null && s != observer) {
+                    observer.add(s);
+                }
+            }
+
+        });
+    }
+
+    /**
+     * @deprecated use {@link #OnSubscribe}
+     */
+    @Deprecated
+    public static interface OnSubscribeFunc<T> extends Function {
+
+        public Subscription onSubscribe(Observer<? super T> op);
+
+    }
+
+    /**
+     * 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.
+     * <p>
+     * In other words, this allows chaining Observers together on an Observable for acting on the values within
+     * the Observable.
+     * <p> {@code
+     * observable.map(...).filter(...).take(5).lift(new ObserverA()).lift(new ObserverB(...)).subscribe()
+     * }
+     * 
+     * @param lift
+     * @return an Observable that emits values that are the result of applying the bind function to the values
+     *         of the current Observable
+     */
+    public final <R> Observable<R> lift(final Operator<? extends R, ? super T> lift) {
+        return new Observable<R>(new OnSubscribe<R>() {
+            @Override
+            public void call(Subscriber<? super R> o) {
+                try {
+                    onSubscribe.call(hook.onLift(lift).call(o));
+                } catch (Throwable e) {
+                    // localized capture of errors rather than it skipping all operators 
+                    // and ending up in the try/catch of the subscribe method which then
+                    // prevents onErrorResumeNext and other similar approaches to error handling
+                    if (e instanceof OnErrorNotImplementedException) {
+                        throw (OnErrorNotImplementedException) e;
+                    }
+                    o.onError(e);
+                }
+            }
+        });
+    }
+
+    /* *********************************************************************************************************
+     * Observers Below Here
+     * *********************************************************************************************************
+     */
+
+    /**
+     * Mirror the one Observable in an Iterable of several Observables that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229115.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Iterable<? extends Observable<? extends T>> sources) {
+        return create(OperatorAmb.amb(sources));
+    }
+
+    /**
+     * Given two Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @param o1
+     *            an Observable competing to react first
+     * @param o2
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2) {
+        return create(OperatorAmb.amb(o1, o2));
+    }
+
+    /**
+     * Given three Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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 emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3) {
+        return create(OperatorAmb.amb(o1, o2, o3));
+    }
+
+    /**
+     * Given four Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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 emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4) {
+        return create(OperatorAmb.amb(o1, o2, o3, o4));
+    }
+
+    /**
+     * Given five Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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 emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5) {
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5));
+    }
+
+    /**
+     * Given six Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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 emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6) {
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6));
+    }
+
+    /**
+     * Given seven Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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 emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7) {
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7));
+    }
+
+    /**
+     * Given eight Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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 emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8) {
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8));
+    }
+
+    /**
+     * Given nine Observables, mirror the one that first emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/amb.png">
+     * 
+     * @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 emits the same sequence of items as whichever of the source Observables first
+     *         emitted an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-amb">RxJava Wiki: amb()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229733.aspx">MSDN: Observable.Amb</a>
+     */
+    public final static <T> Observable<T> amb(Observable<? extends T> o1, Observable<? extends T> o2, Observable<? extends T> o3, Observable<? extends T> o4, Observable<? extends T> o5, Observable<? extends T> o6, Observable<? extends T> o7, Observable<? extends T> o8, Observable<? extends T> o9) {
+        return create(OperatorAmb.amb(o1, o2, o3, o4, o5, o6, o7, o8, o9));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Func2<? super T1, ? super T2, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2), Functions.fromFunc(combineFunction));
+    }
+
+    /**
+     * Combines three 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, T3, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3), Functions.fromFunc(combineFunction));
+    }
+
+    /**
+     * Combines four 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, T3, T4, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4,
+            Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3, o4), Functions.fromFunc(combineFunction));
+    }
+
+    /**
+     * Combines five 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, T3, T4, T5, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5,
+            Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5), Functions.fromFunc(combineFunction));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, T3, T4, T5, T6, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
+            Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6), Functions.fromFunc(combineFunction));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
+            Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7), Functions.fromFunc(combineFunction));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8), Functions.fromFunc(combineFunction));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/combineLatest.png">
+     * 
+     * @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 that emits items that are the result of combining the items emitted by the source
+     *         Observables by means of the given aggregation function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    @SuppressWarnings("unchecked")
+    public static final <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> combineLatest(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Observable<? extends T9> o9,
+            Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> combineFunction) {
+        return combineLatest(Arrays.asList(o1, o2, o3, o4, o5, o6, o7, o8, o9), Functions.fromFunc(combineFunction));
+    }
+    /**
+     * 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.
+     * @param <T> the common base type of source values
+     * @param <R> the result type
+     * @param sources the list of observable sources
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-combinelatest">RxJava Wiki: combineLatest()</a>
+     */
+    public static final <T, R> Observable<R> combineLatest(List<? extends Observable<? extends T>> sources, FuncN<? extends R> combineFunction) {
+        return create(new OperatorCombineLatest<T, R>(sources, combineFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by each of the Observables emitted by an Observable,
+     * one after the other, without interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends Observable<? extends T>> observables) {
+        return observables.lift(new OperatorConcat<T>());
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by two Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @param t1
+     *            an Observable to be concatenated
+     * @param t2
+     *            an Observable to be concatenated
+     * @return an Observable that emits items emitted by the two source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2) {
+        return concat(from(t1, t2));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by three Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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 emitted by the three source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
+        return concat(from(t1, t2, t3));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by four Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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 emitted by the four source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
+        return concat(from(t1, t2, t3, t4));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by five Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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 emitted by the five source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
+        return concat(from(t1, t2, t3, t4, t5));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by six Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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 emitted by the six source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
+        return concat(from(t1, t2, t3, t4, t5, t6));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by seven Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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 emitted by the seven source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
+        return concat(from(t1, t2, t3, t4, t5, t6, t7));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by eight Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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 emitted by the eight source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
+        return concat(from(t1, t2, t3, t4, t5, t6, t7, t8));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by nine Observables, one after the other, without
+     * interleaving them.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concat.png">
+     * 
+     * @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 emitted by the nine source Observables, one after the other,
+     *         without interleaving them
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-concat">RxJava Wiki: concat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.linq.observable.concat.aspx">MSDN: Observable.Concat</a>
+     */
+    public final static <T> Observable<T> concat(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
+        return concat(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/defer.png">
+     * <p>
+     * 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
+     * @param <T>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-defer">RxJava Wiki: defer()</a>
+     */
+    public final static <T> Observable<T> defer(Func0<? extends Observable<? extends T>> observableFactory) {
+        return create(new OperatorDefer<T>(observableFactory));
+    }
+
+    /**
+     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its {@link Observer#onCompleted onCompleted} method.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/empty.png">
+     * 
+     * @param <T>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: empty()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229670.aspx">MSDN: Observable.Empty</a>
+     */
+    public final static <T> Observable<T> empty() {
+        return from(new ArrayList<T>());
+    }
+
+    /**
+     * Returns an Observable that emits no items to the {@link Observer} and immediately invokes its {@link Observer#onCompleted onCompleted} method on the specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/empty.s.png">
+     * 
+     * @param scheduler
+     *            the Scheduler to use to call the {@link Observer#onCompleted onCompleted} method
+     * @param <T>
+     *            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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: empty()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229066.aspx">MSDN: Observable.Empty Method (IScheduler)</a>
+     */
+    public final static <T> Observable<T> empty(Scheduler scheduler) {
+        return Observable.<T> empty().subscribeOn(scheduler);
+    }
+
+    /**
+     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method when the
+     * Observer subscribes to it.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/error.png">
+     * 
+     * @param exception
+     *            the particular Throwable to pass to {@link Observer#onError onError}
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: error()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244299.aspx">MSDN: Observable.Throw</a>
+     */
+    public final static <T> Observable<T> error(Throwable exception) {
+        return new ThrowObservable<T>(exception);
+    }
+
+    /**
+     * Returns an Observable that invokes an {@link Observer}'s {@link Observer#onError onError} method on the
+     * specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/error.s.png">
+     * 
+     * @param exception
+     *            the particular Throwable to pass to {@link Observer#onError onError}
+     * @param scheduler
+     *            the Scheduler on which to call {@link Observer#onError onError}
+     * @param <T>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: error()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211711.aspx">MSDN: Observable.Throw</a>
+     */
+    public final static <T> Observable<T> error(Throwable exception, Scheduler scheduler) {
+        return Observable.<T> error(exception).subscribeOn(scheduler);
+    }
+
+    /**
+     * Converts a {@link Future} into an Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.png">
+     * <p>
+     * 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.
+     * <p>
+     * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
+     * 
+     * @param future
+     *            the source {@link Future}
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    public final static <T> Observable<T> from(Future<? extends T> future) {
+        return create(OperatorToObservableFuture.toObservableFuture(future));
+    }
+
+    /**
+     * Converts a {@link Future} into an Observable, with a timeout on the Future.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.png">
+     * <p>
+     * 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.
+     * <p>
+     * <em>Important note:</em> This Observable is blocking; you cannot unsubscribe from it.
+     * 
+     * @param future
+     *            the source {@link Future}
+     * @param timeout
+     *            the maximum time to wait before calling {@code get()}
+     * @param unit
+     *            the {@link TimeUnit} of the {@code timeout} argument
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    public final static <T> Observable<T> from(Future<? extends T> future, long timeout, TimeUnit unit) {
+        return create(OperatorToObservableFuture.toObservableFuture(future, timeout, unit));
+    }
+
+    /**
+     * Converts a {@link Future}, operating on a specified {@link Scheduler}, into an Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.Future.s.png">
+     * <p>
+     * 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.
+     * <p>
+     * 
+     * @param future
+     *            the source {@link Future}
+     * @param scheduler
+     *            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 <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    public final static <T> Observable<T> from(Future<? extends T> future, Scheduler scheduler) {
+        return create(OperatorToObservableFuture.toObservableFuture(future)).subscribeOn(scheduler);
+    }
+
+    /**
+     * Converts an {@link Iterable} sequence into an Observable that emits the items in the sequence.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param iterable
+     *            the source {@link Iterable} sequence
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    public final static <T> Observable<T> from(Iterable<? extends T> iterable) {
+        return create(new OnSubscribeFromIterable<T>(iterable));
+    }
+
+    /**
+     * Converts an {@link Iterable} sequence into an Observable that operates on the specified Scheduler,
+     * emitting each item from the sequence.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.s.png">
+     * 
+     * @param iterable
+     *            the source {@link Iterable} sequence
+     * @param scheduler
+     *            the Scheduler on which the Observable is to emit the items of the Iterable
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212140.aspx">MSDN: Observable.ToObservable</a>
+     */
+    public final static <T> Observable<T> from(Iterable<? extends T> iterable, Scheduler scheduler) {
+        return create(new OnSubscribeFromIterable<T>(iterable)).subscribeOn(scheduler);
+    }
+
+    /**
+     * Converts an item into an Observable that emits that item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param t1
+     *            the item
+     * @param <T>
+     *            the type of the item
+     * @return an Observable that emits the item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1) {
+        return from(Arrays.asList(t1));
+    }
+
+    /**
+     * Converts two items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1, T t2) {
+        return from(Arrays.asList(t1, t2));
+    }
+
+    /**
+     * Converts three items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1, T t2, T t3) {
+        return from(Arrays.asList(t1, t2, t3));
+    }
+
+    /**
+     * Converts four items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4) {
+        return from(Arrays.asList(t1, t2, t3, t4));
+    }
+
+    /**
+     * Converts five items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param t1
+     *            first item
+     * @param t2
+     *            second item
+     * @param t3
+     *            third item
+     * @param t4
+     *            fourth item
+     * @param t5
+     *            fifth item
+     * @param <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5) {
+        return from(Arrays.asList(t1, t2, t3, t4, t5));
+    }
+
+    /**
+     * Converts six items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @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 <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6) {
+        return from(Arrays.asList(t1, t2, t3, t4, t5, t6));
+    }
+
+    /**
+     * Converts seven items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @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 <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
+        return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7));
+    }
+
+    /**
+     * Converts eight items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @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 <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> from(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
+        return from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8));
+    }
+
+    /**
+     * Converts nine items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @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 <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> 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 ten items into an Observable that emits those items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * <p>
+     * 
+     * @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 <T>
+     *            the type of these items
+     * @return an Observable that emits each item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    // suppress unchecked because we are using varargs inside the method
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> 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));
+    }
+
+    /**
+     * Converts an Array into an Observable that emits the items in the Array.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param t1
+     *            the source Array
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    public final static <T> Observable<T> from(T... t1) {
+        return from(Arrays.asList(t1));
+    }
+
+    /**
+     * Converts an Array into an Observable that emits the items in the Array on a specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/from.png">
+     * 
+     * @param items
+     *            the source Array
+     * @param scheduler
+     *            the Scheduler on which the Observable emits the items of the Array
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
+     */
+    public final static <T> Observable<T> from(T[] items, Scheduler scheduler) {
+        return from(Arrays.asList(items), scheduler);
+    }
+
+    /**
+     * Returns an Observable that emits a sequential number every specified interval of time.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/interval.png">
+     * 
+     * @param interval
+     *            interval size in time units (see below)
+     * @param unit
+     *            time units to use for the interval size
+     * @return an Observable that emits a sequential number each time interval
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-interval">RxJava Wiki: interval()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229027.aspx">MSDN: Observable.Interval</a>
+     */
+    public final static Observable<Long> interval(long interval, TimeUnit unit) {
+        return create(new OperatorTimerPeriodically(interval, interval, unit, Schedulers.computation()));
+    }
+
+    /**
+     * Returns an Observable that emits a sequential number every specified interval of time, on a
+     * specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/interval.s.png">
+     * 
+     * @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 a sequential number each time interval
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-interval">RxJava Wiki: interval()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228911.aspx">MSDN: Observable.Interval</a>
+     */
+    public final static Observable<Long> interval(long interval, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperatorTimerPeriodically(interval, interval, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that emits a single item and then completes.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/just.png">
+     * <p>
+     * To convert any object into an Observable that emits that object, pass that object into the {@code just} method.
+     * <p>
+     * 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
+     * @param <T>
+     *            the type of that item
+     * @return an Observable that emits {@code value} as a single item and then completes
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-just">RxJava Wiki: just()</a>
+     */
+    public final static <T> Observable<T> just(final T value) {
+        return Observable.create(new OnSubscribe<T>() {
+
+            @Override
+            public void call(Subscriber<? super T> s) {
+                if (!s.isUnsubscribed()) {
+                    s.onNext(value);
+                    s.onCompleted();
+                }
+            }
+
+        });
+    }
+
+    /**
+     * Returns an Observable that emits a single item and then completes, on a specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/just.s.png">
+     * <p>
+     * This is a scheduler version of {@link #just(Object)}.
+     * 
+     * @param value
+     *            the item to emit
+     * @param <T>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-just">RxJava Wiki: just()</a>
+     */
+    public final static <T> Observable<T> just(T value, Scheduler scheduler) {
+        return just(value).subscribeOn(scheduler);
+    }
+
+    /**
+     * Flattens an Iterable of Observables into one Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229590.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences) {
+        return merge(from(sequences));
+    }
+
+    /**
+     * Flattens an Iterable of Observables into one Observable, without any transformation, while limiting the
+     * number of concurrent subscriptions to these Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @throws IllegalArgumentException
+     *             if {@code maxConcurrent} is less than or equal to 0
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229923.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences, int maxConcurrent) {
+        return merge(from(sequences), maxConcurrent);
+    }
+
+    /**
+     * Flattens an Iterable of Observables into one Observable, without any transformation, while limiting the
+     * number of concurrent subscriptions to these Observables, and subscribing to these Observables on a
+     * specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @throws IllegalArgumentException
+     *             if {@code maxConcurrent} is less than or equal to 0
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244329.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences, int maxConcurrent, Scheduler scheduler) {
+        return merge(from(sequences, scheduler), maxConcurrent);
+    }
+
+    /**
+     * Flattens an Iterable of Observables into one Observable, without any transformation, subscribing to these
+     * Observables on a specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244336.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Iterable<? extends Observable<? extends T>> sequences, Scheduler scheduler) {
+        return merge(from(sequences, scheduler));
+    }
+
+    /**
+     * Flattens an Observable that emits Observables into a single Observable that emits the items emitted by
+     * those Observables, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.oo.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source) {
+        return source.lift(new OperatorMerge<T>());
+    }
+
+    /**
+     * Flattens an Observable that emits Observables into a single Observable that emits the items emitted by
+     * those Observables, without any transformation, while limiting the maximum number of concurrent
+     * subscriptions to these Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.oo.png">
+     * <p>
+     * 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
+     * @throws IllegalArgumentException
+     *             if {@code maxConcurrent} is less than or equal to 0
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211914.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Observable<? extends Observable<? extends T>> source, int maxConcurrent) {
+        return source.lift(new OperatorMergeMaxConcurrent<T>(maxConcurrent));
+    }
+
+    /**
+     * Flattens two Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @param t2
+     *            an Observable to be merged
+     * @return an Observable that emits all of the items emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2) {
+        return merge(from(Arrays.asList(t1, t2)));
+    }
+
+    /**
+     * Flattens three Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @param t2
+     *            an Observable to be merged
+     * @param t3
+     *            an Observable to be merged
+     * @return an Observable that emits all of the items emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
+        return merge(from(Arrays.asList(t1, t2, t3)));
+    }
+
+    /**
+     * Flattens four Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @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 all of the items emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
+        return merge(from(Arrays.asList(t1, t2, t3, t4)));
+    }
+
+    /**
+     * Flattens five Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @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 all of the items emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5)));
+    }
+
+    /**
+     * Flattens six Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @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 all of the items emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6)));
+    }
+
+    /**
+     * Flattens seven Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @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 all of the items emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7)));
+    }
+
+    /**
+     * Flattens eight Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @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
+     * @return an Observable that emits all of the items emitted by the source Observables
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8)));
+    }
+
+    /**
+     * Flattens nine Observables into a single Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.png">
+     * <p>
+     * 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
+     * @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 all of the items emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    public final static <T> Observable<T> merge(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
+        return merge(from(Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9)));
+    }
+
+    /**
+     * Flattens an Array of Observables into one Observable, without any transformation.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.io.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Observable<? extends T>[] sequences) {
+        return merge(from(sequences));
+    }
+
+    /**
+     * Flattens an Array of Observables into one Observable, without any transformation, traversing the array on
+     * a specified Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/merge.ios.png">
+     * <p>
+     * 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
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-merge">RxJava Wiki: merge()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229061.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> merge(Observable<? extends T>[] sequences, Scheduler scheduler) {
+        return merge(from(sequences, scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends Observable<? extends T>> source) {
+        return source.lift(new OperatorMergeDelayError<T>());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2) {
+        return mergeDelayError(from(t1, t2));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @param t2
+     *            an Observable to be merged
+     * @param t3
+     *            an Observable to be merged
+     * @return an Observable that emits all of the items that are emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3) {
+        return mergeDelayError(from(t1, t2, t3));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @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 all of the items that are emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4) {
+        return mergeDelayError(from(t1, t2, t3, t4));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @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 all of the items that are emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5) {
+        return mergeDelayError(from(t1, t2, t3, t4, t5));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @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 all of the items that are emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6) {
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @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 all of the items that are emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7) {
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @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 all of the items that are emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    @SuppressWarnings("unchecked")
+    // suppress because the types are checked by the method signature before using a vararg
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7, t8));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeDelayError.png">
+     * <p>
+     * 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
+     * @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 all of the items that are emitted by the source Observables
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
+     */
+    public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8, Observable<? extends T> t9) {
+        return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7, t8, t9));
+    }
+
+    /**
+     * Convert the current {@code Observable<T>} into an {@code Observable<Observable<T>>}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/nest.png">
+     * 
+     * @return an Observable that emits a single item: the source Observable
+     */
+    public final Observable<Observable<T>> nest() {
+        return just(this);
+    }
+
+    /**
+     * Returns an Observable that never sends any items or notifications to an {@link Observer}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/never.png">
+     * <p>
+     * This Observable is useful primarily for testing purposes.
+     * 
+     * @param <T>
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-empty-error-and-never">RxJava Wiki: never()</a>
+     */
+    public final static <T> Observable<T> never() {
+        return new NeverObservable<T>();
+    }
+
+    /**
+     * Converts an {@code Observable<Observable<T>>} into another {@code Observable<Observable<T>>} whose
+     * emitted Observables emit the same items, but the number of such Observables is restricted by {@code parallelObservables}.
+     * <p>
+     * For example, if the original {@code Observable<Observable<T>>} 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallelMerge.png">
+     * <p>
+     * This is a mechanism for efficiently processing <i>n</i> number of Observables on a smaller <i>m</i>
+     * number of resources (typically CPU cores).
+     * 
+     * @param parallelObservables
+     *            the number of Observables to merge into
+     * @return an Observable of Observables constrained in number by {@code parallelObservables}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-parallelmerge">RxJava Wiki: parallelMerge()</a>
+     */
+    public final static <T> Observable<Observable<T>> parallelMerge(Observable<Observable<T>> source, int parallelObservables) {
+        return OperatorParallelMerge.parallelMerge(source, parallelObservables);
+    }
+
+    /**
+     * Converts an {@code Observable<Observable<T>>} into another {@code Observable<Observable<T>>} 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.
+     * <p>
+     * For example, if the original {@code Observable<Observable<T>>} 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallelMerge.png">
+     * <p>
+     * This is a mechanism for efficiently processing <i>n</i> number of Observables on a smaller <i>m</i>
+     * number of resources (typically CPU cores).
+     * 
+     * @param parallelObservables
+     *            the number of Observables to merge into
+     * @param scheduler
+     *            the {@link Scheduler} to run each Observable on
+     * @return an Observable of Observables constrained in number by {@code parallelObservables}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-parallelmerge">RxJava Wiki: parallelMerge()</a>
+     */
+    public final static <T> Observable<Observable<T>> parallelMerge(Observable<Observable<T>> source, int parallelObservables, Scheduler scheduler) {
+        return OperatorParallelMerge.parallelMerge(source, parallelObservables, scheduler);
+    }
+
+    /**
+     * Pivot GroupedObservable streams without serializing/synchronizing to a single stream first.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/pivot.png">
+     *
+     * For example an Observable such as this =&gt;
+     * 
+     * {@code Observable<GroupedObservable<String, GroupedObservable<Boolean, Integer>>>}:
+     * <ul>
+     * <li>o1.odd: 1, 3, 5, 7, 9 on Thread 1</li>
+     * <li>o1.even: 2, 4, 6, 8, 10 on Thread 1</li>
+     * <li>o2.odd: 11, 13, 15, 17, 19 on Thread 2</li>
+     * <li>o2.even: 12, 14, 16, 18, 20 on Thread 2</li>
+     * </ul>
+     * is pivoted to become this =&gt;
+     * 
+     * {@code Observable<GroupedObservable<Boolean, GroupedObservable<String, Integer>>>}:
+     * <ul>
+     * <li>odd.o1: 1, 3, 5, 7, 9 on Thread 1</li>
+     * <li>odd.o2: 11, 13, 15, 17, 19 on Thread 2</li>
+     * <li>even.o1: 2, 4, 6, 8, 10 on Thread 1</li>
+     * <li>even.o2: 12, 14, 16, 18, 20 on Thread 2</li>
+     * </ul>
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/pivot.ex.png">
+     * 
+     * @param groups
+     * @return
+     */
+    public static final <K1, K2, T> Observable<GroupedObservable<K2, GroupedObservable<K1, T>>> pivot(Observable<GroupedObservable<K1, GroupedObservable<K2, T>>> groups) {
+        return groups.lift(new OperatorPivot<K1, K2, T>());
+    }
+
+    /**
+     * Returns an Observable that emits a sequence of Integers within a specified range.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/range.png">
+     * 
+     * @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
+     * @throws IllegalArgumentException
+     *             if {@code count} is less than zero
+     * @throws IllegalArgumentException
+     *             if {@code start} + {@code count} exceeds {@code Integer.MAX_VALUE}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-range">RxJava Wiki: range()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229460.aspx">MSDN: Observable.Range</a>
+     */
+    public final static Observable<Integer> range(int start, int count) {
+        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");
+        }
+        return Observable.create(new OnSubscribeRange(start, start + (count - 1)));
+    }
+
+    /**
+     * Returns an Observable that emits a sequence of Integers within a specified range, on a specified
+     * Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/range.s.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-range">RxJava Wiki: range()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211896.aspx">MSDN: Observable.Range</a>
+     */
+    public final static Observable<Integer> range(int start, int count, Scheduler scheduler) {
+        return range(start, count).subscribeOn(scheduler);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sequenceEqual.png">
+     * 
+     * @param first
+     *            the first Observable to compare
+     * @param second
+     *            the second Observable to compare
+     * @param <T>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-sequenceequal">RxJava Wiki: sequenceEqual()</a>
+     */
+    public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second) {
+        return sequenceEqual(first, second, new Func2<T, T, Boolean>() {
+            @Override
+            public final Boolean call(T first, T second) {
+                if (first == null) {
+                    return second == null;
+                }
+                return first.equals(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sequenceEqual.png">
+     * 
+     * @param first
+     *            the first Observable to compare
+     * @param second
+     *            the second Observable to compare
+     * @param equality
+     *            a function used to compare items emitted by each Observable
+     * @param <T>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-sequenceequal">RxJava Wiki: sequenceEqual()</a>
+     */
+    public final static <T> Observable<Boolean> sequenceEqual(Observable<? extends T> first, Observable<? extends T> second, Func2<? super T, ? super T, Boolean> equality) {
+        return OperatorSequenceEqual.sequenceEqual(first, second, equality);
+    }
+
+    /**
+     * Given an Observable that emits Observables, returns an Observable that emits the items emitted by the
+     * most recently emitted of those Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchDo.png">
+     * <p> {@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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-switchonnext">RxJava Wiki: switchOnNext()</a>
+     * 
+     * @param <T> the element type
+     */
+    public final static <T> Observable<T> switchOnNext(Observable<? extends Observable<? extends T>> sequenceOfSequences) {
+        return sequenceOfSequences.lift(new OperatorSwitch<T>());
+    }
+
+    /**
+     * Return an Observable that emits a 0L after the {@code initialDelay} and ever increasing numbers after
+     * each {@code period} of time thereafter.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.p.png">
+     * 
+     * @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 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava Wiki: timer()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229435.aspx">MSDN: Observable.Timer</a>
+     */
+    public final static Observable<Long> timer(long initialDelay, long period, TimeUnit unit) {
+        return timer(initialDelay, period, unit, Schedulers.computation());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.ps.png">
+     * 
+     * @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 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 Scheduler
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava Wiki: timer()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229652.aspx">MSDN: Observable.Timer</a>
+     */
+    public final static Observable<Long> timer(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperatorTimerPeriodically(initialDelay, period, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that emits one item after a specified delay, and then completes.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.png">
+     * 
+     * @param delay
+     *            the initial delay before emitting a single 0L
+     * @param unit
+     *            time units to use for {@code delay}
+     * @return an Observable that emits one item after a specified delay, and then completes
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava wiki: timer()</a>
+     */
+    public final static Observable<Long> timer(long delay, TimeUnit unit) {
+        return timer(delay, unit, Schedulers.computation());
+    }
+
+    /**
+     * Returns an Observable that emits one item after a specified delay, on a specified Scheduler, and then
+     * completes.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timer.s.png">
+     * 
+     * @param delay
+     *            the initial delay before emitting a single 0L
+     * @param unit
+     *            time units to use for {@code delay}
+     * @param scheduler
+     *            the Scheduler to use for scheduling the item
+     * @return Observable that emits one item after a specified delay, on a specified Scheduler, and then
+     * completes
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-timer">RxJava wiki: timer()</a>
+     */
+    public final static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperatorTimerOnce(delay, unit, scheduler));
+    }
+
+    /**
+     * Constructs an Observable that creates a dependent resource object.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/using.png">
+     * 
+     * @param resourceFactory
+     *            the factory function to create 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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-using">RxJava Wiki: using()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229585.aspx">MSDN: Observable.Using</a>
+     */
+    public final static <T, Resource extends Subscription> Observable<T> using(Func0<Resource> resourceFactory, Func1<Resource, ? extends Observable<? extends T>> observableFactory) {
+        return create(new OperatorUsing<T, Resource>(resourceFactory, observableFactory));
+    }
+
+    /**
+     * 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.
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * 
+     * @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
+     * @return an Observable that emits the zipped results
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <R> Observable<R> zip(Iterable<? extends Observable<?>> ws, FuncN<? extends R> zipFunction) {
+        List<Observable<?>> os = new ArrayList<Observable<?>>();
+        for (Observable<?> o : ws) {
+            os.add(o);
+        }
+        return Observable.just(os.toArray(new Observable<?>[os.size()])).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * <i>n</i> items emitted, in sequence, by the <i>n</i> Observables emitted by a specified Observable.
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.o.png">
+     * 
+     * @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
+     * @return an Observable that emits the zipped results
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <R> Observable<R> zip(Observable<? extends Observable<?>> ws, final FuncN<? extends R> zipFunction) {
+        return ws.toList().map(new Func1<List<? extends Observable<?>>, Observable<?>[]>() {
+
+            @Override
+            public Observable<?>[] call(List<? extends Observable<?>> o) {
+                return o.toArray(new Observable<?>[o.size()]);
+            }
+
+        }).lift(new OperatorZip<R>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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
+     * @return an Observable that emits the zipped results
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, final Func2<? super T1, ? super T2, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2 }).lift(new OperatorZip<R>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, T3, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2, o3 }).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * four items emitted, in sequence, by four other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, T3, T4, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2, o3, o4 }).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * five items emitted, in sequence, by five other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, T3, T4, T5, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2, o3, o4, o5 }).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * six items emitted, in sequence, by six other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, T3, T4, T5, T6, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6,
+            Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6 }).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * seven items emitted, in sequence, by seven other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, T3, T4, T5, T6, T7, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7,
+            Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7 }).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * eight items emitted, in sequence, by eight other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, T3, T4, T5, T6, T7, T8, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8 }).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits the results of a function of your choosing applied to combinations of
+     * nine items emitted, in sequence, by nine other Observables.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * <p> {@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.
+     * <p>
+     * The resulting {@code Observable<R>} 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 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 <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-zip">RxJava Wiki: zip()</a>
+     */
+    public final static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Observable<R> zip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Observable<? extends T5> o5, Observable<? extends T6> o6, Observable<? extends T7> o7, Observable<? extends T8> o8,
+            Observable<? extends T9> o9, Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> zipFunction) {
+        return just(new Observable<?>[] { o1, o2, o3, o4, o5, o6, o7, o8, o9 }).lift(new OperatorZip<R>(zipFunction));
+    }
+
+    /**
+     * Returns an Observable that emits a Boolean that indicates whether all of the items emitted by the source
+     * Observable satisfy a condition.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/all.png">
+     * 
+     * @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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-all">RxJava Wiki: all()</a>
+     */
+    public final Observable<Boolean> all(Func1<? super T, Boolean> predicate) {
+        return lift(new OperatorAll<T>(predicate));
+    }
+
+    /**
+     * 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
+     */
+    public final Observable<T> asObservable() {
+        return lift(new OperatorAsObservable<T>());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer1.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final <TClosing> Observable<List<T>> buffer(Func0<? extends Observable<? extends TClosing>> bufferClosingSelector) {
+        return lift(new OperatorBufferWithSingleObservable<T, TClosing>(bufferClosingSelector, 16));
+    }
+
+    /**
+     * Returns an Observable that emits buffers of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping buffers, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer3.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(int count) {
+        return lift(new OperatorBufferWithSize<T>(count, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer4.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(int count, int skip) {
+        return lift(new OperatorBufferWithSize<T>(count, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer7.png">
+     * 
+     * @param timespan
+     *            the period of time each buffer collects items before it is 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 {@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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit) {
+        return lift(new OperatorBufferWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, Schedulers.computation()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer7.s.png">
+     * 
+     * @param timespan
+     *            the period of time each buffer collects items before it is 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 {@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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorBufferWithTime<T>(timespan, timeshift, unit, Integer.MAX_VALUE, scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer5.png">
+     * 
+     * @param timespan
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(long timespan, TimeUnit unit) {
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, Schedulers.computation()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer6.png">
+     * 
+     * @param timespan
+     *            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)
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count) {
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, count, Schedulers.computation()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer6.s.png">
+     * 
+     * @param timespan
+     *            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)
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, count, scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer5.s.png">
+     * 
+     * @param timespan
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorBufferWithTime<T>(timespan, timespan, unit, Integer.MAX_VALUE, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer2.png">
+     * 
+     * @param bufferOpenings
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final <TOpening, TClosing> Observable<List<T>> buffer(Observable<? extends TOpening> bufferOpenings, Func1<? super TOpening, ? extends Observable<? extends TClosing>> bufferClosingSelector) {
+        return lift(new OperatorBufferWithStartEndObservable<T, TOpening, TClosing>(bufferOpenings, bufferClosingSelector));
+    }
+
+    /**
+     * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the
+     * specified boundary Observable emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer8.png">
+     * <p>
+     * Completion of either the source or the boundary Observable causes the returned Observable to emit the
+     * latest buffer and complete.
+     * 
+     * @param <B>
+     *            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
+     * @see #buffer(rx.Observable, int)
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     */
+    public final <B> Observable<List<T>> buffer(Observable<B> boundary) {
+        return lift(new OperatorBufferWithSingleObservable<T, B>(boundary, 16));
+    }
+
+    /**
+     * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the
+     * specified boundary Observable emits an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer8.png">
+     * <p>
+     * Completion of either the source or the boundary Observable causes the returned Observable to emit the
+     * latest buffer and complete.
+     * 
+     * @param <B>
+     *            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 from the source Observable when the boundary Observable
+     *         emits an item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-buffer">RxJava Wiki: buffer()</a>
+     * @see #buffer(rx.Observable, int)
+     */
+    public final <B> Observable<List<T>> buffer(Observable<B> boundary, int initialCapacity) {
+        return lift(new OperatorBufferWithSingleObservable<T, B>(boundary, initialCapacity));
+    }
+
+    /**
+     * This method has similar behavior to {@link #replay} except that this auto-subscribes to the source
+     * Observable rather than returning a {@link ConnectableObservable}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/cache.png">
+     * <p>
+     * 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.
+     * <p>
+     * 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()}.
+     * <p>
+     *
+     * <!-- IS THE FOLLOWING NOTE STILL VALID??? -->
+     *
+     * <em>Note:</em> 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-cache">RxJava Wiki: cache()</a>
+     */
+    public final Observable<T> cache() {
+        return create(new OperatorCache<T>(this));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by the source Observable, converted to the specified
+     * type.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/cast.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-cast">RxJava Wiki: cast()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211842.aspx">MSDN: Observable.Cast</a>
+     */
+    public final <R> Observable<R> cast(final Class<R> klass) {
+        return lift(new OperatorCast<T, R>(klass));
+    }
+
+    /**
+     * Collect values into a single mutable data structure.
+     * <p>
+     * This is a simplified version of {@code reduce} that does not need to return the state on each pass.
+     * <p>
+     * 
+     * @param state
+     *            FIXME FIXME FIXME
+     * @param collector
+     *            FIXME FIXME FIXME
+     * @return FIXME FIXME FIXME
+     */
+    public final <R> Observable<R> collect(R state, final Action2<R, ? super T> collector) {
+        Func2<R, T, R> accumulator = new Func2<R, T, R>() {
+
+            @Override
+            public final R call(R state, T value) {
+                collector.call(state, value);
+                return state;
+            }
+
+        };
+        return reduce(state, accumulator);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/concatMap.png">
+     * 
+     * @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
+     */
+    public final <R> Observable<R> concatMap(Func1<? super T, ? extends Observable<? extends R>> func) {
+        return concat(map(func));
+    }
+
+    /**
+     * Returns an Observable that emits a Boolean that indicates whether the source Observable emitted a
+     * specified item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/contains.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-contains">RxJava Wiki: contains()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228965.aspx">MSDN: Observable.Contains</a>
+     */
+    public final Observable<Boolean> contains(final T element) {
+        return exists(new Func1<T, Boolean>() {
+            public final Boolean call(T t1) {
+                return element == null ? t1 == null : element.equals(t1);
+            }
+        });
+    }
+
+    /**
+     * Returns an Observable that emits the count of the total number of items emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/count.png">
+     * 
+     * @return an Observable that emits a single item: the number of elements emitted by the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-count-and-longcount">RxJava Wiki: count()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229470.aspx">MSDN: Observable.Count</a>
+     * @see #longCount()
+     */
+    public final Observable<Integer> count() {
+        return reduce(0, new Func2<Integer, T, Integer>() {
+            @Override
+            public final Integer call(Integer t1, T t2) {
+                return t1 + 1;
+            }
+        });
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/debounce.f.png">
+     * 
+     * @param <U>
+     *            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
+     */
+    public final <U> Observable<T> debounce(Func1<? super T, ? extends Observable<U>> debounceSelector) {
+        return lift(new OperatorDebounceWithSelector<T, U>(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.
+     * <p>
+     * <em>Note:</em> If items keep being emitted by the source Observable faster than the timeout then no items
+     * will be emitted by the resulting Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/debounce.png">
+     * <p>
+     * Information on debounce vs throttle:
+     * <p>
+     * <ul>
+     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
+     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
+     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
+     * </ul>
+     * 
+     * @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
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: debounce()</a>
+     * @see #throttleWithTimeout(long, TimeUnit)
+     */
+    public final Observable<T> debounce(long timeout, TimeUnit unit) {
+        return lift(new OperatorDebounceWithTime<T>(timeout, unit, Schedulers.computation()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <em>Note:</em> If items keep being emitted by the source Observable faster than the timeout then no items
+     * will be emitted by the resulting Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/debounce.s.png">
+     * <p>
+     * Information on debounce vs throttle:
+     * <p>
+     * <ul>
+     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
+     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
+     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
+     * </ul>
+     * 
+     * @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
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: debounce()</a>
+     * @see #throttleWithTimeout(long, TimeUnit, Scheduler)
+     */
+    public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorDebounceWithTime<T>(timeout, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that emits the items emitted by the source Observable or a specified default item
+     * if the source Observable is empty.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/defaultIfEmpty.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-defaultifempty">RxJava Wiki: defaultIfEmpty()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229624.aspx">MSDN: Observable.DefaultIfEmpty</a>
+     */
+    public final Observable<T> defaultIfEmpty(T defaultValue) {
+        return lift(new OperatorDefaultIfEmpty<T>(defaultValue));
+    }
+
+    /**
+     * Returns an Observable that delays the subscription to and emissions from the souce Observable via another
+     * Observable on a per-item basis.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.oo.png">
+     * <p>
+     * <em>Note:</em> the resulting Observable will immediately propagate any {@code onError} notification
+     * from the source Observable.
+     * 
+     * @param <U>
+     *            the subscription delay value type (ignored)
+     * @param <V>
+     *            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
+     * @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
+     */
+    public final <U, V> Observable<T> delay(
+            Func0<? extends Observable<U>> subscriptionDelay,
+            Func1<? super T, ? extends Observable<V>> itemDelay) {
+        return create(new OperatorDelayWithSelector<T, U, V>(this, subscriptionDelay, itemDelay));
+    }
+
+    /**
+     * Returns an Observable that delays the emissions of the source Observable via another Observable on a
+     * per-item basis.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.o.png">
+     * <p>
+     * <em>Note:</em> the resulting Observable will immediately propagate any {@code onError} notification
+     * from the source Observable.
+     * 
+     * @param <U>
+     *            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
+     */
+    public final <U> Observable<T> delay(Func1<? super T, ? extends Observable<U>> itemDelay) {
+        return create(new OperatorDelayWithSelector<T, Object, U>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.png">
+     * 
+     * @param delay
+     *            the delay to shift the source by
+     * @param unit
+     *            the {@link TimeUnit} in which {@code period} is defined
+     * @return the source Observable shifted in time by the specified delay
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-delay">RxJava Wiki: delay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229810.aspx">MSDN: Observable.Delay</a>
+     */
+    public final Observable<T> delay(long delay, TimeUnit unit) {
+        return create(new OperatorDelay<T>(this, delay, unit, Schedulers.computation()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.s.png">
+     * 
+     * @param delay
+     *            the delay to shift the source by
+     * @param unit
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-delay">RxJava Wiki: delay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229280.aspx">MSDN: Observable.Delay</a>
+     */
+    public final Observable<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperatorDelay<T>(this, delay, unit, scheduler));
+    }
+
+    /**
+     * Return an Observable that delays the subscription to the source Observable by a given amount of time.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delaySubscription.png">
+     * 
+     * @param delay
+     *            the time to delay the subscription
+     * @param unit
+     *            the time unit of {@code delay}
+     * @return an Observable that delays the subscription to the source Observable by the given amount
+     */
+    public final Observable<T> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delaySubscription.s.png">
+     * 
+     * @param delay
+     *            the time to delay the subscription
+     * @param unit
+     *            the time unit of {@code delay}
+     * @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 final Observable<T> delaySubscription(long delay, TimeUnit unit, Scheduler scheduler) {
+        return create(new OperatorDelaySubscription<T>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/dematerialize.png">
+     * 
+     * @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<Notification<T>>}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dematerialize">RxJava Wiki: dematerialize()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229047.aspx">MSDN: Observable.dematerialize</a>
+     */
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public final <T2> Observable<T2> dematerialize() {
+        return lift(new OperatorDematerialize());
+    }
+
+    /**
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinct.png">
+     * 
+     * @return an Observable that emits only those items emitted by the source Observable that are distinct from
+     *         each other
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinct">RxJava Wiki: distinct()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229764.aspx">MSDN: Observable.distinct</a>
+     */
+    public final Observable<T> distinct() {
+        return lift(new OperatorDistinct<T, T>(Functions.<T>identity()));
+    }
+
+    /**
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct according
+     * to a key selector function.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinct.key.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinct">RxJava Wiki: distinct()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244310.aspx">MSDN: Observable.distinct</a>
+     */
+    public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelector) {
+        return lift(new OperatorDistinct<T, U>(keySelector));
+    }
+
+    /**
+     * Returns an Observable that emits all items emitted by the source Observable that are distinct from their
+     * immediate predecessors.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinctUntilChanged.png">
+     * 
+     * @return an Observable that emits those items from the source Observable that are distinct from their
+     *         immediate predecessors
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinctuntilchanged">RxJava Wiki: distinctUntilChanged()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229494.aspx">MSDN: Observable.distinctUntilChanged</a>
+     */
+    public final Observable<T> distinctUntilChanged() {
+        return lift(new OperatorDistinctUntilChanged<T, T>(Functions.<T>identity()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/distinctUntilChanged.key.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-distinctuntilchanged">RxJava Wiki: distinctUntilChanged()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229508.aspx">MSDN: Observable.distinctUntilChanged</a>
+     */
+    public final <U> Observable<T> distinctUntilChanged(Func1<? super T, ? extends U> keySelector) {
+        return lift(new OperatorDistinctUntilChanged<T, U>(keySelector));
+    }
+
+    /**
+     * Modifies an Observable so that it invokes an action when it calls {@code onCompleted}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnCompleted.png">
+     * 
+     * @param onCompleted
+     *            the action to invoke when the source Observable calls {@code onCompleted}
+     * @return the source Observable with the side-effecting behavior applied
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooncompleted">RxJava Wiki: doOnCompleted()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
+     */
+    public final Observable<T> doOnCompleted(final Action0 onCompleted) {
+        Observer<T> observer = new Observer<T>() {
+            @Override
+            public final void onCompleted() {
+                onCompleted.call();
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+            }
+
+            @Override
+            public final void onNext(T args) {
+            }
+
+        };
+
+        return lift(new OperatorDoOnEach<T>(observer));
+    }
+
+    /**
+     * Modifies an Observable so that it invokes an action for each item it emits.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnEach.png">
+     * 
+     * @param onNotification
+     *            the action to invoke for each item emitted by the source Observable
+     * @return the source Observable with the side-effecting behavior applied
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooneach">RxJava Wiki: doOnEach()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229307.aspx">MSDN: Observable.Do</a>
+     */
+    public final Observable<T> doOnEach(final Action1<Notification<? super T>> onNotification) {
+        Observer<T> observer = new Observer<T>() {
+            @Override
+            public final void onCompleted() {
+                onNotification.call(Notification.createOnCompleted());
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                onNotification.call(Notification.createOnError(e));
+            }
+
+            @Override
+            public final void onNext(T v) {
+                onNotification.call(Notification.createOnNext(v));
+            }
+
+        };
+
+        return lift(new OperatorDoOnEach<T>(observer));
+    }
+
+    /**
+     * Modifies an Observable so that it notifies an Observer for each item it emits.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnEach.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooneach">RxJava Wiki: doOnEach()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229307.aspx">MSDN: Observable.Do</a>
+     */
+    public final Observable<T> doOnEach(Observer<? super T> observer) {
+        return lift(new OperatorDoOnEach<T>(observer));
+    }
+
+    /**
+     * Modifies an Observable so that it invokes an action if it calls {@code onError}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnError.png">
+     * 
+     * @param onError
+     *            the action to invoke if the source Observable calls {@code onError}
+     * @return the source Observable with the side-effecting behavior applied
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-doonerror">RxJava Wiki: doOnError()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
+     */
+    public final Observable<T> doOnError(final Action1<Throwable> onError) {
+        Observer<T> observer = new Observer<T>() {
+            @Override
+            public final void onCompleted() {
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                onError.call(e);
+            }
+
+            @Override
+            public final void onNext(T args) {
+            }
+
+        };
+
+        return lift(new OperatorDoOnEach<T>(observer));
+    }
+
+    /**
+     * Modifies an Observable so that it invokes an action when it calls {@code onNext}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnNext.png">
+     * 
+     * @param onNext
+     *            the action to invoke when the source Observable calls {@code onNext}
+     * @return the source Observable with the side-effecting behavior applied
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-dooneach">RxJava Wiki: doOnNext()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
+     */
+    public final Observable<T> doOnNext(final Action1<? super T> onNext) {
+        Observer<T> observer = new Observer<T>() {
+            @Override
+            public final void onCompleted() {
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+            }
+
+            @Override
+            public final void onNext(T args) {
+                onNext.call(args);
+            }
+
+        };
+
+        return lift(new OperatorDoOnEach<T>(observer));
+    }
+
+    /**
+     * Modifies an Observable so that it invokes an action when it calls {@code onCompleted} or {@code onError}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnTerminate.png">
+     * <p>
+     * This differs from {@code finallyDo} in that this happens BEFORE onCompleted/onError are emitted.
+     * 
+     * @param onTerminate
+     *            the action to invoke when the source Observable calls {@code onCompleted} or {@code onError}
+     * @return the source Observable with the side-effecting behavior applied
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-doonterminate">RxJava Wiki: doOnTerminate()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
+     */
+    public final Observable<T> doOnTerminate(final Action0 onTerminate) {
+        Observer<T> observer = new Observer<T>() {
+            @Override
+            public final void onCompleted() {
+                onTerminate.call();
+            }
+
+            @Override
+            public final void onError(Throwable e) {
+                onTerminate.call();
+            }
+
+            @Override
+            public final void onNext(T args) {
+            }
+
+        };
+
+        return lift(new OperatorDoOnEach<T>(observer));
+    }
+
+    /**
+     * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
+     * source Observbable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAt.png">
+     * 
+     * @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
+     * @throws IndexOutOfBoundsException
+     *             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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementat">RxJava Wiki: elementAt()</a>
+     */
+    public final Observable<T> elementAt(int index) {
+        return lift(new OperatorElementAt<T>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAtOrDefault.png">
+     * 
+     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-elementatordefault">RxJava Wiki: elementAtOrDefault()</a>
+     */
+    public final Observable<T> elementAtOrDefault(int index, T defaultValue) {
+        return lift(new OperatorElementAt<T>(index, defaultValue));
+    }
+
+    /**
+     * Returns an Observable that emits {@code true} if any item emitted by the source Observable satisfies a
+     * specified condition, otherwise {@code false}. <em>Note:</em> this always emits {@code false} if the
+     * source Observable is empty.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/exists.png">
+     * <p>
+     * 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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-exists-and-isempty">RxJava Wiki: exists()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211993.aspx">MSDN: Observable.Any (Note: the description in this page was wrong at the time of this writing)</a>
+     */
+    public final Observable<Boolean> exists(Func1<? super T, Boolean> predicate) {
+        return lift(new OperatorAny<T>(predicate, false));
+    }
+
+    /**
+     * Filter items emitted by an Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/filter.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-filter-or-where">RxJava Wiki: filter()</a>
+     */
+    public final Observable<T> filter(Func1<? super T, Boolean> predicate) {
+        return lift(new OperatorFilter<T>(predicate));
+    }
+
+    /**
+     * Registers an {@link Action0} to be called when this Observable invokes either {@link Observer#onCompleted onCompleted} or {@link Observer#onError onError}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/finallyDo.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-finallydo">RxJava Wiki: finallyDo()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212133.aspx">MSDN: Observable.Finally</a>
+     */
+    public final Observable<T> finallyDo(Action0 action) {
+        return lift(new OperatorFinally<T>(action));
+    }
+
+    /**
+     * Returns an Observable that emits only the very first item emitted by the source Observable, or raises an {@code NoSuchElementException} if the source Observable is empty.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/first.png">
+     * 
+     * @return an Observable that emits only the very first item emitted by the source Observable, or raises an {@code NoSuchElementException} if the source Observable is empty
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
+     * @see "MSDN: Observable.firstAsync()"
+     */
+    public final Observable<T> first() {
+        return take(1).single();
+    }
+
+    /**
+     * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
+     * a specified condition, or raises an {@code NoSuchElementException} if no such items are emitted.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/firstN.png">
+     * 
+     * @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 NoSuchElementException} if no such items are emitted
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
+     * @see "MSDN: Observable.firstAsync()"
+     */
+    public final Observable<T> first(Func1<? super T, Boolean> predicate) {
+        return takeFirst(predicate).single();
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/firstOrDefault.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-firstordefault">RxJava Wiki: firstOrDefault()</a>
+     * @see "MSDN: Observable.firstOrDefaultAsync()"
+     */
+    public final Observable<T> 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 specified condition, or a default item if the source Observable emits no such items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/firstOrDefaultN.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-firstordefault">RxJava Wiki: firstOrDefault()</a>
+     * @see "MSDN: Observable.firstOrDefaultAsync()"
+     */
+    public final Observable<T> firstOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
+        return takeFirst(predicate).singleOrDefault(defaultValue);
+    }
+
+    /**
+     * Returns an Observable that emits items based on 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/flatMap.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-mapmany-or-flatmap-and-mapmanydelayerror">RxJava Wiki: flatMap()</a>
+     */
+    public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupBy.png">
+     * 
+     * @param keySelector
+     *            a function that extracts the key for each item
+     * @param <K>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-groupby-and-groupbyuntil">RxJava Wiki: groupBy</a>
+     */
+    public final <K> Observable<GroupedObservable<K, T>> groupBy(final Func1<? super T, ? extends K> keySelector) {
+        return lift(new OperatorGroupBy<K, T>(keySelector));
+    }
+
+    /**
+     * Groups the items emitted by an Observable according to a specified key selector function until the
+     * duration Observable expires for the key.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupByUntil.png">
+     * 
+     * @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 {@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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-groupby-and-groupbyuntil">RxJava Wiki: groupByUntil()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211932.aspx">MSDN: Observable.GroupByUntil</a>
+     */
+    public final <TKey, TDuration> Observable<GroupedObservable<TKey, T>> groupByUntil(Func1<? super T, ? extends TKey> keySelector, Func1<? super GroupedObservable<TKey, T>, ? extends Observable<? extends TDuration>> durationSelector) {
+        return groupByUntil(keySelector, Functions.<T> identity(), durationSelector);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupByUntil.png">
+     * 
+     * @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
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-groupby-and-groupbyuntil">RxJava Wiki: groupByUntil()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229433.aspx">MSDN: Observable.GroupByUntil</a>
+     */
+    public final <TKey, TValue, TDuration> Observable<GroupedObservable<TKey, TValue>> groupByUntil(Func1<? super T, ? extends TKey> keySelector, Func1<? super T, ? extends TValue> valueSelector, Func1<? super GroupedObservable<TKey, TValue>, ? extends Observable<? extends TDuration>> durationSelector) {
+        return lift(new OperatorGroupByUntil<T, TKey, TValue, TDuration>(keySelector, valueSelector, durationSelector));
+    }
+
+    /**
+     * Return an Observable that correlates two Observables when they overlap in time and groups the results.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/groupJoin.png">
+     * 
+     * @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
+     * @param rightDuration
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-join-and-groupjoin">RxJava Wiiki: groupJoin</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244235.aspx">MSDN: Observable.GroupJoin</a>
+     */
+    public final <T2, D1, D2, R> Observable<R> groupJoin(Observable<T2> right, Func1<? super T, ? extends Observable<D1>> leftDuration,
+            Func1<? super T2, ? extends Observable<D2>> rightDuration,
+            Func2<? super T, ? super Observable<T2>, ? extends R> resultSelector) {
+        return create(new OperatorGroupJoin<T, T2, D1, D2, R>(this, right, leftDuration, rightDuration, resultSelector));
+    }
+
+    /**
+     * Ignores all items emitted by the source Observable and only calls {@code onCompleted} or {@code onError}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/ignoreElements.png">
+     * 
+     * @return an empty Observable that only calls {@code onCompleted} or {@code onError}, based on which one is
+     *         called by the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-ignoreelements">RxJava Wiki: ignoreElements()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229242.aspx">MSDN: Observable.IgnoreElements</a>
+     */
+    public final Observable<T> ignoreElements() {
+        return filter(alwaysFalse());
+    }
+
+    /**
+     * Returns an Observable that emits {@code true} if the source Observable is empty, otherwise {@code false}.
+     * <p>
+     * In Rx.Net this is negated as the {@code any} Observer but we renamed this in RxJava to better match Java
+     * naming idioms.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/isEmpty.png">
+     * 
+     * @return an Observable that emits a Boolean
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-exists-and-isempty">RxJava Wiki: isEmpty()</a>
+     * @see <a href= "http://msdn.microsoft.com/en-us/library/hh229905.aspx">MSDN: Observable.Any</a>
+     */
+    public final Observable<Boolean> isEmpty() {
+        return lift(new OperatorAny<T>(Functions.alwaysTrue(), true));
+    }
+
+    /**
+     * Correlates the items emitted by two Observables based on overlapping durations.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/join_.png">
+     * 
+     * @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
+     * @param rightDurationSelector
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-join">RxJava Wiki: join()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229750.aspx">MSDN: Observable.Join</a>
+     */
+    public final <TRight, TLeftDuration, TRightDuration, R> Observable<R> join(Observable<TRight> right, Func1<T, Observable<TLeftDuration>> leftDurationSelector,
+            Func1<TRight, Observable<TRightDuration>> rightDurationSelector,
+            Func2<T, TRight, R> resultSelector) {
+        return create(new OperatorJoin<T, TRight, TLeftDuration, TRightDuration, R>(this, right, leftDurationSelector, rightDurationSelector, resultSelector));
+    }
+
+    /**
+     * Returns an Observable that emits the last item emitted by the source Observable or notifies observers of
+     * an {@code NoSuchElementException} if the source Observable is empty.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.png">
+     * 
+     * @return an Observable that emits the last item from the source Observable or notifies observers of an
+     *         error
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
+     * @see "MSDN: Observable.lastAsync()"
+     */
+    public final Observable<T> last() {
+        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 {@code NoSuchElementException} if no such items are emitted.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/last.p.png">
+     * 
+     * @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 NoSuchElementException} if no such items are emitted
+     * @throws IllegalArgumentException
+     *             if no items that match the predicate are emitted by the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observable-Operators#wiki-last">RxJava Wiki: last()</a>
+     * @see "MSDN: Observable.lastAsync()"
+     */
+    public final Observable<T> last(Func1<? super T, Boolean> 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 Observable completes without emitting any items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/lastOrDefault.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-lastOrDefault">RxJava Wiki: lastOrDefault()</a>
+     * @see "MSDN: Observable.lastOrDefaultAsync()"
+     */
+    public final Observable<T> 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
+     * specified condition, or a default item if no such item is emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/lastOrDefault.p.png">
+     * 
+     * @param defaultValue
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-lastOrDefault">RxJava Wiki: lastOrDefault()</a>
+     * @see "MSDN: Observable.lastOrDefaultAsync()"
+     */
+    public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
+        return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
+    }
+
+    /**
+     * Returns an Observable that counts the total number of items emitted by the source Observable and emits
+     * this count as a 64-bit Long.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/longCount.png">
+     * 
+     * @return an Observable that emits a single item: the number of items emitted by the source Observable as a
+     *         64-bit Long item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-count-and-longcount">RxJava Wiki: count()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229120.aspx">MSDN: Observable.LongCount</a>
+     * @see #count()
+     */
+    public final Observable<Long> longCount() {
+        return reduce(0L, new Func2<Long, T, Long>() {
+            @Override
+            public final Long call(Long t1, T t2) {
+                return t1 + 1;
+            }
+        });
+    }
+
+    /**
+     * Returns an Observable that applies a specified function to each item emitted by the source Observable and
+     * emits the results of these function applications.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/map.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-map">RxJava Wiki: map()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244306.aspx">MSDN: Observable.Select</a>
+     */
+    public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
+        return lift(new OperatorMap<T, R>(func));
+    }
+
+    /**
+     * Turns all of the emissions and notifications from a source Observable into emissions marked with their
+     * original types within {@link Notification} objects.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/materialize.png">
+     * 
+     * @return an Observable that emits items that are the result of materializing the items and notifications
+     *         of the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-materialize">RxJava Wiki: materialize()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229453.aspx">MSDN: Observable.materialize</a>
+     */
+    public final Observable<Notification<T>> materialize() {
+        return lift(new OperatorMaterialize<T>());
+    }
+
+    /**
+     * Returns an Observable that emits the results of applying a specified function 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMap.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-mapmany-or-flatmap-and-mapmanydelayerror">RxJava Wiki: flatMap()</a>
+     * @see #flatMap(Func1)
+     */
+    public final <R> Observable<R> mergeMap(Func1<? super T, ? extends Observable<? extends R>> func) {
+        return merge(map(func));
+    }
+
+    /**
+     * Returns an Observable that applies a function to each item emitted or notification raised by the source
+     * Observable and then flattens the Observables returned from these functions and emits the resulting items.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMap.nce.png">
+     * 
+     * @param <R>
+     *            the result type
+     * @param onNext
+     *            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
+     * @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
+     */
+    public final <R> Observable<R> mergeMap(
+            Func1<? super T, ? extends Observable<? extends R>> onNext,
+            Func1<? super Throwable, ? extends Observable<? extends R>> onError,
+            Func0<? extends Observable<? extends R>> onCompleted) {
+        return lift(new OperatorMergeMapTransform<T, R>(onNext, onError, onCompleted));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMap.r.png">
+     * 
+     * @param <U>
+     *            the type of items emitted by the collection Observable
+     * @param <R>
+     *            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
+     * @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
+     */
+    public final <U, R> Observable<R> mergeMap(Func1<? super T, ? extends Observable<? extends U>> collectionSelector,
+            Func2<? super T, ? super U, ? extends R> resultSelector) {
+        return lift(new OperatorMergeMapPair<T, U, R>(collectionSelector, resultSelector));
+    }
+
+    /**
+     * Returns an Observable that merges each item emitted by the source Observable with the values in an
+     * Iterable corresponding to that item that is generated by a selector.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMapIterable.png">
+     * 
+     * @param <R>
+     *            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}
+     */
+    public final <R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Iterable<? extends R>> collectionSelector) {
+        return merge(map(OperatorMergeMapPair.convertSelector(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/mergeMapIterable.r.png">
+     * 
+     * @param <U>
+     *            the collection element type
+     * @param <R>
+     *            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
+     * @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
+     */
+    public final <U, R> Observable<R> mergeMapIterable(Func1<? super T, ? extends Iterable<? extends U>> collectionSelector,
+            Func2<? super T, ? super U, ? extends R> resultSelector) {
+        return mergeMap(OperatorMergeMapPair.convertSelector(collectionSelector), resultSelector);
+    }
+
+    /**
+     * Returns an Observable that emits items produced by multicasting the source Observable within a selector
+     * function.
+     * 
+     * @param subjectFactory
+     *            the {@link Subject} factory
+     * @param selector
+     *            the selector function, which can use the multicasted source Observable subject to the policies
+     *            enforced by the created {@code Subject}
+     * @return an Observable that emits the items produced by multicasting the source Observable within a
+     *         selector function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava: Observable.publish() and Observable.multicast()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229708.aspx">MSDN: Observable.Multicast</a>
+     */
+    public final <TIntermediate, TResult> Observable<TResult> multicast(
+            final Func0<? extends Subject<? super T, ? extends TIntermediate>> subjectFactory,
+            final Func1<? super Observable<TIntermediate>, ? extends Observable<TResult>> selector) {
+        return create(new OperatorMulticastSelector<T, TIntermediate, TResult>(this, subjectFactory, selector));
+    }
+
+    /**
+     * 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 <R>
+     *            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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: Observable.publish() and
+     *      Observable.multicast()</a>
+     */
+    public final <R> ConnectableObservable<R> multicast(Subject<? super T, ? extends R> subject) {
+        return new OperatorMulticast<T, R>(this, subject);
+    }
+
+    /**
+     * Move notifications to the specified {@link Scheduler} asynchronously with an unbounded buffer.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/observeOn.png">
+     * 
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-observeon">RxJava Wiki: observeOn()</a>
+     */
+    public final Observable<T> observeOn(Scheduler scheduler) {
+        return lift(new OperatorObserveOn<T>(scheduler));
+    }
+
+    /**
+     * Filters the items emitted by an Observable, only emitting those of the specified type.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/ofClass.png">
+     * 
+     * @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 {@code klass}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-oftype">RxJava Wiki: ofType()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229380.aspx">MSDN: Observable.OfType</a>
+     */
+    public final <R> Observable<R> ofType(final Class<R> klass) {
+        return filter(new Func1<T, Boolean>() {
+            public final Boolean call(T t) {
+                return klass.isInstance(t);
+            }
+        }).cast(klass);
+    }
+
+    /**
+     * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorResumeNext.png">
+     * <p>
+     * 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.
+     * <p>
+     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorresumenext">RxJava Wiki: onErrorResumeNext()</a>
+     */
+    public final Observable<T> onErrorResumeNext(final Func1<Throwable, ? extends Observable<? extends T>> resumeFunction) {
+        return lift(new OperatorOnErrorResumeNextViaFunction<T>(resumeFunction));
+    }
+
+    /**
+     * Instruct an Observable to pass control to another Observable rather than invoking {@link Observer#onError onError} if it encounters an error.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorResumeNext.png">
+     * <p>
+     * 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.
+     * <p>
+     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorresumenext">RxJava Wiki: onErrorResumeNext()</a>
+     */
+    public final Observable<T> onErrorResumeNext(final Observable<? extends T> resumeSequence) {
+        return lift(new OperatorOnErrorResumeNextViaObservable<T>(resumeSequence));
+    }
+
+    /**
+     * Instruct an Observable to emit an item (returned by a specified function) rather than invoking {@link Observer#onError onError} if it encounters an error.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorReturn.png">
+     * <p>
+     * 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}.
+     * <p>
+     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onerrorreturn">RxJava Wiki: onErrorReturn()</a>
+     */
+    public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFunction) {
+        return lift(new OperatorOnErrorReturn<T>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onErrorFlatMap.png">
+     *
+     * @param resumeFunction
+     *            a function that accepts an {@link OnErrorThrowable} representing the Throwable issued by the
+     *            source Observable, and returns an Observable that issues items that will be emitted in place
+     *            of the error
+     * @return the original Observable, with appropriately modified behavior
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#onerrorflatmap">RxJava Wiki: onErrorFlatMap()</a>
+     */
+    public final Observable<T> onErrorFlatMap(final Func1<OnErrorThrowable, ? extends Observable<? extends T>> resumeFunction) {
+        return lift(new OperatorOnErrorFlatMap<T>(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}.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/onExceptionResumeNextViaObservable.png">
+     * <p>
+     * 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.
+     * <p>
+     * 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
+     * @return the original Observable, with appropriately modified behavior
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-onexceptionresumenext">RxJava Wiki: onExceptionResumeNext()</a>
+     */
+    public final Observable<T> onExceptionResumeNext(final Observable<? extends T> resumeSequence) {
+        return lift(new OperatorOnExceptionResumeNextViaObservable<T>(resumeSequence));
+    }
+
+    /**
+     * Perform work on the source {@code Observable<T>} in parallel by sharding it on a {@link Schedulers#computation()} {@link Scheduler}, and return the resulting {@code Observable<R>}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallel.png">
+     * 
+     * @param f
+     *            a {@link Func1} that applies Observable Observers to {@code Observable<T>} in parallel and
+     *            returns an {@code Observable<R>}
+     * @return an Observable that emits the results of applying {@code f} to the items emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-parallel">RxJava Wiki: parallel()</a>
+     */
+    public final <R> Observable<R> parallel(Func1<Observable<T>, Observable<R>> f) {
+        return lift(new OperatorParallel<T, R>(f, Schedulers.computation()));
+    }
+
+    /**
+     * Perform work on the source {@code Observable<T>} in parallel by sharding it on a {@link Scheduler}, and
+     * return the resulting {@code Observable<R>}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/parallel.png">
+     * 
+     * @param f
+     *            a {@link Func1} that applies Observable Observers to {@code Observable<T>} in parallel and
+     *            returns an {@code Observable<R>}
+     * @param s
+     *            a {@link Scheduler} to perform the work on
+     * @return an Observable that emits the results of applying {@code f} to the items emitted by the source
+     *         Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-parallel">RxJava Wiki: parallel()</a>
+     */
+    public final <R> Observable<R> parallel(final Func1<Observable<T>, Observable<R>> f, final Scheduler s) {
+        return lift(new OperatorParallel<T, R>(f, s));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.png">
+     * 
+     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit items
+     *         to its {@link Observer}s
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: publish()</a>
+     */
+    public final ConnectableObservable<T> publish() {
+        return new OperatorMulticast<T, T>(this, PublishSubject.<T> create());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.f.png">
+     * 
+     * @param <R>
+     *            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
+     */
+    public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
+        return multicast(new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return PublishSubject.create();
+            }
+        }, selector);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.if.png">
+     * 
+     * @param <R>
+     *            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
+     * @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 {@link ConnectableObservable} that shares a single subscription to the underlying Observable
+     */
+    public final <R> Observable<R> publish(Func1<? super Observable<T>, ? extends Observable<R>> selector, final T initialValue) {
+        return multicast(new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return BehaviorSubject.create(initialValue);
+            }
+        }, selector);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.i.png">
+     * 
+     * @param 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<T> publish(T initialValue) {
+        return new OperatorMulticast<T, T>(this, BehaviorSubject.<T> create(initialValue));
+    }
+
+    /**
+     * Returns a {@link ConnectableObservable} that emits only the last item emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishLast.png">
+     * 
+     * @return a {@link ConnectableObservable} that emits only the last item emitted by the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublishlast">RxJava Wiki: publishLast()</a>
+     */
+    public final ConnectableObservable<T> publishLast() {
+        return new OperatorMulticast<T, T>(this, AsyncSubject.<T> create());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishLast.f.png">
+     * 
+     * @param <R>
+     *            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 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 <R> Observable<R> publishLast(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
+        return multicast(new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/reduce.png">
+     * <p>
+     * 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
+     * @throws IllegalArgumentException
+     *             if the source Observable emits no items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-reduce">RxJava Wiki: reduce()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229154.aspx">MSDN: Observable.Aggregate</a>
+     * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
+     */
+    public final Observable<T> reduce(Func2<T, T, T> 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 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/reduceSeed.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-reduce">RxJava Wiki: reduce()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229154.aspx">MSDN: Observable.Aggregate</a>
+     * @see <a href="http://en.wikipedia.org/wiki/Fold_(higher-order_function)">Wikipedia: Fold (higher-order function)</a>
+     */
+    public final <R> Observable<R> reduce(R initialValue, Func2<R, ? super T, R> accumulator) {
+        return scan(initialValue, accumulator).takeLast(1);
+    }
+
+    /**
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.o.png">
+     * 
+     * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+     */
+    public final Observable<T> repeat() {
+        return nest().lift(new OperatorRepeat<T>());
+    }
+
+    /**
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely,
+     * on a particular Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.os.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+     */
+    public final Observable<T> repeat(Scheduler scheduler) {
+        return nest().lift(new OperatorRepeat<T>(scheduler));
+    }
+
+    /**
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most {@code count} times.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.on.png">
+     * 
+     * @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
+     * @throws IllegalArgumentException
+     *             if {@code count} is less than zero
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+     */
+    public final Observable<T> repeat(long count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("count >= 0 expected");
+        }
+        return nest().lift(new OperatorRepeat<T>(count));
+    }
+
+    /**
+     * Returns an Observable that repeats the sequence of items emitted by the source Observable at most {@code count} times, on a particular Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.ons.png">
+     * 
+     * @param count
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+     */
+    public final Observable<T> repeat(long count, Scheduler scheduler) {
+        return nest().lift(new OperatorRepeat<T>(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}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.png">
+     * 
+     * @return a {@link ConnectableObservable} that upon connection causes the source Observable to emit its
+     *         items to its {@link Observer}s
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     */
+    public final ConnectableObservable<T> replay() {
+        return new OperatorMulticast<T, T>(this, ReplaySubject.<T> create());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.f.png">
+     * 
+     * @param <R>
+     *            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 source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229653.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector) {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return ReplaySubject.create();
+            }
+        }, selector));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fn.png">
+     * 
+     * @param <R>
+     *            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
+     * @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 source Observable
+     *         replaying no more than {@code bufferSize} items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211675.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize) {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return OperatorReplay.replayBuffered(bufferSize);
+            }
+        }, selector));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fnt.png">
+     * 
+     * @param <R>
+     *            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
+     * @param bufferSize
+     *            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 source Observable, and
+     *         replays no more than {@code bufferSize} items that were emitted within the window defined by {@code time}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228952.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, int bufferSize, long time, TimeUnit unit) {
+        return replay(selector, bufferSize, time, unit, Schedulers.computation());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fnts.png">
+     * 
+     * @param <R>
+     *            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
+     * @param bufferSize
+     *            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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229404.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler) {
+        if (bufferSize < 0) {
+            throw new IllegalArgumentException("bufferSize < 0");
+        }
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return OperatorReplay.replayWindowed(time, unit, bufferSize, scheduler);
+            }
+        }, selector));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fns.png">
+     * 
+     * @param <R>
+     *            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
+     * @param bufferSize
+     *            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 source Observable,
+     *         replaying no more than {@code bufferSize} notifications
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229928.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final int bufferSize, final Scheduler scheduler) {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return OperatorReplay.<T> createScheduledSubject(OperatorReplay.<T> replayBuffered(bufferSize), scheduler);
+            }
+        }, selector));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ft.png">
+     * 
+     * @param <R>
+     *            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
+     * @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 source Observable,
+     *         replaying all items that were emitted within the window defined by {@code time}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229526.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, long time, TimeUnit unit) {
+        return replay(selector, time, unit, Schedulers.computation());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fts.png">
+     * 
+     * @param <R>
+     *            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
+     * @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 source Observable,
+     *         replaying all items that were emitted within the window defined by {@code time}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244327.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final long time, final TimeUnit unit, final Scheduler scheduler) {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return OperatorReplay.replayWindowed(time, unit, -1, scheduler);
+            }
+        }, selector));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fs.png">
+     * 
+     * @param <R>
+     *            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
+     * @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 source Observable,
+     *         replaying all items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211644.aspx">MSDN: Observable.Replay</a>
+     */
+    public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Observable<R>> selector, final Scheduler scheduler) {
+        return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
+            @Override
+            public final Subject<T, T> call() {
+                return OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler);
+            }
+        }, selector));
+    }
+
+    /**
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable that
+     * replays at most {@code bufferSize} items emitted by that Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.n.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211976.aspx">MSDN: Observable.Replay</a>
+     */
+    public final ConnectableObservable<T> replay(int bufferSize) {
+        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayBuffered(bufferSize));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nt.png">
+     * 
+     * @param bufferSize
+     *            the buffer size that limits the number of items that can be replayed
+     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229874.aspx">MSDN: Observable.Replay</a>
+     */
+    public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit unit) {
+        return replay(bufferSize, time, unit, Schedulers.computation());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nts.png">
+     * 
+     * @param bufferSize
+     *            the buffer size that limits the number of items that can be replayed
+     * @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 used as a time source for the window
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211759.aspx">MSDN: Observable.Replay</a>
+     */
+    public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit unit, Scheduler scheduler) {
+        if (bufferSize < 0) {
+            throw new IllegalArgumentException("bufferSize < 0");
+        }
+        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, bufferSize, scheduler));
+    }
+
+    /**
+     * Returns a {@link ConnectableObservable} that shares a single subscription to the source Observable and
+     * replays at most {@code bufferSize} items emitted by that Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ns.png">
+     * 
+     * @param bufferSize
+     *            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 source Observable and
+     *         replays at most {@code bufferSize} items that were emitted by the Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229814.aspx">MSDN: Observable.Replay</a>
+     */
+    public final ConnectableObservable<T> replay(int bufferSize, Scheduler scheduler) {
+        return new OperatorMulticast<T, T>(this,
+                OperatorReplay.createScheduledSubject(
+                        OperatorReplay.<T> replayBuffered(bufferSize), 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.t.png">
+     * 
+     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229232.aspx">MSDN: Observable.Replay</a>
+     */
+    public final ConnectableObservable<T> replay(long time, TimeUnit unit) {
+        return replay(time, unit, Schedulers.computation());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ts.png">
+     * 
+     * @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 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 <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211811.aspx">MSDN: Observable.Replay</a>
+     */
+    public final ConnectableObservable<T> replay(long time, TimeUnit unit, Scheduler scheduler) {
+        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, -1, 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}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.s.png">
+     * 
+     * @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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablereplay">RxJava Wiki: replay()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211699.aspx">MSDN: Observable.Replay</a>
+     */
+    public final ConnectableObservable<T> replay(Scheduler scheduler) {
+        return new OperatorMulticast<T, T>(this, OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler));
+    }
+
+    /**
+     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} (infinite retry count).
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/retry.png">
+     * <p>
+     * If the source Observable calls {@link Observer#onError}, this method will resubscribe to the source
+     * Observable rather than propagating the {@code onError} call.
+     * <p>
+     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-retry">RxJava Wiki: retry()</a>
+     */
+    public final Observable<T> retry() {
+        return nest().lift(new OperatorRetry<T>());
+    }
+
+    /**
+     * Return an Observable that mirrors the source Observable, resubscribing to it if it calls {@code onError} up to a specified number of retries.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/retry.png">
+     * <p>
+     * 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.
+     * <p>
+     * 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
+     * @return the source Observable modified with retry logic
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#wiki-retry">RxJava Wiki: retry()</a>
+     */
+    public final Observable<T> retry(int retryCount) {
+        return nest().lift(new OperatorRetry<T>(retryCount));
+    }
+
+    /**
+     * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable
+     * within periodic time intervals.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.png">
+     * 
+     * @param period
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
+     */
+    public final Observable<T> sample(long period, TimeUnit unit) {
+        return lift(new OperatorSampleWithTime<T>(period, unit, Schedulers.computation()));
+    }
+
+    /**
+     * Returns an Observable that emits the most recently emitted item (if any) emitted by the source Observable
+     * within periodic time intervals, where the intervals are defined on a particular Scheduler.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.s.png">
+     * 
+     * @param period
+     *            the sampling rate
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
+     */
+    public final Observable<T> sample(long period, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorSampleWithTime<T>(period, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that, when the specified {@code sampler} Observable emits an item or completes,
+     * emits the most recently emitted item (if any) emitted by the source Observable since the previous
+     * emission from the {@code sampler} Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sample.o.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-sample-or-throttlelast">RxJava Wiki: sample()</a>
+     */
+    public final <U> Observable<T> sample(Observable<U> sampler) {
+        return lift(new OperatorSampleWithObservable<T, U>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/scan.png">
+     * <p>
+     * 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
+     * @return an Observable that emits the results of each call to the accumulator function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-scan">RxJava Wiki: scan()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665.aspx">MSDN: Observable.Scan</a>
+     */
+    public final Observable<T> scan(Func2<T, T, T> accumulator) {
+        return lift(new OperatorScan<T, T>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/scanSeed.png">
+     * <p>
+     * This sort of function is sometimes called an accumulator.
+     * <p>
+     * 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 {@code initialValue} followed by the results of each call to the
+     *         accumulator function
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-scan">RxJava Wiki: scan()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211665.aspx">MSDN: Observable.Scan</a>
+     */
+    public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accumulator) {
+        return lift(new OperatorScan<R, T>(initialValue, accumulator));
+    }
+
+    public final Observable<T> serialize() {
+        return lift(new OperatorSerialize<T>());
+    }
+
+    /**
+     * 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 NoSuchElementException}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.png">
+     * 
+     * @return an Observable that emits the single item emitted by the source Observable
+     * @throws IllegalArgumentException
+     *             if the source emits more than one item
+     * @throws NoSuchElementException
+     *             if the source emits no items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
+     * @see "MSDN: Observable.singleAsync()"
+     */
+    public final Observable<T> single() {
+        return lift(new OperatorSingle<T>());
+    }
+
+    /**
+     * 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 NoSuchElementException}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/single.p.png">
+     * 
+     * @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 that matches the predicate
+     * @throws NoSuchElementException
+     *             if the source Observable emits no item that matches the predicate
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
+     * @see "MSDN: Observable.singleAsync()"
+     */
+    public final Observable<T> single(Func1<? super T, Boolean> predicate) {
+        return filter(predicate).single();
+    }
+
+    /**
+     * 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.} <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/singleOrDefault.png">
+     * 
+     * @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
+     * @throws IllegalArgumentException
+     *             if the source Observable emits more than one item
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
+     * @see "MSDN: Observable.singleOrDefaultAsync()"
+     */
+    public final Observable<T> singleOrDefault(T defaultValue) {
+        return lift(new OperatorSingle<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}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/singleOrDefault.p.png">
+     * 
+     * @param 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
+     * @throws IllegalArgumentException
+     *             if the source Observable emits more than one item that matches the predicate
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-single-and-singleordefault">RxJava Wiki: single()</a>
+     * @see "MSDN: Observable.singleOrDefaultAsync()"
+     */
+    public final Observable<T> singleOrDefault(T defaultValue, Func1<? super T, Boolean> predicate) {
+        return filter(predicate).singleOrDefault(defaultValue);
+    }
+
+    /**
+     * Returns an Observable that skips the first {@code num} items emitted by the source Observable and emits
+     * the remainder.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
+     */
+    public final Observable<T> skip(int num) {
+        return lift(new OperatorSkip<T>(num));
+    }
+
+    /**
+     * Returns an Observable that skips values emitted by the source Observable before a specified time window
+     * elapses.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.t.png">
+     * 
+     * @param time
+     *            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 and the emits the remainder
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
+     */
+    public final Observable<T> skip(long time, TimeUnit unit) {
+        return skip(time, unit, Schedulers.computation());
+    }
+
+    /**
+     * Returns an Observable that skips values emitted by the source Observable before a specified time window
+     * on a specified {@link Scheduler} elapses.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skip.ts.png">
+     * 
+     * @param time
+     *            the length of the time window to skip
+     * @param 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, and then emits the remainder
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skip">RxJava Wiki: skip()</a>
+     */
+    public final Observable<T> skip(long time, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorSkipTimed<T>(time, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that drops a specified number of items from the end of the sequence emitted by the
+     * source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.png">
+     * <p>
+     * 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
+     * @throws IndexOutOfBoundsException
+     *             if {@code count} is less than zero
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skiplast">RxJava Wiki: skipLast()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
+     */
+    public final Observable<T> skipLast(int count) {
+        return lift(new OperatorSkipLast<T>(count));
+    }
+
+    /**
+     * Returns an Observable that drops items emitted by the source Observable during a specified time window
+     * before the source completes.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.t.png">
+     *
+     * Note: this action will cache the latest items arriving in the specified time window.
+     * 
+     * @param time
+     *            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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skiplast">RxJava Wiki: skipLast()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
+     */
+    public final Observable<T> skipLast(long time, TimeUnit unit) {
+        return skipLast(time, unit, Schedulers.computation());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipLast.ts.png">
+     *
+     * Note: this action will cache the latest items arriving in the specified time window.
+     *
+     * @param time
+     *            the length of the time window
+     * @param 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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skiplast">RxJava Wiki: skipLast()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211750.aspx">MSDN: Observable.SkipLast</a>
+     */
+    public final Observable<T> skipLast(long time, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorSkipLastTimed<T>(time, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that skips items emitted by the source Observable until a second Observable emits
+     * an item.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipUntil.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skipuntil">RxJava Wiki: skipUntil()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229358.aspx">MSDN: Observable.SkipUntil</a>
+     */
+    public final <U> Observable<T> skipUntil(Observable<U> other) {
+        return lift(new OperatorSkipUntil<T, U>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipWhile.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-skipwhile-and-skipwhilewithindex">RxJava Wiki: skipWhile()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229685.aspx">MSDN: Observable.SkipWhile</a>
+     */
+    public final Observable<T> skipWhile(Func1<? super T, Boolean> predicate) {
+        return lift(new OperatorSkipWhile<T>(OperatorSkipWhile.toPredicate2(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipWhileWithIndex.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-skipwhile-and-skipwhilewithindex">RxJava Wiki: skipWhileWithIndex()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211631.aspx">MSDN: Observable.SkipWhile</a>
+     */
+    public final Observable<T> skipWhileWithIndex(Func2<? super T, Integer, Boolean> predicate) {
+        return lift(new OperatorSkipWhile<T>(predicate));
+    }
+
+    /**
+     * Returns an Observable that emits the items in a specified {@link Observable} before it begins to emit
+     * items emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.o.png">
+     * 
+     * @param values
+     *            an Observable that contains the items you want the modified Observable to emit first
+     * @return an Observable that emits the items in the specified {@link Observable} and then emits the items
+     *         emitted by the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(Observable<T> values) {
+        return concat(values, this);
+    }
+
+    /**
+     * Returns an Observable that emits the items in a specified {@link Iterable} before it begins to emit items
+     * emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(Iterable<T> values) {
+        return concat(Observable.<T> from(values), this);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.s.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229372.aspx">MSDN: Observable.StartWith</a>
+     */
+    public final Observable<T> startWith(Iterable<T> values, Scheduler scheduler) {
+        return concat(from(values, scheduler), this);
+    }
+
+    /**
+     * Returns an Observable that emits a specified item before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1) {
+        return concat(Observable.<T> from(t1), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2) {
+        return concat(Observable.<T> from(t1, t2), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param t1
+     *            the first item to emit
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2, T t3) {
+        return concat(Observable.<T> from(t1, t2, t3), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param t1
+     *            the first item to emit
+     * @param t2
+     *            the second item to emit
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2, T t3, T t4) {
+        return concat(Observable.<T> from(t1, t2, t3, t4), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param t1
+     *            the first item to emit
+     * @param t2
+     *            the second item to emit
+     * @param t3
+     *            the third item to emit
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5) {
+        return concat(Observable.<T> from(t1, t2, t3, t4, t5), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param t1
+     *            the first item to emit
+     * @param t2
+     *            the second item to emit
+     * @param t3
+     *            the third item to emit
+     * @param t4
+     *            the fourth item to emit
+     * @param t5
+     *            the fifth item to emit
+     * @param t6
+     *            the sixth item to emit
+     * @return an Observable that emits the specified items before it begins to emit items emitted
+     *         by the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6) {
+        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param t1
+     *            the first item to emit
+     * @param t2
+     *            the second item to emit
+     * @param t3
+     *            the third item to emit
+     * @param t4
+     *            the fourth item to emit
+     * @param t5
+     *            the fifth item to emit
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7) {
+        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6, t7), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param t1
+     *            the first item to emit
+     * @param t2
+     *            the second item to emit
+     * @param t3
+     *            the third item to emit
+     * @param t4
+     *            the fourth item to emit
+     * @param t5
+     *            the fifth item to emit
+     * @param t6
+     *            the sixth item to emit
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8) {
+        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6, t7, t8), this);
+    }
+
+    /**
+     * Returns an Observable that emits the specified items before it begins to emit items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+     * 
+     * @param t1
+     *            the first item to emit
+     * @param t2
+     *            the second item to emit
+     * @param t3
+     *            the third item to emit
+     * @param t4
+     *            the fourth item to emit
+     * @param t5
+     *            the fifth item to emit
+     * @param t6
+     *            the sixth item to emit
+     * @param t7
+     *            the seventh item to emit
+     * @param t8
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     */
+    public final Observable<T> startWith(T t1, T t2, T t3, T t4, T t5, T t6, T t7, T t8, T t9) {
+        return concat(Observable.<T> from(t1, t2, t3, t4, t5, t6, t7, t8, t9), this);
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.s.png">
+     * 
+     * @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.
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-startwith">RxJava Wiki: startWith()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229372.aspx">MSDN: Observable.StartWith</a>
+     */
+    public final Observable<T> startWith(T[] values, Scheduler scheduler) {
+        return startWith(Arrays.asList(values), 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
+     * @throws OnErrorNotImplementedException
+     *             if the Observable tries to call {@code onError}
+     */
+    public final Subscription subscribe() {
+        return subscribe(new Subscriber<T>() {
+
+            @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
+            }
+
+        });
+    }
+
+    /**
+     * 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
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     */
+    public final Subscription subscribe(final Action1<? super T> onNext) {
+        if (onNext == null) {
+            throw new IllegalArgumentException("onNext can not be null");
+        }
+
+        return subscribe(new Subscriber<T>() {
+
+            @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);
+            }
+
+        });
+    }
+
+    /**
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws IllegalArgumentException
+     *             if {@code onError} is null
+     */
+    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError) {
+        if (onNext == null) {
+            throw new IllegalArgumentException("onNext can not be null");
+        }
+        if (onError == null) {
+            throw new IllegalArgumentException("onError can not be null");
+        }
+
+        return subscribe(new Subscriber<T>() {
+
+            @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);
+            }
+
+        });
+    }
+
+    /**
+     * 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
+     * @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
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws IllegalArgumentException
+     *             if {@code onError} is null
+     * @throws IllegalArgumentException
+     *             if {@code onComplete} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     */
+    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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 subscribe(new Subscriber<T>() {
+
+            @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);
+            }
+
+        });
+    }
+
+    /**
+     * 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
+     * @param onComplete
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     */
+    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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
+     *            FIXME FIXME FIXME
+     * @param onError
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     */
+    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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
+     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     */
+    public final Subscription subscribe(final Action1<? super T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     */
+    public final Subscription subscribe(final Observer<? super T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     */
+    public final Subscription subscribe(final Observer<? super T> observer) {
+        return subscribe(new Subscriber<T>() {
+
+            @Override
+            public void onCompleted() {
+                observer.onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                observer.onError(e);
+            }
+
+            @Override
+            public void onNext(T t) {
+                observer.onNext(t);
+            }
+
+        });
+    }
+
+    /**
+     * Subscribe to Observable and invoke {@link OnSubscribe} function without any
+     * contract protection, error handling, unsubscribe, or execution hooks.
+     * <p>
+     * This should only be used for implementing an {@link Operator} that requires nested subscriptions.
+     * <p>
+     * Normal use should use {@link #subscribe(Subscriber)} which ensures the Rx contract and other functionality.
+     * 
+     * @param subscriber
+     * @return Subscription which is the Subscriber passed in
+     */
+    public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
+        try {
+            onSubscribe.call(subscriber);
+        } catch (Throwable e) {
+            if (e instanceof OnErrorNotImplementedException) {
+                throw (OnErrorNotImplementedException) e;
+            }
+            // handle broken contracts: https://github.com/Netflix/RxJava/issues/1090
+            subscriber.onError(e);
+        }
+        return subscriber;
+    }
+
+    /**
+     * A {@link Subscriber} must call an Observable's {@code subscribe} method in order to receive items and
+     * notifications from the Observable.
+     * <p>
+     * A typical implementation of {@code subscribe} does the following:
+     * <ol>
+     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>} object.</li>
+     * <li>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.</li>
+     * </ol><p>
+     * An {@code Observable<T>} instance is responsible for accepting all subscriptions and notifying all
+     * Subscribers. Unless the documentation for a particular {@code Observable<T>} implementation indicates
+     * otherwise, Subscriber should make no assumptions about the order in which multiple Subscribers will
+     * receive their notifications.
+     * <p>
+     * For more information see the
+     * <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
+     * 
+     * @param subscriber
+     *            the {@link Subscriber}
+     * @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<? super T> subscriber) {
+        // allow the hook to intercept and/or decorate
+        OnSubscribe<T> onSubscribeFunction = hook.onSubscribeStart(this, onSubscribe);
+        // validate and proceed
+        if (subscriber == 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 Observer"
+             */
+            // if not already wrapped
+            if (!(subscriber instanceof SafeSubscriber)) {
+                // assign to `observer` so we return the protected version
+                subscriber = new SafeSubscriber<T>(subscriber);
+            }
+            onSubscribeFunction.call(subscriber);
+            final Subscription returnSubscription = hook.onSubscribeReturn(subscriber);
+            // 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 (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 {
+                subscriber.onError(hook.onSubscribeError(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);
+                // TODO could the hook be the cause of the error in the on error handling.
+                hook.onSubscribeError(r);
+                // TODO why aren't we throwing the hook's return value.
+                throw r;
+            }
+            return Subscriptions.empty();
+        }
+    }
+
+    /**
+     * A {@link Subscriber} must call an Observable's {@code subscribe} method in order to receive items and
+     * notifications from the Observable.
+     * <p>
+     * A typical implementation of {@code subscribe} does the following:
+     * <ol>
+     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>} object.</li>
+     * <li>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.</li>
+     * </ol><p>
+     * An {@code Observable<T>} instance is responsible for accepting all subscriptions and notifying all
+     * Subscribers. Unless the documentation for a particular {@code Observable<T>} implementation indicates
+     * otherwise, Subscribers should make no assumptions about the order in which multiple Subscribers will
+     * receive their notifications.
+     * <p>
+     * For more information see the
+     * <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
+     * 
+     * @param observer
+     *            the {@link Subscriber}
+     * @param scheduler
+     *            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}
+     */
+    public final Subscription subscribe(Subscriber<? super T> observer, Scheduler scheduler) {
+        return subscribeOn(scheduler).subscribe(observer);
+    }
+
+    /**
+     * Asynchronously subscribes Observers to this Observable on the specified {@link Scheduler}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/subscribeOn.png">
+     * 
+     * @param scheduler
+     *            the {@link Scheduler} to perform subscription actions on
+     * @return the source Observable modified so that its subscriptions happen on the
+     *         specified {@link Scheduler}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-subscribeon">RxJava Wiki: subscribeOn()</a>
+     */
+    public final Observable<T> subscribeOn(Scheduler scheduler) {
+        return nest().lift(new OperatorSubscribeOn<T>(scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/switchMap.png">
+     * 
+     * @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
+     */
+    public final <R> Observable<R> switchMap(Func1<? super T, ? extends Observable<? extends R>> func) {
+        return switchOnNext(map(func));
+    }
+
+    /**
+     * Returns an Observable that emits only the first {@code num} items emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
+     */
+    public final Observable<T> take(final int num) {
+        return lift(new OperatorTake<T>(num));
+    }
+
+    /**
+     * Returns an Observable that emits those items emitted by source Observable before a specified time runs
+     * out.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.t.png">
+     * 
+     * @param time
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
+     */
+    public final Observable<T> take(long time, TimeUnit unit) {
+        return take(time, unit, Schedulers.computation());
+    }
+
+    /**
+     * Returns an Observable that emits those items emitted by source Observable before a specified time (on a
+     * specified Scheduler) runs out.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.ts.png">
+     * 
+     * @param time
+     *            the length of the time window
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
+     */
+    public final Observable<T> take(long time, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorTakeTimed<T>(time, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that emits only the very first item emitted by the source Observable that satisfies
+     * a specified condition.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeFirstN.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-first">RxJava Wiki: first()</a>
+     * @see "MSDN: Observable.firstAsync()"
+     */
+    public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) {
+        return filter(predicate).take(1);
+    }
+
+    /**
+     * Returns an Observable that emits only the last {@code count} items emitted by the source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.n.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-takelast">RxJava Wiki: takeLast()</a>
+     */
+    public final Observable<T> takeLast(final int count) {
+        return create(OperationTakeLast.takeLast(this, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.tn.png">
+     * 
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            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
+     */
+    public final Observable<T> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.tns.png">
+     * 
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window
+     * @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 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<T> 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 that emits the items from the source Observable that were emitted in a specified
+     * window of time before the Observable completed.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.t.png">
+     * 
+     * @param time
+     *            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}
+     */
+    public final Observable<T> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.ts.png">
+     * 
+     * @param time
+     *            the length of the time window
+     * @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 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<T> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.png">
+     * 
+     * @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
+     */
+    public final Observable<List<T>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.tn.png">
+     * 
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            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
+     */
+    public final Observable<List<T>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.tns.png">
+     * 
+     * @param count
+     *            the maximum number of items to emit
+     * @param time
+     *            the length of the time window
+     * @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
+     */
+    public final Observable<List<T>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.t.png">
+     * 
+     * @param time
+     *            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
+     */
+    public final Observable<List<T>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLastBuffer.ts.png">
+     * 
+     * @param time
+     *            the length of the time window
+     * @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 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<List<T>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeUntil.png">
+     * 
+     * @param other
+     *            the Observable whose first emitted item will cause {@code takeUntil} to stop emitting items
+     *            from the source Observable
+     * @param <E>
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takeuntil">RxJava Wiki: takeUntil()</a>
+     */
+    public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
+        return OperationTakeUntil.takeUntil(this, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeWhile.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhile()</a>
+     */
+    public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate) {
+        return lift(new OperatorTakeWhile(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeWhileWithIndex.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhileWithIndex()</a>
+     */
+    public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Integer, Boolean> predicate) {
+        return lift(new OperatorTakeWhile(predicate));
+    }
+
+    /**
+     * Returns an Observable that emits only the first item emitted by the source Observable during sequential
+     * time windows of a specified duration.
+     * <p>
+     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleFirst.png">
+     * 
+     * @param windowDuration
+     *            time to wait before emitting another item after emitting the last item
+     * @param unit
+     *            the unit of time of {@code windowDuration}
+     * @return an Observable that performs the throttle operation
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlefirst">RxJava Wiki: throttleFirst()</a>
+     */
+    public final Observable<T> throttleFirst(long windowDuration, TimeUnit unit) {
+        return lift(new OperatorThrottleFirst<T>(windowDuration, unit, Schedulers.computation()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * This differs from {@link #throttleLast} in that this only tracks passage of time whereas {@link #throttleLast} ticks at scheduled intervals.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleFirst.s.png">
+     * 
+     * @param skipDuration
+     *            time to wait before emitting another item after emitting the last item
+     * @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
+     * @return an Observable that performs the throttle operation
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlefirst">RxJava Wiki: throttleFirst()</a>
+     */
+    public final Observable<T> throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) {
+        return lift(new OperatorThrottleFirst<T>(skipDuration, unit, scheduler));
+    }
+
+    /**
+     * Returns an Observable that emits only the last item emitted by the source Observable during sequential
+     * time windows of a specified duration.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleLast.png">
+     * 
+     * @param intervalDuration
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-takelast">RxJava Wiki: throttleLast()</a>
+     * @see #sample(long, TimeUnit)
+     */
+    public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit) {
+        return sample(intervalDuration, 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.
+     * <p>
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleLast.s.png">
+     * 
+     * @param intervalDuration
+     *            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
+     * @return an Observable that performs the throttle operation
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-takelast">RxJava Wiki: throttleLast()</a>
+     * @see #sample(long, TimeUnit, Scheduler)
+     */
+    public final Observable<T> throttleLast(long intervalDuration, TimeUnit unit, Scheduler scheduler) {
+        return sample(intervalDuration, unit, 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.
+     * <p>
+     * <em>Note:</em> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleWithTimeout.png">
+     * <p>
+     * Information on debounce vs throttle:
+     * <p>
+     * <ul>
+     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
+     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
+     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
+     * </ul>
+     * 
+     * @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
+     * @param unit
+     *            the {@link TimeUnit} of {@code timeout}
+     * @return an Observable that filters out items that are too quickly followed by newer items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: throttleWithTimeout()</a>
+     * @see #debounce(long, TimeUnit)
+     */
+    public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
+        return debounce(timeout, 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.
+     * <p>
+     * <em>Note:</em> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/throttleWithTimeout.s.png">
+     * <p>
+     * Information on debounce vs throttle:
+     * <p>
+     * <ul>
+     * <li><a href="http://drupalmotion.com/article/debounce-and-throttle-visual-explanation">Debounce and Throttle: visual explanation</a></li>
+     * <li><a href="http://unscriptable.com/2009/03/20/debouncing-javascript-methods/">Debouncing: javascript methods</a></li>
+     * <li><a href="http://www.illyriad.co.uk/blog/index.php/2011/09/javascript-dont-spam-your-server-debounce-and-throttle/">Javascript - don't spam your server: debounce and throttle</a></li>
+     * </ul>
+     * 
+     * @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
+     * @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
+     * @return an Observable that filters out items that are too quickly followed by newer items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-throttlewithtimeout-or-debounce">RxJava Wiki: throttleWithTimeout()</a>
+     * @see #debounce(long, TimeUnit, Scheduler)
+     */
+    public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
+        return debounce(timeout, unit, scheduler);
+    }
+
+    /**
+     * Returns an Observable that emits records of the time interval between consecutive items emitted by the
+     * source Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeInterval.png">
+     * 
+     * @return an Observable that emits time interval information items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timeinterval">RxJava Wiki: timeInterval()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
+     */
+    public final Observable<TimeInterval<T>> timeInterval() {
+        return lift(new OperatorTimeInterval(Schedulers.immediate()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeInterval.s.png">
+     * 
+     * @param scheduler
+     *            the {@link Scheduler} used to compute time intervals
+     * @return an Observable that emits time interval information items
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timeinterval">RxJava Wiki: timeInterval()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
+     */
+    public final Observable<TimeInterval<T>> timeInterval(Scheduler scheduler) {
+        return lift(new OperatorTimeInterval(scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout5.png">
+     * 
+     * @param <U>
+     *            the first timeout value type (ignored)
+     * @param <V>
+     *            the subsequent timeout value type (ignored)
+     * @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 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 <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout6.png">
+     * 
+     * @param <U>
+     *            the first timeout value type (ignored)
+     * @param <V>
+     *            the subsequent timeout value type (ignored)
+     * @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
+     * @throws NullPointerException
+     *             if {@code timeoutSelector} is null
+     */
+    public final <U, V> Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> other) {
+        if (timeoutSelector == null) {
+            throw new NullPointerException("timeoutSelector is null");
+        }
+        return lift(new OperatorTimeoutWithSelector<T, U, V>(firstTimeoutSelector, timeoutSelector, other));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout3.png">
+     * <p>
+     * Note: The arrival of the first source item is never timed out.
+     * 
+     * @param <V>
+     *            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
+     * @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 <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout4.png">
+     * <p>
+     * Note: The arrival of the first source item is never timed out.
+     * 
+     * @param <V>
+     *            the timeout value type (ignored)
+     * @param timeoutSelector
+     *            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 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 <V> Observable<T> timeout(Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> 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}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.1.png">
+     * 
+     * @param timeout
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh244283.aspx">MSDN: Observable.Timeout</a>
+     */
+    public final Observable<T> timeout(long timeout, TimeUnit timeUnit) {
+        return timeout(timeout, timeUnit, null, Schedulers.computation());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.2.png">
+     * 
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229512.aspx">MSDN: Observable.Timeout</a>
+     */
+    public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<? extends T> other) {
+        return timeout(timeout, timeUnit, other, Schedulers.computation());
+    }
+
+    /**
+     * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted
+     * item using a specified Scheduler. If the next item isn't emitted within the specified timeout duration
+     * starting from its predecessor, the resulting Observable begins instead to mirror a fallback Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.2s.png">
+     * 
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time that applies to the {@code timeout} argument
+     * @param other
+     *            the Observable to use as the fallback in case of a timeout
+     * @param scheduler
+     *            the {@link 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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh211676.aspx">MSDN: Observable.Timeout</a>
+     */
+    public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<? extends T> other, Scheduler scheduler) {
+        return lift(new OperatorTimeout<T>(timeout, timeUnit, other, scheduler));
+    }
+
+    /**
+     * Returns an Observable that mirrors the source Observable but applies a timeout policy for each emitted
+     * item, where this policy is governed on a specified Scheduler. If the next item isn't emitted within the
+     * specified timeout duration starting from its predecessor, the resulting Observable terminates and
+     * notifies observers of a {@code TimeoutException}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeout.1s.png">
+     * 
+     * @param timeout
+     *            maximum duration between items before a timeout occurs
+     * @param timeUnit
+     *            the unit of time that applies to the {@code timeout} argument
+     * @param scheduler
+     *            the Scheduler to run the timeout timers on
+     * @return the source Observable modified to notify observers of a {@code TimeoutException} in case of a
+     *         timeout
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-timeout">RxJava Wiki: timeout()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh228946.aspx">MSDN: Observable.Timeout</a>
+     */
+    public final Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler) {
+        return timeout(timeout, timeUnit, null, scheduler);
+    }
+
+    /**
+     * Returns an Observable that emits each item emitted by the source Observable, wrapped in a {@link Timestamped} object.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timestamp.png">
+     * 
+     * @return an Observable that emits timestamped items from the source Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timestamp">RxJava Wiki: timestamp()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229003.aspx">MSDN: Observable.Timestamp</a>
+     */
+    public final Observable<Timestamped<T>> timestamp() {
+        return timestamp(Schedulers.immediate());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timestamp.s.png">
+     * 
+     * @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}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-timestamp">RxJava Wiki: timestamp()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229003.aspx">MSDN: Observable.Timestamp</a>
+     */
+    public final Observable<Timestamped<T>> timestamp(Scheduler scheduler) {
+        return lift(new OperatorTimestamp<T>(scheduler));
+    }
+
+    /**
+     * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking operators).
+     * 
+     * @return a {@code BlockingObservable} version of this Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators">RxJava Wiki: Blocking Observable Observers</a>
+     */
+    public final BlockingObservable<T> toBlockingObservable() {
+        return BlockingObservable.from(this);
+    }
+
+    /**
+     * Returns an Observable that emits a single item, a list composed of all the items emitted by the source
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toList.png">
+     * <p>
+     * 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.
+     * <p>
+     *
+     * <!-- IS THE FOLLOWING NOTE STILL VALID? -->
+     *
+     * 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 <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tolist">RxJava Wiki: toList()</a>
+     */
+    public final Observable<List<T>> toList() {
+        return lift(new OperatorToObservableList<T>());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229137.aspx">MSDN: Observable.ToDictionary</a>
+     */
+    public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySelector) {
+        return lift(new OperatorToMap<T, K, T>(keySelector, Functions.<T>identity()));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212075.aspx">MSDN: Observable.ToDictionary</a>
+     */
+    public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
+        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMap.png">
+     * 
+     * @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
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
+     */
+    public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, V>> mapFactory) {
+        return lift(new OperatorToMap<T, K, V>(keySelector, valueSelector, mapFactory));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh212098.aspx">MSDN: Observable.ToLookup</a>
+     */
+    public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ? extends K> keySelector) {
+        return lift(new OperatorToMultimap<T, K, T>(keySelector, Functions.<T>identity()));
+    }
+
+    /**
+     * Return an Observable that emits a single HashMap that contains an ArrayList of values extracted by a
+     * specified {@code valueSelector} function from items emitted by the source Observable, keyed by a
+     * specified {@code keySelector} function.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
+     * 
+     * @param keySelector
+     *            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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
+     * @see <a href="http://msdn.microsoft.com/en-us/library/hh229101.aspx">MSDN: Observable.ToLookup</a>
+     */
+    public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector) {
+        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector));
+    }
+
+    /**
+     * Return an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that
+     * contains an ArrayList of values, extracted by a specified {@code valueSelector} function from items
+     * emitted by the source Observable and keyed by the {@code keySelector} function.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
+     * 
+     * @param keySelector
+     *            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
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
+     */
+    public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory) {
+        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory));
+    }
+
+    /**
+     * Return an Observable that emits a single Map, returned by a specified {@code mapFactory} function, that
+     * contains a custom collection of values, extracted by a specified {@code valueSelector} function from
+     * items emitted by the source Observable, and keyed by the {@code keySelector} function.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toMultiMap.png">
+     * 
+     * @param keySelector
+     *            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
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tomap-and-tomultimap">RxJava Wiki: toMap()</a>
+     */
+    public final <K, V> Observable<Map<K, Collection<V>>> toMultimap(Func1<? super T, ? extends K> keySelector, Func1<? super T, ? extends V> valueSelector, Func0<? extends Map<K, Collection<V>>> mapFactory, Func1<? super K, ? extends Collection<V>> collectionFactory) {
+        return lift(new OperatorToMultimap<T, K, V>(keySelector, valueSelector, mapFactory, collectionFactory));
+    }
+
+    /**
+     * Returns an Observable that emits a list that contains 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toSortedList.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tosortedlist">RxJava Wiki: toSortedList()</a>
+     */
+    public final Observable<List<T>> toSortedList() {
+        return lift(new OperatorToObservableSortedList<T>());
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toSortedList.f.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Mathematical-and-Aggregate-Operators#wiki-tosortedlist">RxJava Wiki: toSortedList()</a>
+     */
+    public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Integer> sortFunction) {
+        return lift(new OperatorToObservableSortedList<T>(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<T> unsubscribeOn(Scheduler scheduler) {
+        return lift(new OperatorUnsubscribeOn<T>(scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window1.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final <TClosing> Observable<Observable<T>> window(Func0<? extends Observable<? extends TClosing>> closingSelector) {
+        return create(OperationWindow.window(this, closingSelector));
+    }
+
+    /**
+     * Returns an Observable that emits windows of items it collects from the source Observable. The resulting
+     * Observable emits connected, non-overlapping windows, each containing {@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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window3.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(int count) {
+        return create(OperationWindow.window(this, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window4.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(int count, int skip) {
+        return create(OperationWindow.window(this, count, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window7.png">
+     * 
+     * @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 {@code timespan} and {@code timeshift} arguments
+     * @return an Observable that emits new windows periodically as a fixed timespan elapses
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(long timespan, long timeshift, TimeUnit unit) {
+        return create(OperationWindow.window(this, timespan, timeshift, unit));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window7.s.png">
+     * 
+     * @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 {@code timespan} and {@code timeshift} arguments
+     * @param scheduler
+     *            the {@link Scheduler} to use when determining the end and start of a window
+     * @return an Observable that emits new windows periodically as a fixed timespan elapses
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(long timespan, long timeshift, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationWindow.window(this, timespan, timeshift, unit, scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window5.png">
+     * 
+     * @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 {@code timespan} argument
+     * @return an Observable that emits connected, non-overlapping windows represending items emitted by the
+     *         source Observable during fixed, consecutive durations
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(long timespan, TimeUnit unit) {
+        return create(OperationWindow.window(this, timespan, 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window6.png">
+     * 
+     * @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 {@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)
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int count) {
+        return create(OperationWindow.window(this, timespan, unit, count));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window6.s.png">
+     * 
+     * @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 {@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)
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(long timespan, TimeUnit unit, int count, Scheduler scheduler) {
+        return create(OperationWindow.window(this, timespan, unit, count, scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window5.s.png">
+     * 
+     * @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 {@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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final Observable<Observable<T>> window(long timespan, TimeUnit unit, Scheduler scheduler) {
+        return create(OperationWindow.window(this, timespan, unit, scheduler));
+    }
+
+    /**
+     * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window2.png">
+     * 
+     * @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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Transforming-Observables#wiki-window">RxJava Wiki: window()</a>
+     */
+    public final <TOpening, TClosing> Observable<Observable<T>> window(Observable<? extends TOpening> windowOpenings, Func1<? super TOpening, ? extends Observable<? extends TClosing>> closingSelector) {
+        return create(OperationWindow.window(this, windowOpenings, closingSelector));
+    }
+
+    /**
+     * Returns an Observable that 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 a specified boundary-governing
+     * Observable.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/window8.png">
+     * 
+     * @param <U>
+     *            the window element type (ignored)
+     * @param boundary
+     *            an Observable whose emitted items close and open windows
+     * @return an Observable that 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 {@code boundary} Observable
+     */
+    public final <U> Observable<Observable<T>> window(Observable<U> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.i.png">
+     * <p>
+     * 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 <T2>
+     *            the type of items in the {@code other} Iterable
+     * @param <R>
+     *            the type of items emitted by the resulting Observable
+     * @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
+     */
+    public final <T2, R> Observable<R> zip(Iterable<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
+        return lift(new OperatorZipIterable<T, T2, R>(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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/zip.png">
+     * 
+     * @param <T2>
+     *            the type of items emitted by the {@code other} Observable
+     * @param <R>
+     *            the type of items emitted by the resulting Observable
+     * @param other
+     *            the other Observable
+     * @param zipFunction
+     *            a function that combines the pairs of items from the two Observables 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} Observable
+     *         and emits the results of {@code zipFunction} applied to these pairs
+     */
+    public final <T2, R> Observable<R> zip(Observable<? extends T2> other, Func2<? super T, ? super T2, ? extends R> zipFunction) {
+        return zip(this, other, zipFunction);
+    }
+
+    /**
+     * An Observable that never sends any information to an {@link Observer}.
+     * 
+     * This Observable is useful primarily for testing purposes.
+     * 
+     * @param <T>
+     *            the type of item (not) emitted by the Observable
+     */
+    private static class NeverObservable<T> extends Observable<T> {
+        public NeverObservable() {
+            super(new OnSubscribe<T>() {
+
+                @Override
+                public void call(Subscriber<? super T> observer) {
+                    // do nothing
+                }
+
+            });
+        }
+    }
+
+    /**
+     * An Observable that invokes {@link Observer#onError onError} when the {@link Observer} subscribes to it.
+     * 
+     * @param <T>
+     *            the type of item (ostensibly) emitted by the Observable
+     */
+    private static class ThrowObservable<T> extends Observable<T> {
+
+        public ThrowObservable(final Throwable exception) {
+            super(new OnSubscribe<T>() {
+
+                /**
+                 * 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 void call(Subscriber<? super T> observer) {
+                    observer.onError(exception);
+                }
+
+            });
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperationDelay.java b/rxjava-core/src/main/java/rx/operators/OperationDelay.java
deleted file mode 100644
index 79d03b2264..0000000000
--- a/rxjava-core/src/main/java/rx/operators/OperationDelay.java
+++ /dev/null
@@ -1,307 +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 rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Scheduler;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.functions.Action0;
-import rx.functions.Func0;
-import rx.functions.Func1;
-import rx.observables.ConnectableObservable;
-import rx.observers.Subscribers;
-import rx.subscriptions.CompositeSubscription;
-import rx.subscriptions.SerialSubscription;
-import rx.subscriptions.Subscriptions;
-
-public final class OperationDelay {
-
-    public static <T> Observable<T> delay(Observable<T> observable, final long delay, final TimeUnit unit, final Scheduler scheduler) {
-        // observable.map(x => Observable.timer(t).map(_ => x).startItAlreadyNow()).concat()
-        Observable<Observable<T>> seqs = observable.map(new Func1<T, Observable<T>>() {
-            public Observable<T> call(final T x) {
-                ConnectableObservable<T> co = Observable.timer(delay, unit, scheduler).map(new Func1<Long, T>() {
-                    @Override
-                    public T call(Long ignored) {
-                        return x;
-                    }
-                }).replay();
-                co.connect();
-                return co;
-            }
-        });
-        return Observable.concat(seqs);
-    }
-
-    /**
-     * Delays the subscription to the source by the given amount, running on the given scheduler.
-     */
-    public static <T> OnSubscribeFunc<T> delaySubscription(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
-        return new DelaySubscribeFunc<T>(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<T> implements OnSubscribeFunc<T> {
-        final Observable<? extends T> source;
-        final Scheduler.Worker scheduler;
-        final long time;
-        final TimeUnit unit;
-
-        public DelaySubscribeFunc(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
-            this.source = source;
-            this.scheduler = scheduler.createWorker();
-            this.time = time;
-            this.unit = unit;
-        }
-
-        @Override
-        public Subscription onSubscribe(final Observer<? super T> t1) {
-            final SerialSubscription ssub = new SerialSubscription();
-
-            ssub.set(scheduler.schedule(new Action0() {
-                @Override
-                public void call() {
-                    if (!ssub.isUnsubscribed()) {
-                        ssub.set(source.unsafeSubscribe(Subscribers.from(t1)));
-                    }
-                }
-            }, time, unit));
-
-            return ssub;
-        }
-    }
-
-    /**
-     * Delay the emission of the source items by a per-item observable that fires its first element.
-     */
-    public static <T, U> OnSubscribeFunc<T> delay(Observable<? extends T> source,
-            Func1<? super T, ? extends Observable<U>> itemDelay) {
-        return new DelayViaObservable<T, Object, U>(source, null, itemDelay);
-    }
-
-    /**
-     * Delay the subscription and emission of the source items by a per-item observable that fires its first element.
-     */
-    public static <T, U, V> OnSubscribeFunc<T> delay(Observable<? extends T> source,
-            Func0<? extends Observable<U>> subscriptionDelay,
-            Func1<? super T, ? extends Observable<V>> itemDelay) {
-        return new DelayViaObservable<T, U, V>(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<T, U, V> implements OnSubscribeFunc<T> {
-        final Observable<? extends T> source;
-        final Func0<? extends Observable<U>> subscriptionDelay;
-        final Func1<? super T, ? extends Observable<V>> itemDelay;
-
-        public DelayViaObservable(Observable<? extends T> source,
-                Func0<? extends Observable<U>> subscriptionDelay,
-                Func1<? super T, ? extends Observable<V>> itemDelay) {
-            this.source = source;
-            this.subscriptionDelay = subscriptionDelay;
-            this.itemDelay = itemDelay;
-        }
-
-        @Override
-        public Subscription onSubscribe(Observer<? super T> t1) {
-            CompositeSubscription csub = new CompositeSubscription();
-
-            SerialSubscription sosub = new SerialSubscription();
-            csub.add(sosub);
-            SourceObserver<T, V> so = new SourceObserver<T, V>(t1, itemDelay, csub, sosub);
-            if (subscriptionDelay == null) {
-                sosub.set(source.unsafeSubscribe(so));
-            } else {
-                Observable<U> subscriptionSource;
-                try {
-                    subscriptionSource = subscriptionDelay.call();
-                } catch (Throwable t) {
-                    t1.onError(t);
-                    return Subscriptions.empty();
-                }
-                SerialSubscription ssub = new SerialSubscription();
-                csub.add(ssub);
-                ssub.set(subscriptionSource.unsafeSubscribe(new SubscribeDelay<T, U, V>(source, so, csub, ssub)));
-            }
-
-            return csub;
-        }
-
-        /** Subscribe delay observer. */
-        private static final class SubscribeDelay<T, U, V> extends Subscriber<U> {
-            final Observable<? extends T> source;
-            final SourceObserver<T, V> so;
-            final CompositeSubscription csub;
-            final Subscription self;
-            /** Prevent any onError once the first item was delivered. */
-            boolean subscribed;
-
-            public SubscribeDelay(
-                    Observable<? extends T> source,
-                    SourceObserver<T, V> so,
-                    CompositeSubscription csub, Subscription self) {
-                this.source = source;
-                this.so = so;
-                this.csub = csub;
-                this.self = self;
-            }
-
-            @Override
-            public void onNext(U args) {
-                onCompleted();
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                if (!subscribed) {
-                    so.observer.onError(e);
-                    csub.unsubscribe();
-                }
-            }
-
-            @Override
-            public void onCompleted() {
-                subscribed = true;
-                csub.remove(self);
-                so.self.set(source.unsafeSubscribe(so));
-            }
-        }
-
-        /** The source observer. */
-        private static final class SourceObserver<T, U> extends Subscriber<T> {
-            final Observer<? super T> observer;
-            final Func1<? super T, ? extends Observable<U>> 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<? super T> observer,
-                    Func1<? super T, ? extends Observable<U>> itemDelay,
-                    CompositeSubscription csub,
-                    SerialSubscription self) {
-                this.observer = observer;
-                this.itemDelay = itemDelay;
-                this.csub = csub;
-                this.guard = new Object();
-                this.self = self;
-            }
-
-            @Override
-            public void onNext(T args) {
-                Observable<U> delayer;
-                try {
-                    delayer = itemDelay.call(args);
-                } catch (Throwable t) {
-                    onError(t);
-                    return;
-                }
-
-                synchronized (guard) {
-                    wip++;
-                }
-
-                SerialSubscription ssub = new SerialSubscription();
-                csub.add(ssub);
-                ssub.set(delayer.unsafeSubscribe(new DelayObserver<T, U>(args, this, ssub)));
-            }
-
-            @Override
-            public void onError(Throwable e) {
-                synchronized (guard) {
-                    observer.onError(e);
-                }
-                csub.unsubscribe();
-            }
-
-            @Override
-            public void onCompleted() {
-                boolean b;
-                synchronized (guard) {
-                    done = true;
-                    b = checkDone();
-                }
-                if (b) {
-                    csub.unsubscribe();
-                } else {
-                    self.unsubscribe();
-                }
-            }
-
-            void emit(T value, Subscription token) {
-                boolean b;
-                synchronized (guard) {
-                    observer.onNext(value);
-                    wip--;
-                    b = checkDone();
-                }
-                if (b) {
-                    csub.unsubscribe();
-                } else {
-                    csub.remove(token);
-                }
-            }
-
-            boolean checkDone() {
-                if (done && wip == 0) {
-                    observer.onCompleted();
-                    return true;
-                }
-                return false;
-            }
-        }
-
-        /**
-         * Delay observer.
-         */
-        private static final class DelayObserver<T, U> extends Subscriber<U> {
-            final T value;
-            final SourceObserver<T, U> parent;
-            final Subscription token;
-
-            public DelayObserver(T value, SourceObserver<T, U> 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.emit(value, token);
-            }
-
-        }
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDelay.java b/rxjava-core/src/main/java/rx/operators/OperatorDelay.java
new file mode 100644
index 0000000000..9f7bad5c21
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDelay.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.TimeUnit;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.functions.Func1;
+
+/**
+ * Delays the emission of onNext events by a given amount of time.
+ * @param <T> the value type
+ */
+public final class OperatorDelay<T> implements OnSubscribe<T> {
+
+    final Observable<? extends T> source;
+    final long delay;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+
+    public OperatorDelay(Observable<? extends T> source, long delay, TimeUnit unit, Scheduler scheduler) {
+        this.source = source;
+        this.delay = delay;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> child) {
+        final Worker worker = scheduler.createWorker();
+        child.add(worker);
+        
+        Observable.concat(source.map(new Func1<T, Observable<T>>() {
+            @Override
+            public Observable<T> call(T x) {
+                Emitter<T> e = new Emitter<T>(x);
+                worker.schedule(e, delay, unit);
+                return Observable.create(e);
+            }
+        })).subscribe(child);
+    }
+    
+    /**
+     * Emits a value once the call() is invoked.
+     * Only one subscriber can wait for the emission.
+     * @param <T> the value type
+     */
+    public static final class Emitter<T> implements OnSubscribe<T>, Action0 {
+        final T value;
+        
+        final Object guard;
+        /** Guarded by guard. */
+        Subscriber<? super T> child;
+        /** Guarded by guard. */
+        boolean done;
+
+        public Emitter(T value) {
+            this.value = value;
+            this.guard = new Object();
+        }
+        
+        @Override
+        public void call(Subscriber<? super T> s) {
+            synchronized (guard) {
+                if (!done) {
+                    child = s;
+                    return;
+                }
+            }
+            s.onNext(value);
+            s.onCompleted();
+        }
+
+        @Override
+        public void call() {
+            Subscriber<? super T> s;
+            synchronized (guard) {
+                done = true;
+                s = child;
+                child = null;
+            }
+            if (s != null) {
+                s.onNext(value);
+                s.onCompleted();
+            }
+        }
+    }
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDelaySubscription.java b/rxjava-core/src/main/java/rx/operators/OperatorDelaySubscription.java
new file mode 100644
index 0000000000..ed5c8cf5b3
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDelaySubscription.java
@@ -0,0 +1,59 @@
+/**
+ * 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.Observable.OnSubscribe;
+import rx.Scheduler;
+import rx.Scheduler.Worker;
+import rx.Subscriber;
+import rx.functions.Action0;
+
+/**
+ * Delays the subscription to the source by the given amount, running on the given scheduler.
+ * 
+ * @param <T> the value type
+ */
+public final class OperatorDelaySubscription<T> implements OnSubscribe<T> {
+    final Observable<? extends T> source;
+    final long time;
+    final TimeUnit unit;
+    final Scheduler scheduler;
+
+    public OperatorDelaySubscription(Observable<? extends T> source, long time, TimeUnit unit, Scheduler scheduler) {
+        this.source = source;
+        this.time = time;
+        this.unit = unit;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void call(final Subscriber<? super T> s) {
+        final Worker worker = scheduler.createWorker();
+        s.add(worker);
+
+        worker.schedule(new Action0() {
+            @Override
+            public void call() {
+                if (!s.isUnsubscribed()) {
+                    source.unsafeSubscribe(s);
+                }
+            }
+        }, time, unit);
+    }
+    
+}
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorDelayWithSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorDelayWithSelector.java
new file mode 100644
index 0000000000..af3e702bba
--- /dev/null
+++ b/rxjava-core/src/main/java/rx/operators/OperatorDelayWithSelector.java
@@ -0,0 +1,134 @@
+/**
+ * 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.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.observers.SerializedSubscriber;
+import rx.operators.OperatorDelay.Emitter;
+import rx.subscriptions.CompositeSubscription;
+
+/**
+ * Delay the subscription and emission of the source items by a per-item observable that fires its first element.
+ * @param <T> the item type
+ * @param <U> the value type of the subscription-delaying observable
+ * @param <V> the value type of the item-delaying observable
+ */
+public final class OperatorDelayWithSelector<T, U, V> implements OnSubscribe<T> {
+    final Observable<? extends T> source;
+    final Func0<? extends Observable<U>> subscriptionDelay;
+    final Func1<? super T, ? extends Observable<V>> itemDelay;
+
+    public OperatorDelayWithSelector(Observable<? extends T> source, Func1<? super T, ? extends Observable<V>> itemDelay) {
+        this.source = source;
+        this.subscriptionDelay = new Func0<Observable<U>>() {
+            @Override
+            public Observable<U> call() {
+                return Observable.just(null);
+            }
+        };
+        this.itemDelay = itemDelay;
+    }
+
+    public OperatorDelayWithSelector(Observable<? extends T> source, Func0<? extends Observable<U>> subscriptionDelay, Func1<? super T, ? extends Observable<V>> itemDelay) {
+        this.source = source;
+        this.subscriptionDelay = subscriptionDelay;
+        this.itemDelay = itemDelay;
+    }
+
+    @Override
+    public void call(Subscriber<? super T> child) {
+        final SerializedSubscriber<T> s = new SerializedSubscriber<T>(child);
+        final CompositeSubscription csub = new CompositeSubscription();
+        child.add(csub);
+        
+        Observable<U> osub;
+        try {
+            osub = subscriptionDelay.call();
+        } catch (Throwable e) {
+            s.onError(e);
+            return;
+        }
+        
+        Observable<Observable<T>> seqs = source.map(new Func1<T, Observable<T>>() {
+            @Override
+            public Observable<T> call(final T x) {
+                final Emitter<T> e = new Emitter<T>(x);
+                Observable<V> itemObs = itemDelay.call(x);
+
+                Subscriber<V> itemSub = new Subscriber<V>() {
+                    boolean once = true;
+                    @Override
+                    public void onNext(V t) {
+                        emit();
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        s.onError(e);
+                        s.unsubscribe();
+                    }
+
+                    @Override
+                    public void onCompleted() {
+                        emit();
+                    }
+                    void emit() {
+                        if (once) {
+                            once = false;
+                            e.call();
+                            csub.remove(this);
+                        }
+                    }
+                };
+                csub.add(itemSub);
+                itemObs.unsafeSubscribe(itemSub);
+                
+                return Observable.create(e);
+            }
+        });
+        final Observable<T> delayed = Observable.merge(seqs);
+        
+        Subscriber<U> osubSub = new Subscriber<U>(child) {
+            boolean subscribed;
+            @Override
+            public void onNext(U ignored) {
+                onCompleted();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                if (!subscribed) {
+                    s.onError(e);
+                    unsubscribe();
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                if (!subscribed) {
+                    subscribed = true;
+                    delayed.unsafeSubscribe(s);
+                }
+            }
+        };
+        
+        osub.unsafeSubscribe(osubSub);
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDelayTest.java
similarity index 84%
rename from rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorDelayTest.java
index 1bc8cd0bfc..67357b4fe1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationDelayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDelayTest.java
@@ -29,9 +29,9 @@
 import java.util.concurrent.TimeUnit;
 
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.InOrder;
+import static org.mockito.Matchers.anyInt;
 import org.mockito.Mock;
 
 import rx.Observable;
@@ -42,7 +42,7 @@
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-public class OperationDelayTest {
+public class OperatorDelayTest {
     @Mock
     private Observer<Long> observer;
     @Mock
@@ -157,8 +157,6 @@ public Long call(Long value) {
         verify(observer, never()).onCompleted();
     }
 
-    // TODO activate this test once https://github.com/Netflix/RxJava/issues/552 is fixed
-    @Ignore
     @Test
     public void testDelayWithMultipleSubscriptions() {
         Observable<Long> source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3);
@@ -202,10 +200,9 @@ public void testDelayWithMultipleSubscriptions() {
 
     @Test
     public void testDelaySubscription() {
-        TestScheduler scheduler = new TestScheduler();
-
         Observable<Integer> result = Observable.from(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
 
@@ -226,10 +223,9 @@ public void testDelaySubscription() {
 
     @Test
     public void testDelaySubscriptionCancelBeforeTime() {
-        TestScheduler scheduler = new TestScheduler();
-
         Observable<Integer> result = Observable.from(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         Subscription s = result.subscribe(o);
@@ -549,4 +545,96 @@ public Observable<Integer> call(Integer t1) {
         verify(o, never()).onError(any(Throwable.class));
         verify(o, never()).onCompleted();
     }
+    
+    @Test
+    public void testDelayWithObservableAsTimed() {
+        Observable<Long> source = Observable.interval(1L, TimeUnit.SECONDS, scheduler).take(3);
+        
+        final Observable<Long> delayer = Observable.timer(500L, TimeUnit.MILLISECONDS, scheduler);
+        
+        Func1<Long, Observable<Long>> delayFunc = new Func1<Long, Observable<Long>>() {
+            @Override
+            public Observable<Long> call(Long t1) {
+                return delayer;
+            }
+        };
+        
+        Observable<Long> delayed = source.delay(delayFunc);
+        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 testDelayWithObservableReorder() {
+        int n = 3;
+
+        PublishSubject<Integer> source = PublishSubject.create();
+        final List<PublishSubject<Integer>> subjects = new ArrayList<PublishSubject<Integer>>();
+        for (int i = 0; i < n; i++) {
+            subjects.add(PublishSubject.<Integer>create());
+        }
+        
+        Observable<Integer> result = source.delay(new Func1<Integer, Observable<Integer>>() {
+
+            @Override
+            public Observable<Integer> call(Integer t1) {
+                return subjects.get(t1);
+            }
+        });
+        
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        result.subscribe(o);
+        
+        for (int i = 0; i < n; i++) {
+            source.onNext(i);
+        }
+        source.onCompleted();
+        
+        inOrder.verify(o, never()).onNext(anyInt());
+        inOrder.verify(o, never()).onCompleted();
+        
+        for (int i = n - 1; i >= 0; i--) {
+            subjects.get(i).onCompleted();
+            inOrder.verify(o).onNext(i);
+        }
+        
+        inOrder.verify(o).onCompleted();
+        
+        verify(o, never()).onError(any(Throwable.class));
+    }
 }

From cdc0c2fefd3a8edecbca63b4287b64a341f549cb Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 5 May 2014 12:55:19 -0700
Subject: [PATCH 329/422] Make final

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

diff --git a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 2f6a886c61..089b428b0b 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -23,7 +23,7 @@
 /**
  * Static factory methods for creating Schedulers.
  */
-public class Schedulers {
+public final class Schedulers {
 
     private final Scheduler computationScheduler;
     private final Scheduler ioScheduler;

From 42fa5aab312a4bf38558d6ec07b0f4a7596e13f3 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Mon, 5 May 2014 13:13:20 -0700
Subject: [PATCH 330/422] Fix ReplaySubject termination race

---
 .../main/java/rx/subjects/ReplaySubject.java  | 43 ++++++++++++-------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index d37f7820b1..bd5f16b571 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -25,6 +25,7 @@
 import rx.Observer;
 import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.operators.NotificationLite;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
 /**
@@ -127,7 +128,7 @@ public void onCompleted() {
 
             @Override
             public void call() {
-                state.history.complete(Notification.<T> createOnCompleted());
+                state.history.complete();
             }
         });
         if (observers != null) {
@@ -145,7 +146,7 @@ public void onError(final Throwable e) {
 
             @Override
             public void call() {
-                state.history.complete(Notification.<T> createOnError(e));
+                state.history.complete(e);
             }
         });
         if (observers != null) {
@@ -159,7 +160,7 @@ public void call() {
 
     @Override
     public void onNext(T v) {
-        if (state.history.terminalValue.get() != null) {
+        if (state.history.terminated) {
             return;
         }
         state.history.next(v);
@@ -200,12 +201,9 @@ private void replayObserver(SubjectObserver<? super T> observer) {
 
     private static <T> int replayObserverFromIndex(History<T> history, Integer l, SubjectObserver<? super T> observer) {
         while (l < history.index.get()) {
-            observer.onNext(history.list.get(l));
+            history.accept(observer, l);
             l++;
         }
-        if (history.terminalValue.get() != null) {
-            history.terminalValue.get().accept(observer);
-        }
 
         return l;
     }
@@ -217,19 +215,19 @@ private static <T> int replayObserverFromIndex(History<T> history, Integer l, Su
      * @param <T>
      */
     private static class History<T> {
+        private final NotificationLite<T> nl = NotificationLite.instance();
         private final AtomicInteger index;
-        private final ArrayList<T> list;
-        private final AtomicReference<Notification<T>> terminalValue;
+        private final ArrayList<Object> list;
+        private boolean terminated;
 
         public History(int initialCapacity) {
             index = new AtomicInteger(0);
-            list = new ArrayList<T>(initialCapacity);
-            terminalValue = new AtomicReference<Notification<T>>();
+            list = new ArrayList<Object>(initialCapacity);
         }
 
         public boolean next(T n) {
-            if (terminalValue.get() == null) {
-                list.add(n);
+            if (!terminated) {
+                list.add(nl.next(n));
                 index.getAndIncrement();
                 return true;
             } else {
@@ -237,8 +235,23 @@ public boolean next(T n) {
             }
         }
 
-        public void complete(Notification<T> n) {
-            terminalValue.set(n);
+        public void accept(Observer<? super T> o, int idx) {
+            nl.accept(o, list.get(idx));
+        }
+        
+        public void complete() {
+            if (!terminated) {
+                terminated = true;
+                list.add(nl.completed());
+                index.getAndIncrement();
+            }
+        }
+        public void complete(Throwable e) {
+            if (!terminated) {
+                terminated = true;
+                list.add(nl.error(e));
+                index.getAndIncrement();
+            }
         }
     }
 

From 4f55f958202102cb70ffa63bc7c9441b46fa039d Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Mon, 5 May 2014 13:40:12 -0700
Subject: [PATCH 331/422] ReplaySubject testRaceForTerminalState()

---
 .../ReplaySubjectConcurrencyTest.java         | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index ced51e9608..354701b041 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -17,9 +17,7 @@
 
 import static org.junit.Assert.assertEquals;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
@@ -32,6 +30,8 @@
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action1;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 
 public class ReplaySubjectConcurrencyTest {
@@ -303,6 +303,21 @@ public void run() {
         }
 
     }
+    
+    /**
+     * https://github.com/Netflix/RxJava/issues/1147
+     */
+    @Test
+    public void testRaceForTerminalState() {
+        final List<Integer> expected = Arrays.asList(1);
+        for (int i = 0; i < 100000; i++) {
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            Observable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts);
+            ts.awaitTerminalEvent();
+            ts.assertReceivedOnNext(expected);
+            ts.assertTerminalEvent();
+        }
+    }
 
     private static class SubjectObserverThread extends Thread {
 

From 8273d609d64f9f80490b20e8ac2b22a388e0fcd5 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Mon, 5 May 2014 20:59:03 +0000
Subject: [PATCH 332/422] [Gradle Release Plugin] - pre tag commit:  '0.18.2'.

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

diff --git a/gradle.properties b/gradle.properties
index ba85b03230..e9f68a221c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.2-SNAPSHOT
+version=0.18.2

From 43fd6eeb9479f2676c605a2f6516c008eaa06b2c Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Mon, 5 May 2014 20:59:08 +0000
Subject: [PATCH 333/422] [Gradle Release Plugin] - new version commit: 
 '0.18.3-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index e9f68a221c..061f9ca491 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.2
+version=0.18.3-SNAPSHOT

From 29f564a3a30144443b56ba2fc203f9ea139a4db8 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 5 May 2014 14:11:52 -0700
Subject: [PATCH 334/422] Version 0.18.2

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

diff --git a/CHANGES.md b/CHANGES.md
index fa5ddaccb6..49ae3853e3 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,48 @@
 # RxJava Releases #
 
+### Version 0.18.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.2%22)) ###
+
+
+* [Pull 1150] (https://github.com/Netflix/RxJava/pull/1150) Fix ReplaySubject Terminal State Race Condition
+* [Pull 1144] (https://github.com/Netflix/RxJava/pull/1144) Operator Delay rebase & fixes
+* [Pull 1142] (https://github.com/Netflix/RxJava/pull/1142) Update 'contains' signature to 'contains(Object)'
+* [Pull 1134] (https://github.com/Netflix/RxJava/pull/1134) OperatorTakeLast
+* [Pull 1135] (https://github.com/Netflix/RxJava/pull/1135) OperatorTakeUntil
+* [Pull 1137] (https://github.com/Netflix/RxJava/pull/1137) Random fixes to operators multicast, sample, refCount
+* [Pull 1138] (https://github.com/Netflix/RxJava/pull/1138) Operator Window and other changes
+* [Pull 1131] (https://github.com/Netflix/RxJava/pull/1131) Operator TakeTimed
+* [Pull 1130] (https://github.com/Netflix/RxJava/pull/1130) Operator Switch
+* [Pull 1129] (https://github.com/Netflix/RxJava/pull/1129) Conditional statements contribution to Operator
+* [Pull 1128] (https://github.com/Netflix/RxJava/pull/1128) Fix for SerializedObserverTest
+* [Pull 1126] (https://github.com/Netflix/RxJava/pull/1126) Operator When
+* [Pull 1125] (https://github.com/Netflix/RxJava/pull/1125) Operator contrib math
+* [Pull 1124] (https://github.com/Netflix/RxJava/pull/1124) Add lift to rxscala
+* [Pull 1122] (https://github.com/Netflix/RxJava/pull/1122) OperatorSkipUntil
+* [Pull 1121] (https://github.com/Netflix/RxJava/pull/1121) OperatorSkipTimed
+* [Pull 1120] (https://github.com/Netflix/RxJava/pull/1120) OperatorSequenceEqual
+* [Pull 1119] (https://github.com/Netflix/RxJava/pull/1119) OperatorRefCount
+* [Pull 1118] (https://github.com/Netflix/RxJava/pull/1118) Operator ParallelMerge
+* [Pull 1117] (https://github.com/Netflix/RxJava/pull/1117) Operator OnExceptionResumeNextViaObservable
+* [Pull 1115] (https://github.com/Netflix/RxJava/pull/1115) OperatorTakeWhile
+* [Pull 1112] (https://github.com/Netflix/RxJava/pull/1112) OperatorThrottleFirst
+* [Pull 1111] (https://github.com/Netflix/RxJava/pull/1111) OperatorTimeInterval
+* [Pull 1110] (https://github.com/Netflix/RxJava/pull/1110) OperatorOnErrorReturn
+* [Pull 1109] (https://github.com/Netflix/RxJava/pull/1109) OperatorOnErrorResumeNextViaObservable
+* [Pull 1108] (https://github.com/Netflix/RxJava/pull/1108) OperatorMulticastAndReplay
+* [Pull 1107] (https://github.com/Netflix/RxJava/pull/1107) Fix ReplaySubject's double termination problem.
+* [Pull 1106] (https://github.com/Netflix/RxJava/pull/1106) OperatorMergeMaxConcurrent
+* [Pull 1104] (https://github.com/Netflix/RxJava/pull/1104) Operator merge delay error
+* [Pull 1103] (https://github.com/Netflix/RxJava/pull/1103) OperatorJoin
+* [Pull 1101] (https://github.com/Netflix/RxJava/pull/1101) Operator async
+* [Pull 1100] (https://github.com/Netflix/RxJava/pull/1100) OperatorUsing
+* [Pull 1099] (https://github.com/Netflix/RxJava/pull/1099) OperatorToMap
+* [Pull 1098] (https://github.com/Netflix/RxJava/pull/1098) OperatorTimerAndSample
+* [Pull 1097] (https://github.com/Netflix/RxJava/pull/1097) OperatorToMultimap
+* [Pull 1096] (https://github.com/Netflix/RxJava/pull/1096) OperatorGroupJoin
+* [Pull 1095] (https://github.com/Netflix/RxJava/pull/1095) OperatorGroupByUntil
+* [Pull 1094] (https://github.com/Netflix/RxJava/pull/1094) Operator debounce
+
+
 ### Version 0.18.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.1%22)) ###
 
 * [Pull 1065] (https://github.com/Netflix/RxJava/pull/1065) Optimize OperatorSkipLastTimed

From baf568d2d4d4d92d615c64e0f4120125a0d62ac2 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sat, 3 May 2014 15:07:24 +0800
Subject: [PATCH 335/422] Add 'dropUntil' to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala     |  9 +++++++++
 .../main/scala/rx/lang/scala/Observable.scala    | 16 ++++++++++++++++
 .../scala/rx/lang/scala/CompletenessTest.scala   |  1 +
 3 files changed, 26 insertions(+)

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 7d1ee11cd3..307b7886c9 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
@@ -426,6 +426,15 @@ class RxScalaDemo extends JUnitSuite {
     )
   }
 
+  @Test def dropUntilExample() {
+    val o = List("Alice", "Bob", "Carlos").toObservable.zip(
+      Observable.interval(700 millis, IOScheduler())).map(_._1) // emit every 700 millis
+    val other = List(1).toObservable.delay(1 seconds)
+    println(
+      o.dropUntil(other).toBlockingObservable.toList // output List("Bob", "Carlos")
+    )
+  }
+
   def square(x: Int): Int = {
     println(s"$x*$x is being calculated on thread ${Thread.currentThread().getId}")
     Thread.sleep(100) // calculating a square is heavy work :)
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 35eae53767..2510b14551 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
@@ -1327,6 +1327,22 @@ trait Observable[+T]
     toScalaObservable(asJavaObservable.skipLast(time.length, time.unit, scheduler))
   }
 
+  /**
+   * Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/skipUntil.png">
+   *
+   * @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
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-skipuntil">RxJava Wiki: skipUntil()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229358.aspx">MSDN: Observable.SkipUntil</a>
+   */
+  def dropUntil[E](other: Observable[E]): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.skipUntil(other))
+  }
+
   /**
    * Returns an Observable that emits only the first `num` items emitted by the source
    * Observable.
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 eca5168da5..3a64c36a44 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
@@ -98,6 +98,7 @@ class CompletenessTest extends JUnitSuite {
       "skip(Long, TimeUnit, Scheduler)" -> "drop(Duration, Scheduler)",
       "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)",
       "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary,
+      "skipUntil(Observable[U])" -> "dropUntil(Observable[E])",
       "startWith(Iterable[T])" -> "[unnecessary because we can just use `++` instead]",
       "skipLast(Int)" -> "dropRight(Int)",
       "skipLast(Long, TimeUnit)" -> "dropRight(Duration)",

From bb788092a437580889a476604bdb1ccdb7b7b3ff Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sat, 3 May 2014 16:00:25 +0800
Subject: [PATCH 336/422] Add 'contains' to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala     |  9 +++++++++
 .../main/scala/rx/lang/scala/Observable.scala    | 16 ++++++++++++++++
 .../scala/rx/lang/scala/CompletenessTest.scala   |  1 +
 3 files changed, 26 insertions(+)

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 307b7886c9..6ed20db2a3 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
@@ -25,6 +25,7 @@ import scala.language.implicitConversions
 
 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
@@ -645,6 +646,14 @@ class RxScalaDemo extends JUnitSuite {
     println(m.toBlockingObservable.single)
   }
 
+  @Test def containsExample(): Unit = {
+    val o1 = List(1, 2, 3).toObservable.contains(2)
+    assertTrue(o1.toBlockingObservable.single)
+
+    val o2 = List(1, 2, 3).toObservable.contains(4)
+    assertFalse(o2.toBlockingObservable.single)
+  }
+
   @Test def retryExample1(): Unit = {
     val o : Observable[String] = List("alice", "bob", "carol").toObservable
     assertEquals(List("alice", "bob", "carol"), o.retry.toBlockingObservable.toList)
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 2510b14551..d7c5a8aeb1 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
@@ -1061,6 +1061,22 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.cache())
   }
 
+  /**
+   * Returns an Observable that emits a Boolean that indicates whether the source Observable emitted a
+   * specified item.
+   *
+   * Note: this method uses `==` to compare elements. It's a bit different from RxJava which uses `Object.equals`.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/contains.png">
+   *
+   *@param elem 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
+   */
+  def contains(elem: Any): Observable[Boolean] = {
+    exists(_ == elem)
+  }
+
   /**
    * Returns a a pair of a start function and an [[rx.lang.scala.Observable]], which waits until the start function is called before it begins emitting
    * items to those [[rx.lang.scala.Observer]]s that have subscribed to it.
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 3a64c36a44..6e36756d54 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
@@ -71,6 +71,7 @@ class CompletenessTest extends JUnitSuite {
       "all(Func1[_ >: T, Boolean])" -> "forall(T => Boolean)",
       "buffer(Long, Long, TimeUnit)" -> "buffer(Duration, Duration)",
       "buffer(Long, Long, TimeUnit, Scheduler)" -> "buffer(Duration, Duration, Scheduler)",
+      "contains(T)" -> "contains(Any)",
       "count()" -> "length",
       "dematerialize()" -> "dematerialize(<:<[Observable[T], Observable[Notification[U]]])",
       "elementAt(Int)" -> "[use `.drop(index).first`]",

From d5074f43a0f60cdb9556041676dcec9a8565b374 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sat, 3 May 2014 23:54:36 +0800
Subject: [PATCH 337/422] Add 'repeat' to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 10 +++
 .../main/scala/rx/lang/scala/Observable.scala | 62 +++++++++++++++++++
 .../rx/lang/scala/CompletenessTest.scala      |  2 +
 3 files changed, 74 insertions(+)

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 6ed20db2a3..f8b0dba233 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
@@ -654,6 +654,16 @@ class RxScalaDemo extends JUnitSuite {
     assertFalse(o2.toBlockingObservable.single)
   }
 
+  @Test def repeatExample1(): Unit = {
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable.repeat().take(6)
+    assertEquals(List("alice", "bob", "carol", "alice", "bob", "carol"), o.toBlockingObservable.toList)
+  }
+
+  @Test def repeatExample2(): Unit = {
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable.repeat(2)
+    assertEquals(List("alice", "bob", "carol", "alice", "bob", "carol"), o.toBlockingObservable.toList)
+  }
+
   @Test def retryExample1(): Unit = {
     val o : Observable[String] = List("alice", "bob", "carol").toObservable
     assertEquals(List("alice", "bob", "carol"), o.retry.toBlockingObservable.toList)
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 d7c5a8aeb1..dfb507b9c2 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
@@ -2253,6 +2253,68 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.retry())
   }
 
+  /**
+   * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.o.png">
+   *
+   * @return an Observable that emits the items emitted by the source Observable repeatedly and in sequence
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+   */
+  def repeat(): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.repeat())
+  }
+
+  /**
+   * Returns an Observable that repeats the sequence of items emitted by the source Observable indefinitely,
+   * on a particular Scheduler.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.os.png">
+   *
+   * @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
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+   */
+  def repeat(scheduler: Scheduler): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.repeat(scheduler))
+  }
+
+  /**
+   * Returns an Observable that repeats the sequence of items emitted by the source Observable at most `count` times.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.on.png">
+   *
+   * @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
+   * @throws IllegalArgumentException if `count` is less than zero
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+   */
+  def repeat(count: Long): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.repeat(count))
+  }
+
+  /**
+   * Returns an Observable that repeats the sequence of items emitted by the source Observable
+   * at most `count` times, on a particular Scheduler.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/repeat.ons.png">
+   *
+   * @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
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+   */
+  def repeat(count: Long, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.repeat(count, scheduler))
+  }
+
   /**
    * Converts an Observable into a [[rx.lang.scala.observables.BlockingObservable]] (an Observable with blocking
    * operators).
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 6e36756d54..1de16eab50 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
@@ -143,6 +143,8 @@ class CompletenessTest extends JUnitSuite {
       "mergeDelayError(Observable[_ <: T], Observable[_ <: T])" -> "mergeDelayError(Observable[U])",
       "mergeDelayError(Observable[_ <: Observable[_ <: T]])" -> "flattenDelayError(<:<[Observable[T], Observable[Observable[U]]])",
       "range(Int, Int)" -> "apply(Range)",
+      "repeat()" -> "repeat()",
+      "retry()" -> "retry()",
       "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])",

From 1b4e2a8f429ac335c277f6dbc56d20f69c4a349e Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 4 May 2014 22:57:42 +0800
Subject: [PATCH 338/422] Add 'doOnTerminate' to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 20 +++++++++++++++++++
 .../main/scala/rx/lang/scala/Observable.scala | 16 +++++++++++++++
 2 files changed, 36 insertions(+)

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 f8b0dba233..fcb8f83e26 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
@@ -560,6 +560,26 @@ class RxScalaDemo extends JUnitSuite {
     obs.toBlockingObservable.toIterable.last
   }
 
+  @Test def doOnTerminateExample(): Unit = {
+    val o = List("red", "green", "blue").toObservable.doOnTerminate(() => println("terminate"))
+    o.subscribe(v => println(v), e => e.printStackTrace, () => println("onCompleted"))
+    // red
+    // green
+    // blud
+    // terminate
+    // onCompleted
+  }
+
+  @Test def finallyDoExample(): Unit = {
+    val o = List("red", "green", "blue").toObservable.finallyDo(() => println("finally"))
+    o.subscribe(v => println(v), e => e.printStackTrace, () => println("onCompleted"))
+    // red
+    // green
+    // blud
+    // onCompleted
+    // finally
+  }
+
   @Test def timeoutExample(): Unit = {
     val other = List(100L, 200L, 300L).toObservable
     val result = Observable.interval(100 millis).timeout(50 millis, other).toBlockingObservable.toList
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 dfb507b9c2..3d3e159c33 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
@@ -2461,6 +2461,22 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.doOnEach(Observer(onNext, onError,onCompleted)))
   }
 
+  /**
+   * Modifies an Observable so that it invokes an action when it calls `onCompleted` or `onError`.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnTerminate.png">
+   * <p>
+   * This differs from `finallyDo` in that this happens BEFORE onCompleted/onError are emitted.
+   *
+   * @param onTerminate the action to invoke when the source Observable calls `onCompleted` or `onError`
+   * @return the source Observable with the side-effecting behavior applied
+   * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-doonterminate">RxJava Wiki: doOnTerminate()</a>
+   * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
+   */
+  def doOnTerminate(onTerminate: () => Unit): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.doOnTerminate(onTerminate))
+  }
+
   /**
    * Given two Observables, mirror the one that first emits an item.
    *

From 7e1c2d495075843a44b4885b5fe45b736ce270dc Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 6 May 2014 12:01:33 +0800
Subject: [PATCH 339/422] Add 'startWith' to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 22 +++++++
 .../main/scala/rx/lang/scala/Observable.scala | 60 +++++++++++++++++++
 .../rx/lang/scala/CompletenessTest.scala      |  8 ++-
 3 files changed, 88 insertions(+), 2 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 fcb8f83e26..799c5e3351 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
@@ -756,4 +756,26 @@ class RxScalaDemo extends JUnitSuite {
       case e: IllegalArgumentException => println("IllegalArgumentException from skipWithException")
     }
   }
+
+  @Test def startWithExample1(): Unit = {
+    val o = List(2, 3).toObservable + 1
+    assertEquals(List(1, 2, 3), o.toBlockingObservable.toList)
+  }
+
+  @Test def startWithExample2(): Unit = {
+    val prepended = List(2, 4).toObservable
+    val o = List(5, 6, 7, 8).toObservable.filter(_ % 2 == 0).startWith(prepended)
+    assertEquals(List(2, 4, 6, 8), o.toBlockingObservable.toList)
+  }
+
+  @Test def startWithExample3(): Unit = {
+    val o = List(5, 6, 7, 8).toObservable.filter(_ % 2 == 0).startWith(List(2, 4))
+    assertEquals(List(2, 4, 6, 8), o.toBlockingObservable.toList)
+  }
+
+  @Test def startWithExample4(): Unit = {
+    val o = List(5, 6, 7, 8).toObservable.filter(_ % 2 == 0).startWith(Array(2, 4))
+    assertEquals(List(2, 4, 6, 8), o.toBlockingObservable.toList)
+  }
+
 }
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 3d3e159c33..7e8540326c 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
@@ -77,6 +77,7 @@ import collection.JavaConversions._
  */
 trait Observable[+T]
 {
+  import scala.collection.JavaConverters._
   import scala.collection.Seq
   import scala.concurrent.duration.{Duration, TimeUnit}
   import rx.functions._
@@ -238,6 +239,65 @@ trait Observable[+T]
     toScalaObservable(rx.Observable.concat(o1, o2))
   }
 
+  /**
+   * Returns an Observable that emits a specified item before it begins to emit items emitted by the source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+   *
+   * @param elem the item to emit
+   * @return an Observable that emits the specified item before it begins to emit items emitted by the source Observable
+   */
+  def +[U >: T](elem: U): Observable[U] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable(thisJava.startWith(elem))
+  }
+
+  /**
+   * Returns an Observable that emits the items in a specified `Observable` before it begins to emit
+   * items emitted by the source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.o.png">
+   *
+   * @param that an Observable that contains the items you want the modified Observable to emit first
+   * @return an Observable that emits the items in the specified `Observable` and then emits the items
+   *         emitted by the source Observable
+   */
+  def startWith[U >: T](that: Observable[U]): Observable[U] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val thatJava = that.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable(thisJava.startWith(thatJava))
+  }
+
+  /**
+   * Returns an Observable that emits the items in a specified `Iterable` before it begins to emit items
+   * emitted by the source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
+   *
+   * @param iterable an Iterable that contains the items you want the modified Observable to emit first
+   * @return an Observable that emits the items in the specified `Iterable` and then emits the items
+   *         emitted by the source Observable
+   */
+  def startWith[U >: T](iterable: Iterable[U]): Observable[U] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable(thisJava.startWith(iterable.asJava))
+  }
+
+  /**
+   * Returns an Observable that emits the items in a specified `Iterable`, on a specified `Scheduler`, before it begins to emit items emitted by the source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.s.png">
+   *
+   * @param iterable 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 `Iterable`, on a specified `Scheduler`, and then emits the items
+   *         emitted by the source Observable
+   */
+  def startWith[U >: T](iterable: Iterable[U], scheduler: Scheduler): Observable[U] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable(thisJava.startWith(iterable.asJava, scalaSchedulerToJavaScheduler(scheduler)))
+  }
+
   /**
    * Returns an Observable that emits the items emitted by several Observables, one after the
    * other.
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 1de16eab50..fcbce1f2b1 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
@@ -100,7 +100,11 @@ class CompletenessTest extends JUnitSuite {
       "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)",
       "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary,
       "skipUntil(Observable[U])" -> "dropUntil(Observable[E])",
-      "startWith(Iterable[T])" -> "[unnecessary because we can just use `++` instead]",
+      "startWith(Array[T])" -> "startWith(Iterable[U])",
+      "startWith(Array[T], Scheduler)" -> "startWith(Iterable[U], Scheduler)",
+      "startWith(Iterable[T])" -> "startWith(Iterable[U])",
+      "startWith(Iterable[T], Scheduler)" -> "startWith(Iterable[U], Scheduler)",
+      "startWith(Observable[T])" -> "startWith(Observable[U])",
       "skipLast(Int)" -> "dropRight(Int)",
       "skipLast(Long, TimeUnit)" -> "dropRight(Duration)",
       "skipLast(Long, TimeUnit, Scheduler)" -> "dropRight(Duration, Scheduler)",
@@ -159,7 +163,7 @@ class CompletenessTest extends JUnitSuite {
       "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]"
+      "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`]"

From 6dcc9d3533431dfec245bf114d6793308cbc13e5 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 6 May 2014 15:31:07 +0800
Subject: [PATCH 340/422] Add 'publish' variants to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 22 ++++++++
 .../main/scala/rx/lang/scala/Observable.scala | 56 ++++++++++++++++++-
 .../rx/lang/scala/CompletenessTest.scala      |  4 ++
 3 files changed, 81 insertions(+), 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 799c5e3351..a11ec76638 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
@@ -297,6 +297,28 @@ class RxScalaDemo extends JUnitSuite {
     shared.connect
   }
 
+  @Test def exampleWithPublish2() {
+    val unshared = Observable.from(1 to 4)
+    val shared = unshared.publish(0)
+    shared.subscribe(n => println(s"subscriber 1 gets $n"))
+    shared.subscribe(n => println(s"subscriber 2 gets $n"))
+    shared.connect
+  }
+
+  @Test def exampleWithPublish3() {
+    val o = Observable.interval(100 millis).take(5).publish((o: Observable[Long]) => o.map(_ * 2))
+    o.subscribe(n => println(s"subscriber 1 gets $n"))
+    o.subscribe(n => println(s"subscriber 2 gets $n"))
+    Thread.sleep(1000)
+  }
+
+  @Test def exampleWithPublish4() {
+    val o = Observable.interval(100 millis).take(5).publish((o: Observable[Long]) => o.map(_ * 2), -1L)
+    o.subscribe(n => println(s"subscriber 1 gets $n"))
+    o.subscribe(n => println(s"subscriber 2 gets $n"))
+    Thread.sleep(1000)
+  }
+
   def doLater(waitTime: Duration, action: () => Unit): Unit = {
     Observable.interval(waitTime).take(1).subscribe(_ => action())
   }
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 7e8540326c..0473189e63 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
@@ -1145,10 +1145,64 @@ trait Observable[+T]
    *
    * @return an [[rx.lang.scala.observables.ConnectableObservable]].
    */
-  def publish: ConnectableObservable[T] = {
+  def publish(): ConnectableObservable[T] = {
     new ConnectableObservable[T](asJavaObservable.publish())
   }
 
+
+  /**
+   * Returns an Observable that emits `initialValue` followed by the items emitted by a `ConnectableObservable` that shares a single subscription to the source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.i.png">
+   *
+   * @param initialValue the initial value to be emitted by the resulting Observable
+   * @return a `ConnectableObservable` that shares a single subscription to the underlying Observable and starts with `initialValue`
+   */
+  def publish[U >: T](initialValue: U): ConnectableObservable[U] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    new ConnectableObservable[U](thisJava.publish(initialValue))
+  }
+
+  /**
+   * Returns an Observable that emits the results of invoking a specified selector on items emitted by a `ConnectableObservable`
+   * that shares a single subscription to the underlying sequence.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.f.png">
+   *
+   * @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 `ConnectableObservable`
+   *         that shares a single subscription to the underlying sequence
+   */
+  def publish[U >: T, R](selector: Observable[U] => Observable[R]): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.publish(fJava))
+  }
+
+  /**
+   * Returns an Observable that emits `initialValue` followed by the results of invoking a specified
+   * selector on items emitted by a `ConnectableObservable` that shares a single subscription to the
+   * source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.if.png">
+   *
+   * @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
+   * @param initialValue  the initial value of the underlying `BehaviorSubject`
+   * @return an Observable that emits `initialValue` followed by the results of invoking the selector
+   *         on a `ConnectableObservable` that shares a single subscription to the underlying Observable
+   */
+  def publish[U >: T, R](selector: Observable[U] => Observable[R], initialValue: U): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.publish(fJava, initialValue))
+  }
+
   // TODO add Scala-like aggregate function
 
   /**
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 fcbce1f2b1..03b4d879bb 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
@@ -89,6 +89,10 @@ class CompletenessTest extends JUnitSuite {
       "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)",
+      "publish()" -> "publish()",
+      "publish(T)" -> "publish(U)",
+      "publish(Func1[_ >: Observable[T], _ <: Observable[R]])" -> "publish(Observable[U] => Observable[R])",
+      "publish(Func1[_ >: Observable[T], _ <: Observable[R]], T)" -> "publish(Observable[U] => Observable[R], U)",
       "reduce(Func2[T, T, T])" -> "reduce((U, U) => U)",
       "reduce(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)",
       "retry()" -> "retry()",

From 8fa3a37420c3bcca5ed8355a09cd67b75ae6665e Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 6 May 2014 10:07:40 +0200
Subject: [PATCH 341/422] Scheduler correctness improvements.

---
 .../rx/schedulers/EventLoopsScheduler.java    |  82 ++++-----
 .../rx/schedulers/NewThreadScheduler.java     | 169 ++++++++++--------
 2 files changed, 138 insertions(+), 113 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
index ef41d86432..48443a9743 100644
--- a/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
@@ -7,14 +7,15 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.functions.Action0;
-import rx.schedulers.NewThreadScheduler.OnActionComplete;
+import rx.schedulers.NewThreadScheduler.NewThreadWorker.Remover;
+import rx.schedulers.NewThreadScheduler.NewThreadWorker.ScheduledAction;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
 
 /* package */class EventLoopsScheduler extends Scheduler {
-
-    private static class ComputationSchedulerPool {
-        final int cores = Runtime.getRuntime().availableProcessors();
+    /** Manages a fixed number of workers. */
+    static final class FixedSchedulerPool {
+        final int cores;
         final ThreadFactory factory = new ThreadFactory() {
             final AtomicInteger counter = new AtomicInteger();
 
@@ -26,47 +27,46 @@ public Thread newThread(Runnable r) {
             }
         };
 
-        final EventLoopScheduler[] eventLoops;
+        final PoolWorker[] eventLoops;
+        long n;
 
-        ComputationSchedulerPool() {
+        FixedSchedulerPool() {
             // initialize event loops
-            eventLoops = new EventLoopScheduler[cores];
+            this.cores = Runtime.getRuntime().availableProcessors();
+            this.eventLoops = new PoolWorker[cores];
             for (int i = 0; i < cores; i++) {
-                eventLoops[i] = new EventLoopScheduler(factory);
+                this.eventLoops[i] = new PoolWorker(factory);
             }
         }
 
-        private static ComputationSchedulerPool INSTANCE = new ComputationSchedulerPool();
-
-        long n = 0;
-
-        public EventLoopScheduler getEventLoop() {
-            // round-robin selection (improvements to come)
-            return eventLoops[(int) (n++ % cores)];
+        public PoolWorker getEventLoop() {
+            // simple round robin, improvements to come
+            return eventLoops[(int)(n++ % cores)];
         }
-
     }
 
+    final FixedSchedulerPool pool;
+    
+    /**
+     * Create a scheduler with pool size equal to the available processor
+     * count and using least-recent worker selection policy.
+     */
+    EventLoopsScheduler() {
+        pool = new FixedSchedulerPool();
+    }
+    
     @Override
     public Worker createWorker() {
-        return new EventLoop();
+        return new EventLoopWorker(pool.getEventLoop());
     }
 
-    private static class EventLoop extends Scheduler.Worker {
+    private static class EventLoopWorker extends Scheduler.Worker {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
-        private final EventLoopScheduler pooledEventLoop;
-        private final OnActionComplete onComplete;
-
-        EventLoop() {
-            pooledEventLoop = ComputationSchedulerPool.INSTANCE.getEventLoop();
-            onComplete = new OnActionComplete() {
+        private final PoolWorker poolWorker;
 
-                @Override
-                public void complete(Subscription s) {
-                    innerSubscription.remove(s);
-                }
-
-            };
+        EventLoopWorker(PoolWorker poolWorker) {
+            this.poolWorker = poolWorker;
+            
         }
 
         @Override
@@ -81,13 +81,8 @@ public boolean isUnsubscribed() {
 
         @Override
         public Subscription schedule(Action0 action) {
-            if (innerSubscription.isUnsubscribed()) {
-                // don't schedule, we are unsubscribed
-                return Subscriptions.empty();
-            }
-            return pooledEventLoop.schedule(action, onComplete);
+            return schedule(action, 0, null);
         }
-
         @Override
         public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
             if (innerSubscription.isUnsubscribed()) {
@@ -95,15 +90,16 @@ public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
                 return Subscriptions.empty();
             }
             
-            return pooledEventLoop.schedule(action, delayTime, unit, onComplete);
+            ScheduledAction s = poolWorker.scheduleActual(action, delayTime, unit);
+            innerSubscription.add(s);
+            s.addParent(innerSubscription);
+            return s;
         }
-
     }
-
-    private static class EventLoopScheduler extends NewThreadScheduler.EventLoopScheduler {
-        EventLoopScheduler(ThreadFactory threadFactory) {
+    
+    private static final class PoolWorker extends NewThreadScheduler.NewThreadWorker {
+        PoolWorker(ThreadFactory threadFactory) {
             super(threadFactory);
         }
     }
-
-}
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index acbe6c81cc..24be9bd8a7 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -15,13 +15,13 @@
  */
 package rx.schedulers;
 
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Scheduler;
 import rx.Subscription;
@@ -56,15 +56,15 @@ private NewThreadScheduler() {
 
     @Override
     public Worker createWorker() {
-        return new EventLoopScheduler(THREAD_FACTORY);
+        return new NewThreadWorker(THREAD_FACTORY);
     }
 
-    /* package */static class EventLoopScheduler extends Scheduler.Worker implements Subscription {
+    /* package */static class NewThreadWorker extends Scheduler.Worker implements Subscription {
         private final CompositeSubscription innerSubscription = new CompositeSubscription();
-        private final ExecutorService executor;
+        private final ScheduledExecutorService executor;
 
-        /* package */EventLoopScheduler(ThreadFactory threadFactory) {
-            executor = Executors.newSingleThreadExecutor(threadFactory);
+        /* package */NewThreadWorker(ThreadFactory threadFactory) {
+            executor = Executors.newScheduledThreadPool(1, threadFactory);
         }
 
         @Override
@@ -73,80 +73,109 @@ public Subscription schedule(final Action0 action) {
         }
 
         /* package */Subscription schedule(final Action0 action, final OnActionComplete onComplete) {
+            return scheduleActual(action, 0, null);
+        }
+
+        @Override
+        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
             if (innerSubscription.isUnsubscribed()) {
-                // don't schedule, we are unsubscribed
                 return Subscriptions.empty();
             }
-
-            final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
-            Subscription s = Subscriptions.from(executor.submit(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        if (innerSubscription.isUnsubscribed()) {
-                            return;
-                        }
-                        action.call();
-                    } finally {
-                        // remove the subscription now that we're completed
-                        Subscription s = sf.get();
-                        if (s != null) {
-                            innerSubscription.remove(s);
-                        }
-                        if (onComplete != null) {
-                            onComplete.complete(s);
-                        }
-                    }
-                }
-            }));
-
-            sf.set(s);
-            innerSubscription.add(s);
-            return s;
+            return scheduleActual(action, delayTime, unit);
         }
 
-        @Override
-        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
-            return schedule(action, delayTime, unit, null);
+        /* package */ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
+            ScheduledAction run = new ScheduledAction(action, innerSubscription);
+            Future<?> f;
+            if (delayTime <= 0) {
+                f = executor.submit(run);
+            } else {
+                f = executor.schedule(run, delayTime, unit);
+            }
+            run.add(Subscriptions.from(f));
+            
+            return run;
         }
+        
+        /** Remove a child subscription from a composite when unsubscribing. */
+        public static final class Remover implements Subscription {
+            final Subscription s;
+            final CompositeSubscription parent;
+            final AtomicBoolean once;
+            
+            public Remover(Subscription s, CompositeSubscription parent) {
+                this.s = s;
+                this.parent = parent;
+                this.once = new AtomicBoolean();
+            }
+            
+            @Override
+            public boolean isUnsubscribed() {
+                return s.isUnsubscribed();
+            }
+            
+            @Override
+            public void unsubscribe() {
+                if (once.compareAndSet(false, true)) {
+                    parent.remove(s);
+                }
+            }
+            
+        }
+        /** 
+         * A runnable that executes an Action0 and can be cancelled
+         * The analogue is the Subscriber in respect of an Observer.
+         */
+        public static final class ScheduledAction implements Runnable, Subscription {
+            final CompositeSubscription cancel;
+            final Action0 action;
+            final CompositeSubscription parent;
+            final AtomicBoolean once;
+
+            public ScheduledAction(Action0 action, CompositeSubscription parent) {
+                this.action = action;
+                this.parent = parent;
+                this.cancel = new CompositeSubscription();
+                this.once = new AtomicBoolean();
+            }
 
-        /* package */Subscription schedule(final Action0 action, long delayTime, TimeUnit unit, final OnActionComplete onComplete) {
-            final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
-            // 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
-            ScheduledFuture<?> f = GenericScheduledExecutorService.getInstance().schedule(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        if (innerSubscription.isUnsubscribed()) {
-                            return;
-                        }
-                        // now that the delay is past schedule the work to be done for real on the UI thread
-                        schedule(action);
-                    } finally {
-                        // remove the subscription now that we're completed
-                        Subscription s = sf.get();
-                        if (s != null) {
-                            innerSubscription.remove(s);
-                        }
-                        if (onComplete != null) {
-                            onComplete.complete(s);
-                        }
-                    }
+            @Override
+            public void run() {
+                try {
+                    action.call();
+                } finally {
+                    unsubscribe();
                 }
-            }, delayTime, unit);
+            }
 
-            // add the ScheduledFuture as a subscription so we can cancel the scheduled action if an unsubscribe happens
-            Subscription s = Subscriptions.from(f);
-            sf.set(s);
-            innerSubscription.add(s);
-            return s;
+            @Override
+            public boolean isUnsubscribed() {
+                return cancel.isUnsubscribed();
+            }
+            
+            @Override
+            public void unsubscribe() {
+                if (once.compareAndSet(false, true)) {
+                    cancel.unsubscribe();
+                    parent.remove(this);
+                }
+            }
+            public void add(Subscription s) {
+                cancel.add(s);
+            }
+            /** 
+             * Adds a parent to this ScheduledAction so when it is 
+             * cancelled or terminates, it can remove itself from this parent.
+             * @param parent 
+             */
+            public void addParent(CompositeSubscription parent) {
+                cancel.add(new Remover(this, parent));
+            } 
         }
 
         @Override
         public void unsubscribe() {
+            executor.shutdown();
             innerSubscription.unsubscribe();
         }
 
@@ -163,4 +192,4 @@ public boolean isUnsubscribed() {
 
     }
 
-}
+}
\ No newline at end of file

From 024a427f6032aabd4939be11941bfe2527cac8a6 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 6 May 2014 16:08:24 +0800
Subject: [PATCH 342/422] Change '(() => Subscription, Observable[R])' to
 'ConnectableObservable[R]'

---
 .../scala/rx/lang/scala/examples/RxScalaDemo.scala     |  4 ++--
 .../src/main/scala/rx/lang/scala/Observable.scala      | 10 ++++------
 2 files changed, 6 insertions(+), 8 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 7d1ee11cd3..4a788024ee 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
@@ -312,9 +312,9 @@ class RxScalaDemo extends JUnitSuite {
 
   @Test def exampleWithReplay() {
     val numbers = Observable.interval(1000 millis).take(6)
-    val (startFunc, sharedNumbers) = numbers.replay
+    val sharedNumbers = numbers.replay
     sharedNumbers.subscribe(n => println(s"subscriber 1 gets $n"))
-    startFunc()
+    sharedNumbers.connect
     // subscriber 2 subscribes later but still gets all numbers
     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 35eae53767..1e1a97486c 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
@@ -215,10 +215,9 @@ 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 push results into the specified Subject
    */
-  def multicast[R >: T](subject: rx.lang.scala.Subject[R]): (() => Subscription, Observable[R]) = {
+  def multicast[R >: T](subject: rx.lang.scala.Subject[R]): ConnectableObservable[R] = {
     val s: rx.subjects.Subject[_ >: T, _<: R] = subject.asJavaSubject
-    val javaCO: rx.observables.ConnectableObservable[R] = asJavaObservable.multicast(s)
-    (() => javaCO.connect(), toScalaObservable(javaCO))
+    new ConnectableObservable[R](asJavaObservable.multicast(s))
   }
 
   /**
@@ -1032,9 +1031,8 @@ 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
    */
-  def replay: (() => Subscription, Observable[T]) = {
-    val javaCO = asJavaObservable.replay()
-    (() => javaCO.connect(), toScalaObservable[T](javaCO))
+  def replay: ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay())
   }
 
   /**

From bcf34f71800ed98f18d01dd8ea2eae3c080ff830 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 6 May 2014 16:52:44 +0800
Subject: [PATCH 343/422] Add 'multicast' variants to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala      | 15 +++++++++++++++
 .../src/main/scala/rx/lang/scala/Observable.scala | 15 +++++++++++++++
 .../scala/rx/lang/scala/CompletenessTest.scala    |  2 ++
 3 files changed, 32 insertions(+)

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 4a788024ee..786a344ca5 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
@@ -708,4 +708,19 @@ class RxScalaDemo extends JUnitSuite {
       case e: IllegalArgumentException => println("IllegalArgumentException from skipWithException")
     }
   }
+
+  @Test def multicastExample1(): Unit = {
+    val unshared = Observable.from(1 to 4)
+    val shared = unshared.multicast(Subject())
+    shared.subscribe(n => println(s"subscriber 1 gets $n"))
+    shared.subscribe(n => println(s"subscriber 2 gets $n"))
+    shared.connect
+  }
+
+  @Test def multicastExample2(): Unit = {
+    val unshared = Observable.from(1 to 4)
+    val shared = unshared.multicast[Int, String](() => Subject(), o => o.map("No. " + _))
+    shared.subscribe(n => println(s"subscriber 1 gets $n"))
+    shared.subscribe(n => println(s"subscriber 2 gets $n"))
+  }
 }
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 1e1a97486c..09c62fd153 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
@@ -220,6 +220,21 @@ trait Observable[+T]
     new ConnectableObservable[R](asJavaObservable.multicast(s))
   }
 
+  /**
+   * Returns an Observable that emits items produced by multicasting the source Observable within a selector function.
+   *
+   * @param subjectFactory the `Subject` factory
+   * @param selector the selector function, which can use the multicasted source Observable subject to the policies
+   *                 enforced by the created `Subject`
+   * @return an Observable that emits the items produced by multicasting the source Observable within a selector function
+   */
+  def multicast[R >: T, U](subjectFactory: () => rx.lang.scala.Subject[R], selector: Observable[R] => Observable[U]): Observable[U] = {
+    val subjectFactoryJava: Func0[rx.subjects.Subject[_ >: T, _ <: R]] = () => subjectFactory().asJavaSubject
+    val selectorJava: Func1[rx.Observable[R], rx.Observable[U]] =
+      (jo: rx.Observable[R]) => selector(toScalaObservable[R](jo)).asJavaObservable.asInstanceOf[rx.Observable[U]]
+    toScalaObservable[U](asJavaObservable.multicast[R, U](subjectFactoryJava, selectorJava))
+  }
+
   /**
    * Returns an Observable that first emits the items emitted by `this`, and then the items emitted
    * by `that`.
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 eca5168da5..b433f35f46 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
@@ -140,6 +140,8 @@ class CompletenessTest extends JUnitSuite {
       "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]]])",
+      "multicast(Subject[_ >: T, _ <: R])" -> "multicast(Subject[R])",
+      "multicast(Func0[_ <: Subject[_ >: T, _ <: TIntermediate]], Func1[_ >: Observable[TIntermediate], _ <: Observable[TResult]])" -> "multicast(() => Subject[R], Observable[R] => 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))`]",

From a0ad6c9b8dd2ab88ccc2379af9d7c2ddcb04dcad Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 6 May 2014 19:59:33 +0800
Subject: [PATCH 344/422] Remove 'Observable.apply(Int)'

---
 .../main/scala/rx/lang/scala/Observable.scala | 20 -------------------
 1 file changed, 20 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 09c62fd153..1f681567a8 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
@@ -2449,26 +2449,6 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.delaySubscription(delay.length, delay.unit, scheduler))
   }
 
-  /**
-   * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
-   * source Observbable.
-   * 
-   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/elementAt.png">
-   * 
-   * @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
-   * @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 `Observable.elementAt`
-   * @deprecated("Use `elementAt`", "0.18.0")
-   */
-  def apply(index: Int): Observable[T] = elementAt(index)
-
   /**
    * Returns an Observable that emits the single item at a specified index in a sequence of emissions from a
    * source Observbable.

From 3609e675f4efd296a136d389daedcde5b4f95a7a Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 6 May 2014 20:34:39 +0800
Subject: [PATCH 345/422] Add 'replay' variants to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  |  40 +++
 .../main/scala/rx/lang/scala/Observable.scala | 273 ++++++++++++++++++
 .../rx/lang/scala/CompletenessTest.scala      |   8 +
 3 files changed, 321 insertions(+)

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 786a344ca5..6a4d0cfdf6 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
@@ -320,6 +320,46 @@ class RxScalaDemo extends JUnitSuite {
     waitFor(sharedNumbers)
   }
 
+  @Test def exampleWithReplay2() {
+    val numbers = Observable.interval(100 millis).take(10)
+    val sharedNumbers = numbers.replay(3)
+    sharedNumbers.subscribe(n => println(s"subscriber 1 gets $n"))
+    sharedNumbers.connect
+    // subscriber 2 subscribes later but only gets the 3 buffered numbers and the following numbers
+    Thread.sleep(700)
+    sharedNumbers.subscribe(n => println(s"subscriber 2 gets $n"))
+    waitFor(sharedNumbers)
+  }
+
+  @Test def exampleWithReplay3() {
+    val numbers = Observable.interval(100 millis).take(10)
+    val sharedNumbers = numbers.replay(300 millis)
+    sharedNumbers.subscribe(n => println(s"subscriber 1 gets $n"))
+    sharedNumbers.connect
+    // subscriber 2 subscribes later but only gets the buffered numbers and the following numbers
+    Thread.sleep(700)
+    sharedNumbers.subscribe(n => println(s"subscriber 2 gets $n"))
+    waitFor(sharedNumbers)
+  }
+
+  @Test def exampleWithReplay4() {
+    val numbers = Observable.interval(100 millis).take(10)
+    val sharedNumbers = numbers.replay(2, 300 millis)
+    sharedNumbers.subscribe(n => println(s"subscriber 1 gets $n"))
+    sharedNumbers.connect
+    // subscriber 2 subscribes later but only gets the buffered numbers and the following numbers
+    Thread.sleep(700)
+    sharedNumbers.subscribe(n => println(s"subscriber 2 gets $n"))
+    waitFor(sharedNumbers)
+  }
+
+  @Test def exampleWithReplay5() {
+    val numbers = Observable.interval(100 millis).take(10)
+    val sharedNumbers = numbers.replay[Long, Long]((o: Observable[Long]) => o.map(_ * 2))
+    sharedNumbers.subscribe(n => println(s"subscriber gets $n"))
+    waitFor(sharedNumbers)
+  }
+
   @Test def testSingleOption() {
     assertEquals(None,    List(1, 2).toObservable.toBlockingObservable.singleOption)
     assertEquals(Some(1), List(1).toObservable.toBlockingObservable.singleOption)
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 1f681567a8..e9c7b8a742 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
@@ -1050,6 +1050,279 @@ trait Observable[+T]
     new ConnectableObservable[T](asJavaObservable.replay())
   }
 
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on the items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.f.png">
+   *
+   * @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 `ConnectableObservable`
+   *         that shares a single subscription to the source Observable
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R]): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava))
+  }
+
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable,
+   * replaying `bufferSize` notifications.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fn.png">
+   *
+   * @param selector 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 `ConnectableObservable` that shares a single subscription to the source Observable  replaying
+   *         no more than `bufferSize` items
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R], bufferSize: Int): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava, bufferSize))
+  }
+
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable,
+   * replaying no more than `bufferSize` items that were emitted within a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fnt.png">
+   *
+   * @param selector  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
+   * @param time the duration of the window in which the replayed items must have been emitted
+   * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+   *         a `ConnectableObservable` that shares a single subscription to the source Observable, and
+   *         replays no more than `bufferSize` items that were emitted within the window defined by `time`
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R], bufferSize: Int, time: Duration): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava, bufferSize, time.length, time.unit))
+  }
+
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable,
+   * replaying no more than `bufferSize` items that were emitted within a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fnts.png">
+   *
+   * @param selector  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
+   * @param time  the duration of the window in which the replayed items must have been emitted
+   * @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 `ConnectableObservable` that shares a single subscription to the source Observable, and
+   *         replays no more than `bufferSize` items that were emitted within the window defined by `time`
+   * @throws IllegalArgumentException if `bufferSize` is less than zero
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R], bufferSize: Int, time: Duration, scheduler: Scheduler): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava, bufferSize, time.length, time.unit, scheduler))
+  }
+
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable,
+   * replaying a maximum of `bufferSize` items.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fns.png">
+   *
+   * @param selector  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
+   * @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 `ConnectableObservable` that shares a single subscription to the source Observable,
+   *         replaying no more than `bufferSize` notifications
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R], bufferSize: Int, scheduler: Scheduler): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava, bufferSize, scheduler))
+  }
+
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable,
+   * replaying all items that were emitted within a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ft.png">
+   *
+   * @param selector   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
+   * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+   *         a `ConnectableObservable` that shares a single subscription to the source Observable,
+   *         replaying all items that were emitted within the window defined by `time`
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R], time: Duration, scheduler: Scheduler): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava, time.length, time.unit, scheduler))
+  }
+
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.fs.png">
+   *
+   * @param selector  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 `ConnectableObservable` that shares a single subscription to the source Observable,
+   *         replaying all items
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R], scheduler: Scheduler): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava, scheduler))
+  }
+
+  /**
+   * Returns a `ConnectableObservable` that shares a single subscription to the source Observable and
+   * replays at most `bufferSize` items that were emitted during a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nt.png">
+   *
+   * @param bufferSize the buffer size that limits the number of items that can be replayed
+   * @param time the duration of the window in which the replayed items must have been emitted
+   * @return a `ConnectableObservable` that shares a single subscription to the source Observable and
+   *         replays at most `bufferSize` items that were emitted during the window defined by `time`
+   */
+  def replay(bufferSize: Int, time: Duration): ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay(bufferSize, time.length, time.unit))
+  }
+
+  /**
+   * Returns a `ConnectableObservable` that shares a single subscription to the source Observable and
+   * that replays a maximum of `bufferSize` items that are emitted within a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nts.png">
+   *
+   * @param bufferSize the buffer size that limits the number of items that can be replayed
+   * @param time the duration of the window in which the replayed items must have been emitted
+   * @param scheduler the scheduler that is used as a time source for the window
+   * @return a `ConnectableObservable` that shares a single subscription to the source Observable and
+   *         replays at most `bufferSize` items that were emitted during the window defined by `time``
+   * @throws IllegalArgumentException if `bufferSize` is less than zero
+   */
+  def replay(bufferSize: Int, time: Duration, scheduler: Scheduler): ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay(bufferSize, time.length, time.unit, scheduler))
+  }
+
+  /**
+   * Returns an Observable that emits items that are the results of invoking a specified selector on items
+   * emitted by a `ConnectableObservable` that shares a single subscription to the source Observable,
+   * replaying all items that were emitted within a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ft.png">
+   *
+   * @param selector  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
+   * @return an Observable that emits items that are the results of invoking the selector on items emitted by
+   *         a `ConnectableObservable` that shares a single subscription to the source Observable,
+   *         replaying all items that were emitted within the window defined by `time``
+   */
+  def replay[U >: T, R](selector: Observable[U] => Observable[R], time: Duration): Observable[R] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
+    val fJava: Func1[rx.Observable[U], rx.Observable[R]] =
+      (jo: rx.Observable[U]) => selector(toScalaObservable[U](jo)).asJavaObservable.asInstanceOf[rx.Observable[R]]
+    toScalaObservable[R](thisJava.replay(fJava, time.length, time.unit))
+  }
+
+  /**
+   * Returns a `ConnectableObservable` that shares a single subscription to the source Observable that
+   * replays at most `bufferSize` items emitted by that Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.n.png">
+   *
+   * @param bufferSize the buffer size that limits the number of items that can be replayed
+   * @return a `ConnectableObservable` that shares a single subscription to the source Observable and
+   *         replays at most `bufferSize` items emitted by that Observable
+   */
+  def replay(bufferSize: Int): ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay(bufferSize))
+  }
+
+  /**
+   * Returns a `ConnectableObservable` that shares a single subscription to the source Observable and
+   * replays at most `bufferSize` items emitted by that Observable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ns.png">
+   *
+   * @param bufferSize 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 `ConnectableObservable` that shares a single subscription to the source Observable and
+   *         replays at most `bufferSize` items that were emitted by the Observable
+   */
+  def replay(bufferSize: Int, scheduler: Scheduler): ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay(bufferSize, scheduler))
+  }
+
+  /**
+   * Returns a `ConnectableObservable` that shares a single subscription to the source Observable and
+   * replays all items emitted by that Observable within a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.t.png">
+   *
+   * @param time  the duration of the window in which the replayed items must have been emitted
+   * @return a `ConnectableObservable` that shares a single subscription to the source Observable and
+   *         replays the items that were emitted during the window defined by `time`
+   */
+  def replay(time: Duration): ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay(time.length, time.unit))
+  }
+
+  /**
+   * Returns a `ConnectableObservable` that shares a single subscription to the source Observable and
+   * replays all items emitted by that Observable within a specified time window.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ts.png">
+   *
+   * @param time the duration of the window in which the replayed items must have been emitted
+   * @param scheduler the Scheduler that is the time source for the window
+   * @return a `ConnectableObservable` that shares a single subscription to the source Observable and
+   *         replays the items that were emitted during the window defined by `time`
+   */
+  def replay(time: Duration, scheduler: Scheduler): ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay(time.length, time.unit, scheduler))
+  }
+
+  /**
+   * Returns a `ConnectableObservable` that shares a single subscription to the source Observable that
+   * will replay all of its items and notifications to any future `Observer` on the given `Scheduler`.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.s.png">
+   *
+   * @param scheduler the Scheduler on which the Observers will observe the emitted items
+   * @return a `ConnectableObservable` that shares a single subscription to the source Observable that
+   *         will replay all of its items and notifications to any future `bserver` on the given `Scheduler`
+   */
+  def replay(scheduler: Scheduler): ConnectableObservable[T] = {
+    new ConnectableObservable[T](asJavaObservable.replay(scheduler))
+  }
+
   /**
    * This method has similar behavior to [[rx.lang.scala.Observable.replay]] except that this auto-subscribes to
    * the source Observable rather than returning a start function and an Observable.
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 b433f35f46..1b4c7ceea2 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
@@ -90,6 +90,14 @@ class CompletenessTest extends JUnitSuite {
       "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)",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]])" -> "replay(Observable[U] => Observable[R])",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Int)" -> "replay(Observable[U] => Observable[R], Int)",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Int, Long, TimeUnit)" -> "replay(Observable[U] => Observable[R], Int, Duration)",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Int, Long, TimeUnit, Scheduler)" -> "replay(Observable[U] => Observable[R], Int, Duration, Scheduler)",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Int, Scheduler)" -> "replay(Observable[U] => Observable[R], Int, Scheduler)",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Long, TimeUnit)" -> "replay(Observable[U] => Observable[R], Duration)",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Long, TimeUnit, Scheduler)" -> "replay(Observable[U] => Observable[R], Duration, Scheduler)",
+      "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Scheduler)" -> "replay(Observable[U] => Observable[R], Scheduler)",
       "retry()" -> "retry()",
       "scan(Func2[T, T, T])" -> unnecessary,
       "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)",

From b4b67623dab336a61c53d63d55db94640fd02105 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 6 May 2014 15:15:38 +0200
Subject: [PATCH 346/422] Removed use of deprecated API from tests & operators,
 fixed year in headers, added and removed suppressions, fixed line endings,
 replaced tabs with spaces

---
 .../lang/clojure/interop/DummyObservable.java |   2 +-
 .../rx/lang/groovy/GroovyActionWrapper.java   |   2 +-
 .../rx/lang/groovy/GroovyCreateWrapper.java   |   2 +-
 .../rx/lang/groovy/GroovyFunctionWrapper.java |   2 +-
 .../groovy/GroovyOnSubscribeFuncWrapper.java  |   2 +-
 .../lang/groovy/RxGroovyExtensionModule.java  |   5 +-
 .../RxGroovyPropertiesModuleFactory.java      |   2 +-
 .../rx/lang/jruby/JRubyActionWrapper.java     |   2 +-
 .../rx/lang/jruby/JRubyFunctionWrapper.java   |  18 +-
 .../rx/lang/scala/examples/MovieLibUsage.java |   2 +-
 .../concurrency/AndroidSchedulers.java        |   2 +-
 .../concurrency/HandlerThreadScheduler.java   |   2 +-
 .../observables/AndroidObservable.java        |   2 +-
 .../rx/android/observables/Assertions.java    |  15 ++
 .../android/observables/ViewObservable.java   |   2 +-
 .../android/schedulers/AndroidSchedulers.java |   2 +-
 .../schedulers/HandlerThreadScheduler.java    |   2 +-
 .../operators/OperatorConditionalBinding.java |  15 ++
 .../OperatorObserveFromAndroidComponent.java  |   2 +-
 .../observables/AndroidObservableTest.java    |   2 +-
 ...eratorObserveFromAndroidComponentTest.java |   2 +-
 .../HandlerThreadSchedulerTest.java           |   2 +-
 .../OperatorConditionalBindingTest.java       |  15 ++
 .../java/rx/apache/http/ObservableHttp.java   |  31 ++-
 .../apache/http/ObservableHttpResponse.java   |   2 +-
 .../http/consumers/ExpandableByteBuffer.java  |   2 +-
 .../http/consumers/ResponseConsumerBasic.java |  13 +-
 .../consumers/ResponseConsumerDelegate.java   |   2 +-
 .../ResponseConsumerEventStream.java          |  12 +-
 .../http/consumers/ResponseDelegate.java      |   2 +-
 .../http/examples/ExampleObservableHttp.java  |   2 +-
 .../operators/OperatorDeferFutureTest.java    |  14 +-
 .../operators/OperatorForEachFutureTest.java  |  15 +-
 .../OperatorFromFunctionalsTest.java          |   8 +-
 .../operators/OperatorStartFutureTest.java    |  16 +-
 .../src/main/java/rx/Statement.java           |   4 +-
 .../java/rx/operators/OperatorIfThen.java     |  15 ++
 .../java/rx/operators/OperatorSwitchCase.java |  15 ++
 .../rx/operators/OperatorWhileDoWhile.java    |  15 ++
 .../operators/OperatorConditionalsTest.java   |  10 +-
 .../src/main/java/rx/plugins/DebugHook.java   |   9 +-
 .../java/rx/plugins/DebugNotification.java    |   6 +-
 .../rx/plugins/DebugNotificationListener.java |   8 +-
 .../src/test/java/rx/debug/DebugHookTest.java |   4 +
 .../src/main/java/rx/joins/Pattern1.java      |   2 +-
 .../joins/operators/OperatorJoinPatterns.java |   2 +-
 .../math/operators/OperatorAverageDouble.java |   4 +-
 .../math/operators/OperatorAverageFloat.java  |   2 +-
 .../operators/OperatorAverageInteger.java     |   2 +-
 .../math/operators/OperatorAverageLong.java   |   2 +-
 .../rx/math/operators/OperatorMinMax.java     |   2 +-
 .../java/rx/math/operators/OperatorSum.java   |   2 +-
 .../math/operators/OperatorAverageTest.java   |   2 +-
 .../rx/math/operators/OperatorSumTest.java    |   2 +-
 .../java/rx/quasar/ChannelObservable.java     |   4 +-
 .../java/rx/quasar/NewFiberScheduler.java     |   4 +-
 .../rx/quasar/BlockingObservableTest.java     |  15 +-
 .../java/rx/quasar/ChannelObservableTest.java |  11 +-
 .../java/rx/observables/StringObservable.java |  32 +--
 .../rx/observables/StringObservableTest.java  |  25 ++-
 .../java/rx/observables/SwingObservable.java  |   2 +-
 .../java/rx/schedulers/SwingScheduler.java    |   2 +-
 .../rx/subscriptions/SwingSubscriptions.java  |   2 +-
 .../swing/sources/AbstractButtonSource.java   |   2 +-
 .../swing/sources/ComponentEventSource.java   |   2 +-
 .../java/rx/swing/sources/KeyEventSource.java |   2 +-
 .../rx/swing/sources/MouseEventSource.java    |   2 +-
 .../rx/swing/sources/SwingTestHelper.java     |   2 +-
 .../rx/schedulers/SwingSchedulerTest.java     |   2 +-
 rxjava-core/src/main/java/rx/Observable.java  |  13 +-
 rxjava-core/src/main/java/rx/Scheduler.java   |   2 +-
 .../src/main/java/rx/functions/Actions.java   |   1 +
 .../src/main/java/rx/functions/Functions.java |   1 +
 .../main/java/rx/observers/EmptyObserver.java |  15 ++
 .../src/main/java/rx/observers/Observers.java |  15 ++
 .../java/rx/observers/SerializedObserver.java |  19 +-
 .../rx/observers/SerializedSubscriber.java    |  15 ++
 .../main/java/rx/observers/Subscribers.java   |  21 +-
 .../rx/operators/BufferUntilSubscriber.java   |   1 -
 .../java/rx/operators/NotificationLite.java   |  30 ++-
 .../OperatorBufferWithSingleObservable.java   |   5 +-
 .../OperatorBufferWithStartEndObservable.java |   4 +-
 .../rx/operators/OperatorCombineLatest.java   |  11 +-
 .../java/rx/operators/OperatorMulticast.java  |   1 -
 ...peratorOnErrorResumeNextViaObservable.java |   1 -
 .../java/rx/operators/OperatorReplay.java     |   2 +-
 .../main/java/rx/operators/OperatorSkip.java  |  15 ++
 .../java/rx/operators/OperatorSwitch.java     |   1 -
 .../main/java/rx/operators/OperatorZip.java   |   4 +-
 .../operators/SafeObservableSubscription.java |  83 --------
 .../main/java/rx/operators/SafeObserver.java  | 170 ----------------
 .../rx/schedulers/EventLoopsScheduler.java    |  15 ++
 .../rx/schedulers/ImmediateScheduler.java     |   2 +-
 .../rx/schedulers/NewThreadScheduler.java     |   2 +-
 .../main/java/rx/schedulers/Schedulers.java   |   2 +-
 .../java/rx/schedulers/SleepingAction.java    |   2 +-
 .../rx/schedulers/TrampolineScheduler.java    |   2 +-
 .../main/java/rx/subjects/ReplaySubject.java  |   2 -
 .../java/rx/subscriptions/Subscriptions.java  |  41 ++--
 rxjava-core/src/test/java/rx/ConcatTests.java |  12 +-
 rxjava-core/src/test/java/rx/MergeTests.java  |  13 +-
 .../src/test/java/rx/ObservableTests.java     |  62 +++---
 .../src/test/java/rx/RefCountTests.java       |  11 +-
 .../src/test/java/rx/StartWithTests.java      |   2 +-
 .../rx/exceptions/CompositeExceptionTest.java |   5 +-
 .../java/rx/exceptions/TestException.java     |  36 ++++
 .../observables/BlockingObservableTest.java   |  20 +-
 .../rx/observers/SerializedObserverTest.java  |   3 -
 .../BlockingOperatorMostRecentTest.java       |   5 +-
 .../operators/BlockingOperatorNextTest.java   |  15 +-
 .../BlockingOperatorToFutureTest.java         |  15 +-
 .../BlockingOperatorToIteratorTest.java       |  17 +-
 .../operators/OperatorAsObservableTest.java   |  15 +-
 ...ufferTest.java => OperatorBufferTest.java} | 107 +++++-----
 .../java/rx/operators/OperatorCacheTest.java  |   9 +-
 .../operators/OperatorCombineLatestTest.java  |  42 ++--
 .../java/rx/operators/OperatorConcatTest.java |  32 ++-
 .../rx/operators/OperatorDebounceTest.java    |  34 ++--
 .../operators/OperatorDefaultIfEmptyTest.java |  11 +-
 .../java/rx/operators/OperatorDeferTest.java  |  13 +-
 .../java/rx/operators/OperatorDelayTest.java  |  23 ++-
 .../operators/OperatorDematerializeTest.java  |   9 +-
 .../rx/operators/OperatorGroupByTest.java     |   7 +-
 .../rx/operators/OperatorMaterializeTest.java |   9 +-
 .../OperatorMergeDelayErrorTest.java          |  75 ++-----
 .../rx/operators/OperatorMergeMapTest.java    |  29 +--
 .../OperatorMergeMaxConcurrentTest.java       |   9 +-
 .../java/rx/operators/OperatorMergeTest.java  |  37 ++--
 ...ratorOnErrorResumeNextViaFunctionTest.java |  12 +-
 ...torOnErrorResumeNextViaObservableTest.java |   7 +-
 .../operators/OperatorOnErrorReturnTest.java  |  11 +-
 ...nExceptionResumeNextViaObservableTest.java |  26 +--
 ...educeTest.java => OperatorReduceTest.java} |  18 +-
 .../java/rx/operators/OperatorRepeatTest.java |  16 +-
 .../operators/OperatorSequenceEqualTest.java  |   5 +-
 .../rx/operators/OperatorSerializeTest.java   | 188 +-----------------
 .../operators/OperatorSkipLastTimedTest.java  |  10 +-
 .../java/rx/operators/OperatorSkipTest.java   |  15 ++
 .../rx/operators/OperatorSkipTimedTest.java   |  12 +-
 ...leTest.java => OperatorSkipWhileTest.java} |   2 +-
 .../java/rx/operators/OperatorSwitchTest.java | 113 ++++-------
 .../operators/OperatorTakeLastTimedTest.java  |  29 ++-
 .../java/rx/operators/OperatorTakeTest.java   |  34 ++--
 .../rx/operators/OperatorTakeTimedTest.java   |  10 +-
 .../rx/operators/OperatorTakeUntilTest.java   |   7 +-
 .../rx/operators/OperatorTakeWhileTest.java   |   6 +-
 .../operators/OperatorThrottleFirstTest.java  |   5 +-
 .../OperatorTimeoutWithSelectorTest.java      |  17 +-
 .../java/rx/operators/OperatorTimerTest.java  |  22 +-
 .../java/rx/operators/OperatorToMapTest.java  |   3 +
 .../rx/operators/OperatorToMultimapTest.java  |   3 +
 .../OperatorToObservableFutureTest.java       |   4 +
 .../operators/OperatorUnsubscribeOnTest.java  |  15 ++
 .../java/rx/operators/OperatorUsingTest.java  |  12 +-
 .../java/rx/operators/OperatorWindowTest.java |  13 +-
 ...on.java => OperatorZipCompletionTest.java} |   2 +-
 .../rx/operators/OperatorZipIterableTest.java |  35 ++--
 .../java/rx/operators/OperatorZipTest.java    |  27 +--
 .../SafeObservableSubscriptionTest.java       |  36 ----
 .../java/rx/operators/SafeSubscriberTest.java |  20 +-
 .../java/rx/plugins/RxJavaPluginsTest.java    |   1 -
 .../rx/schedulers/AbstractSchedulerTests.java |  14 +-
 .../schedulers/ComputationSchedulerTests.java |   2 -
 .../java/rx/subjects/BehaviorSubjectTest.java |   6 +-
 .../java/rx/subjects/PublishSubjectTest.java  |   6 +-
 .../ReplaySubjectConcurrencyTest.java         |  20 +-
 .../java/rx/subjects/ReplaySubjectTest.java   |  10 +-
 167 files changed, 1051 insertions(+), 1358 deletions(-)
 delete mode 100644 rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java
 delete mode 100644 rxjava-core/src/main/java/rx/operators/SafeObserver.java
 create mode 100644 rxjava-core/src/test/java/rx/exceptions/TestException.java
 rename rxjava-core/src/test/java/rx/operators/{OperationBufferTest.java => OperatorBufferTest.java} (89%)
 rename rxjava-core/src/test/java/rx/operators/{OperationReduceTest.java => OperatorReduceTest.java} (86%)
 rename rxjava-core/src/test/java/rx/operators/{OperationSkipWhileTest.java => OperatorSkipWhileTest.java} (99%)
 rename rxjava-core/src/test/java/rx/operators/{OperationZipTestCompletion.java => OperatorZipCompletionTest.java} (98%)
 delete mode 100644 rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java

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 44a5a0b66d..805198b6fa 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
@@ -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/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 4c05c96b4a..dbf99b943d 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
@@ -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/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyCreateWrapper.java b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyCreateWrapper.java
index c94b0aaf57..a5149c857e 100644
--- a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyCreateWrapper.java
+++ b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyCreateWrapper.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/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 4adb8de014..e0b6132de2 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
@@ -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/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyOnSubscribeFuncWrapper.java b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyOnSubscribeFuncWrapper.java
index d8a4369a43..3e2bc1b638 100644
--- a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyOnSubscribeFuncWrapper.java
+++ b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/GroovyOnSubscribeFuncWrapper.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/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 8f12c8430b..0df587bfb5 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
@@ -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.
@@ -167,7 +167,7 @@ public String getName() {
             }
 
             @Override
-            public Class getReturnType() {
+            public Class<?> getReturnType() {
                 return m.getReturnType();
             }
 
@@ -177,6 +177,7 @@ public CachedClass getDeclaringClass() {
             }
 
             @Override
+            @SuppressWarnings("unchecked")
             public Object invoke(Object object, final Object[] arguments) {
                 return Observable.create(new GroovyCreateWrapper((Closure) arguments[0]));
             }
diff --git a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyPropertiesModuleFactory.java b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyPropertiesModuleFactory.java
index 149bca5621..ec80b6401e 100644
--- a/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyPropertiesModuleFactory.java
+++ b/language-adaptors/rxjava-groovy/src/main/java/rx/lang/groovy/RxGroovyPropertiesModuleFactory.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/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 d85ffbbf41..9bfef70a4c 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
@@ -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/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 d372ee136a..d9c5ae959e 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
@@ -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.
@@ -41,6 +41,11 @@
  * @param <T2>
  * @param <T3>
  * @param <T4>
+ * @param <T5>
+ * @param <T6>
+ * @param <T7>
+ * @param <T8>
+ * @param <T9>
  * @param <R>
  */
 public class JRubyFunctionWrapper<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
@@ -67,18 +72,21 @@ public JRubyFunctionWrapper(ThreadContext context, RubyProc proc) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call() {
         IRubyObject[] array = new IRubyObject[0];
         return (R) proc.call(context, array);
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1)};
         return (R) proc.call(context, array);
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2)};
@@ -86,6 +94,7 @@ public R call(T1 t1, T2 t2) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2, T3 t3) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2),
@@ -94,6 +103,7 @@ public R call(T1 t1, T2 t2, T3 t3) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2, T3 t3, T4 t4) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2),
@@ -103,6 +113,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2),
@@ -113,6 +124,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2),
@@ -124,6 +136,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2),
@@ -136,6 +149,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2),
@@ -149,6 +163,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
         IRubyObject[] array = {JavaUtil.convertJavaToRuby(runtime, t1),
                                JavaUtil.convertJavaToRuby(runtime, t2),
@@ -163,6 +178,7 @@ public R call(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public R call(Object... args) {
         IRubyObject[] array = new IRubyObject[args.length];
         for (int i = 0; i < args.length; i++) {
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 a8edadaf6b..5d1acf5361 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
@@ -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-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 f0e42f0d6d..adcdc4465e 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,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-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 7c117ccf44..2d9ec915da 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,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-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 6f26377da9..498a9547f7 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
@@ -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-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.java b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.java
index 58ed484ef5..055388d7dc 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/android/observables/Assertions.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.android.observables;
 
 import android.os.Looper;
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 ecf0ab4f21..327a8a7bd3 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
@@ -27,7 +27,7 @@
 public class ViewObservable {
 
     public static <T extends View> Observable<T> clicks(final T view, final boolean emitInitialValue) {
-        return Observable.create(new OperatorViewClick(view, emitInitialValue));
+        return Observable.create(new OperatorViewClick<T>(view, emitInitialValue));
     }
 
     public static Observable<String> input(final EditText input, final boolean emitInitialValue) {
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
index d43f0d2db2..3e807ab58b 100644
--- 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
@@ -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-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 0e786207c1..68d1bb43a1 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
@@ -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-contrib/rxjava-android/src/main/java/rx/operators/OperatorConditionalBinding.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorConditionalBinding.java
index 51713367ca..ef057f1799 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorConditionalBinding.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorConditionalBinding.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;
diff --git a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
index 3c7430c4e4..fbede3d868 100644
--- a/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.java
+++ b/rxjava-contrib/rxjava-android/src/main/java/rx/operators/OperatorObserveFromAndroidComponent.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-contrib/rxjava-android/src/test/java/rx/android/observables/AndroidObservableTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/observables/AndroidObservableTest.java
index fe7263da0f..166ee0f3bd 100644
--- 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
@@ -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-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
index 443901a1f7..97f5b7b150 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/android/operators/OperatorObserveFromAndroidComponentTest.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-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 8969e47a9e..3afea125f1 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
@@ -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-contrib/rxjava-android/src/test/java/rx/operators/OperatorConditionalBindingTest.java b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorConditionalBindingTest.java
index 3661dd3bc9..4a5c6233ec 100644
--- a/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorConditionalBindingTest.java
+++ b/rxjava-contrib/rxjava-android/src/test/java/rx/operators/OperatorConditionalBindingTest.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 static org.junit.Assert.assertEquals;
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 6ea424848a..ff10800e7e 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
@@ -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.
@@ -21,13 +21,13 @@
 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.HttpContext;
 import org.apache.http.protocol.BasicHttpContext;
+import org.apache.http.protocol.HttpContext;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.apache.http.consumers.ResponseConsumerDelegate;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
@@ -80,22 +80,22 @@
  */
 public class ObservableHttp<T> {
 
-    private final OnSubscribeFunc<T> onSubscribe;
+    private final OnSubscribe<T> onSubscribe;
 
-    private ObservableHttp(OnSubscribeFunc<T> onSubscribe) {
+    private ObservableHttp(OnSubscribe<T> onSubscribe) {
         this.onSubscribe = onSubscribe;
     }
 
-    private static <T> ObservableHttp<T> create(OnSubscribeFunc<T> onSubscribe) {
+    private static <T> ObservableHttp<T> create(OnSubscribe<T> onSubscribe) {
         return new ObservableHttp<T>(onSubscribe);
     }
 
     public Observable<T> toObservable() {
-        return Observable.create(new OnSubscribeFunc<T>() {
+        return Observable.create(new OnSubscribe<T>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super T> observer) {
-                return onSubscribe.onSubscribe(observer);
+            public void call(Subscriber<? super T> observer) {
+                onSubscribe.call(observer);
             }
         });
     }
@@ -133,7 +133,7 @@ public static ObservableHttp<ObservableHttpResponse> createGet(String uri, final
      * 
      * @param requestProducer
      * @param client
-     * @return
+     * @return the observable HTTP response stream
      */
     public static ObservableHttp<ObservableHttpResponse> createRequest(final HttpAsyncRequestProducer requestProducer, final HttpAsyncClient client) {
         return createRequest(requestProducer, client, new BasicHttpContext());
@@ -169,16 +169,17 @@ public static ObservableHttp<ObservableHttpResponse> createRequest(final HttpAsy
      * @param requestProducer
      * @param client
      * @param context The HttpContext
-     * @return
+     * @return the observable HTTP response stream
      */
     public static ObservableHttp<ObservableHttpResponse> createRequest(final HttpAsyncRequestProducer requestProducer, final HttpAsyncClient client, final HttpContext context) {
 
-        return ObservableHttp.create(new OnSubscribeFunc<ObservableHttpResponse>() {
+        return ObservableHttp.create(new OnSubscribe<ObservableHttpResponse>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super ObservableHttpResponse> observer) {
+            public void call(final Subscriber<? super ObservableHttpResponse> observer) {
 
                 final CompositeSubscription parentSubscription = new CompositeSubscription();
+                observer.add(parentSubscription);
 
                 // return a Subscription that wraps the Future so it can be cancelled
                 parentSubscription.add(Subscriptions.from(client.execute(requestProducer, new ResponseConsumerDelegate(observer, parentSubscription),
@@ -200,8 +201,6 @@ public void cancelled() {
                             }
 
                         })));
-
-                return parentSubscription;
             }
         });
     }
diff --git a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttpResponse.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttpResponse.java
index 8077152ccc..66cbe43a39 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttpResponse.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/ObservableHttpResponse.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-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ExpandableByteBuffer.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ExpandableByteBuffer.java
index da6c81e7f2..f346ec7266 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ExpandableByteBuffer.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ExpandableByteBuffer.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-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerBasic.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerBasic.java
index 8101c9ad8d..88d92e6b1a 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerBasic.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerBasic.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.
@@ -27,9 +27,9 @@
 import org.apache.http.protocol.HttpContext;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.apache.http.ObservableHttpResponse;
 import rx.subscriptions.CompositeSubscription;
 
@@ -68,10 +68,11 @@ public void _onEntityEnclosed(HttpEntity entity, ContentType contentType) throws
     public HttpResponse _buildResult(HttpContext context) throws Exception {
         final HttpResponse response = buildResult(context);
 
-        Observable<byte[]> contentObservable = Observable.create(new OnSubscribeFunc<byte[]>() {
+        Observable<byte[]> contentObservable = Observable.create(new OnSubscribe<byte[]>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super byte[]> o) {
+            public void call(Subscriber<? super byte[]> o) {
+                o.add(parentSubscription);
                 long length = response.getEntity().getContentLength();
                 if (length > Integer.MAX_VALUE) {
                     o.onError(new IllegalStateException("Content Length too large for a byte[] => " + length));
@@ -85,8 +86,6 @@ public Subscription onSubscribe(Observer<? super byte[]> o) {
                         o.onError(e);
                     }
                 }
-
-                return parentSubscription;
             }
         });
 
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 24671e7051..7fa7b342ca 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
@@ -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-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerEventStream.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerEventStream.java
index be8407aecf..8aed85af93 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerEventStream.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseConsumerEventStream.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.
@@ -29,9 +29,9 @@
 import org.apache.http.protocol.HttpContext;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.apache.http.ObservableHttpResponse;
 import rx.subjects.PublishSubject;
 import rx.subscriptions.CompositeSubscription;
@@ -81,12 +81,12 @@ protected void onByteReceived(ByteBuffer buf, IOControl ioctrl) throws IOExcepti
     protected void onResponseReceived(HttpResponse response) throws HttpException, IOException {
 
         // wrap the contentSubject so we can chain the Subscription between parent and child
-        Observable<byte[]> contentObservable = Observable.create(new OnSubscribeFunc<byte[]>() {
+        Observable<byte[]> contentObservable = Observable.create(new OnSubscribe<byte[]>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super byte[]> observer) {
+            public void call(Subscriber<? super byte[]> observer) {
+                observer.add(parentSubscription);
                 parentSubscription.add(contentSubject.subscribe(observer));
-                return parentSubscription;
             }
         });
         observer.onNext(new ObservableHttpResponse(response, contentObservable));
diff --git a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseDelegate.java b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseDelegate.java
index 566237a9d1..92333cd101 100644
--- a/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseDelegate.java
+++ b/rxjava-contrib/rxjava-apache-http/src/main/java/rx/apache/http/consumers/ResponseDelegate.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-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 37fe6e8925..4f65c09eaa 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
@@ -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-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorDeferFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorDeferFutureTest.java
index 16a703e2d6..2386165ebc 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorDeferFutureTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorDeferFutureTest.java
@@ -15,9 +15,12 @@
  */
 package rx.util.async.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.fail;
+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 java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
@@ -31,6 +34,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.Func0;
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
@@ -89,7 +93,7 @@ public void testSimpleFactoryThrows() {
 
             @Override
             public Future<Observable<Integer>> call() {
-                throw new OperatorStartFutureTest.CustomException();
+                throw new TestException();
             }
         };
         
@@ -100,6 +104,6 @@ public Future<Observable<Integer>> call() {
         
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        verify(observer).onError(any(OperatorStartFutureTest.CustomException.class));
+        verify(observer).onError(any(TestException.class));
     }
 }
\ No newline at end of file
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorForEachFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorForEachFutureTest.java
index 0d8a60c85b..3075c79942 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorForEachFutureTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorForEachFutureTest.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
  /**
-  * 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.
@@ -30,7 +30,8 @@
   */
 package rx.util.async.operators;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -43,6 +44,7 @@
 import org.junit.Test;
 
 import rx.Observable;
+import rx.exceptions.TestException;
 import rx.functions.Action1;
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
@@ -85,14 +87,13 @@ public void call(Integer t1) {
             exec.shutdown();
         }
     }
-    private static final class CustomException extends RuntimeException { }
     @Test
     public void testSimpleThrowing() {
         
         final ExecutorService exec = Executors.newCachedThreadPool();
         
         try {
-            Observable<Integer> source = Observable.<Integer>error(new CustomException())
+            Observable<Integer> source = Observable.<Integer>error(new TestException())
                     .subscribeOn(Schedulers.computation());
             
             final AtomicInteger sum = new AtomicInteger();
@@ -112,7 +113,7 @@ public void call(Integer t1) {
             } catch (TimeoutException ex) {
                 fail("Timed out: " + ex);
             } catch (ExecutionException ex) {
-                if (!(ex.getCause() instanceof CustomException)) {
+                if (!(ex.getCause() instanceof TestException)) {
                     fail("Got different exception: " + ex.getCause());
                 }
             } catch (InterruptedException ex) {
@@ -157,7 +158,7 @@ public void call(Integer t1) {
     @Test
     public void testSimpleScheduledThrowing() {
         
-        Observable<Integer> source = Observable.<Integer>error(new CustomException())
+        Observable<Integer> source = Observable.<Integer>error(new TestException())
                 .subscribeOn(Schedulers.computation());
         
         final AtomicInteger sum = new AtomicInteger();
@@ -175,7 +176,7 @@ public void call(Integer t1) {
         } catch (TimeoutException ex) {
             fail("Timed out: " + ex);
         } catch (ExecutionException ex) {
-            if (!(ex.getCause() instanceof CustomException)) {
+            if (!(ex.getCause() instanceof TestException)) {
                 fail("Got different exception: " + ex.getCause());
             }
         } catch (InterruptedException ex) {
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorFromFunctionalsTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorFromFunctionalsTest.java
index ce31712175..aed539f67b 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorFromFunctionalsTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorFromFunctionalsTest.java
@@ -16,7 +16,12 @@
 
 package rx.util.async.operators;
 
-import static org.mockito.Mockito.*;
+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 java.io.IOException;
 import java.util.concurrent.Callable;
@@ -32,7 +37,6 @@
 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;
diff --git a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorStartFutureTest.java b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorStartFutureTest.java
index 66948f906f..0c6f800926 100644
--- a/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorStartFutureTest.java
+++ b/rxjava-contrib/rxjava-async-util/src/test/java/rx/util/async/operators/OperatorStartFutureTest.java
@@ -15,9 +15,12 @@
  */
 package rx.util.async.operators;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.fail;
+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 java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
@@ -31,13 +34,12 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.Func0;
 import rx.schedulers.Schedulers;
 import rx.util.async.Async;
 
 public class OperatorStartFutureTest {
-    /** 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.
@@ -135,7 +137,7 @@ public void testSimpleFactoryThrows() {
 
             @Override
             public Future<Integer> call() {
-                throw new CustomException();
+                throw new TestException();
             }
         };
         
@@ -146,6 +148,6 @@ public Future<Integer> call() {
         
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        verify(observer).onError(any(CustomException.class));
+        verify(observer).onError(any(TestException.class));
     }
 }
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 f536b9c8d5..f980c041b7 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
@@ -26,7 +26,7 @@
  * Imperative statements expressed as Observable operators.
  */
 public final class Statement {
-	private Statement() { throw new IllegalStateException("No instances!"); }
+    private Statement() { throw new IllegalStateException("No instances!"); }
     /**
      * Return a particular one of several possible Observables based on a case
      * selector.
@@ -94,7 +94,7 @@ public static <K, R> Observable<R> switchCase(Func0<? extends K> caseSelector,
      * @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}
+     *            the default Observable if the {@code mapOfCases} doesn't contain a value for the key returned by the {@code caseSelector}
      * @return a particular Observable chosen by key from the map of
      *         Observables, or the default case if no Observable matches the key
      */
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.java
index 827124e29a..68a60bcb51 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorIfThen.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;
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.java
index 53cf09f62f..ab5fbcf9f0 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorSwitchCase.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.Map;
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.java b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.java
index bade4c427e..2cecb64132 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/main/java/rx/operators/OperatorWhileDoWhile.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;
diff --git a/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperatorConditionalsTest.java b/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperatorConditionalsTest.java
index d59b0ed2ac..c927a0613c 100644
--- a/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperatorConditionalsTest.java
+++ b/rxjava-contrib/rxjava-computation-expressions/src/test/java/rx/operators/OperatorConditionalsTest.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.
@@ -232,9 +232,9 @@ public void testMapGetThrows() {
         Observable<Integer> source2 = Observable.from(4, 5, 6);
 
         Map<Integer, Observable<Integer>> map = new HashMap<Integer, Observable<Integer>>() {
-			private static final long serialVersionUID = -4342868139960216388L;
+            private static final long serialVersionUID = -4342868139960216388L;
 
-			@Override
+            @Override
             public Observable<Integer> get(Object key) {
                 if (key.equals(2)) {
                     throw new RuntimeException("Forced failure!");
@@ -257,9 +257,9 @@ public void testMapContainsKeyThrows() {
         Observable<Integer> source1 = Observable.from(1, 2, 3);
 
         Map<Integer, Observable<Integer>> map = new HashMap<Integer, Observable<Integer>>() {
-			private static final long serialVersionUID = 1975411728567003983L;
+            private static final long serialVersionUID = 1975411728567003983L;
 
-			@Override
+            @Override
             public boolean containsKey(Object key) {
                 if (key.equals(2)) {
                     throw new RuntimeException("Forced failure!");
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 9e48267333..22d61a16d6 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,6 @@
 import rx.Observable.Operator;
 import rx.Subscriber;
 import rx.Subscription;
-import rx.functions.Action1;
-import rx.functions.Action2;
-import rx.functions.Actions;
-import rx.functions.Func1;
-import rx.functions.Functions;
 import rx.operators.DebugSubscriber;
 
 /**
@@ -25,11 +20,9 @@ public class DebugHook<C> extends RxJavaObservableExecutionHook {
      * Creates a new instance of the DebugHook RxJava plug-in that can be passed into
      * {@link RxJavaPlugins} registerObservableExecutionHook(hook) method.
      * 
-     * @param onNextDataHook
+     * @param listener
      *            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(DebugNotificationListener<C> listener) {
         if (listener == null)
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 f7e065b50c..cc011d48fd 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
@@ -19,6 +19,7 @@ public static enum Kind {
     private final Operator<?, ? super T> to;
     private final Throwable throwable;
     private final T value;
+    @SuppressWarnings("rawtypes")
     private final Observer observer;
 
     @SuppressWarnings("unchecked")
@@ -29,13 +30,14 @@ public static <T, C> DebugNotification<T> createSubscribe(Observer<? super T> o,
             o = ((SafeSubscriber<T>) o).getActual();
         }
         if (o instanceof DebugSubscriber) {
+            @SuppressWarnings("rawtypes")
             final DebugSubscriber ds = (DebugSubscriber) o;
             to = ds.getTo();
             from = ds.getFrom();
             o = ds.getActual();
         }
         if (sourceFunc instanceof DebugHook.DebugOnSubscribe) {
-            sourceFunc = (OnSubscribe<T>) ((SafeSubscriber) sourceFunc).getActual();
+            sourceFunc = (OnSubscribe<T>) ((SafeSubscriber<T>) sourceFunc).getActual();
         }
         return new DebugNotification<T>(o, from, Kind.Subscribe, null, null, to, source, sourceFunc);
     }
@@ -56,6 +58,7 @@ public static <T> DebugNotification<T> createUnsubscribe(Observer<? super T> o,
         return new DebugNotification<T>(o, from, Kind.Unsubscribe, null, null, to, null, null);
     }
 
+    @SuppressWarnings("rawtypes")
     private DebugNotification(Observer o, Operator<? extends T, ?> from, Kind kind, T value, Throwable throwable, Operator<?, ? super T> to, Observable<? extends T> source, OnSubscribe<T> sourceFunc) {
         this.observer = (o instanceof SafeSubscriber) ? ((SafeSubscriber) o).getActual() : o;
         this.from = from;
@@ -67,6 +70,7 @@ private DebugNotification(Observer o, Operator<? extends T, ?> from, Kind kind,
         this.sourceFunc = sourceFunc;
     }
 
+    @SuppressWarnings("rawtypes")
     public Observer getObserver() {
         return observer;
     }
diff --git a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.java b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.java
index f34e25159e..7c306a01ac 100644
--- a/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.java
+++ b/rxjava-contrib/rxjava-debug/src/main/java/rx/plugins/DebugNotificationListener.java
@@ -14,7 +14,6 @@
  *            Context type that is returned from start and passed to either complete or error.
  * @see DebugHook
  */
-@SuppressWarnings("unused")
 public abstract class DebugNotificationListener<C> {
     /**
      * Override this to change the default behavior of returning the encapsulated value. This will
@@ -29,7 +28,7 @@ public abstract class DebugNotificationListener<C> {
      * 
      * @param n
      *            {@link DebugNotification} containing the data and context about what is happening.
-     * @return
+     * @return the notification's value
      */
     public <T> T onNext(DebugNotification<T> n) {
         return n.getValue();
@@ -43,8 +42,8 @@ public <T> T onNext(DebugNotification<T> n) {
      * @param n
      *            {@link DebugNotification} containing the data and context about what is happening.
      * @return
-     *         A contextual object that the listener can use in the {@link #complete(C)} or
-     *         {@link #error(C, Throwable)} after the actual operation has ended.
+     *         A contextual object that the listener can use in the {@link #complete(Object) } or
+     *         {@link #error(Object, Throwable)} after the actual operation has ended.
      */
     public <T> C start(DebugNotification<T> n) {
         return null;
@@ -64,6 +63,7 @@ public void complete(C context) {
      * this is invoked
      * 
      * @param context
+     * @param e
      */
     public void error(C context, Throwable e) {
     }
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 5fdba559a6..cb1419f3f2 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
@@ -91,6 +91,7 @@ public void assertValidState() {
     public void testSimple() {
         TestDebugNotificationListener listener = new TestDebugNotificationListener();
         listener = spy(listener);
+        @SuppressWarnings("rawtypes")
         final DebugHook hook = new DebugHook(listener);
         RxJavaPlugins.getInstance().registerObservableExecutionHook(hook);
 
@@ -210,6 +211,7 @@ public void describeTo(Description description) {
         });
     }
 
+    @SuppressWarnings("rawtypes")
     private static <T> DebugNotification subscribe() {
         return argThat(new BaseMatcher<DebugNotification<T>>() {
             @Override
@@ -228,6 +230,7 @@ public void describeTo(Description description) {
         });
     }
 
+    @SuppressWarnings("rawtypes")
     private static <T> DebugNotification unsubscribe() {
         return argThat(new BaseMatcher<DebugNotification<T>>() {
             @Override
@@ -246,6 +249,7 @@ public void describeTo(Description description) {
         });
     }
 
+    @SuppressWarnings("rawtypes")
     private static DebugNotification onCompleted() {
         return argThat(new BaseMatcher<DebugNotification>() {
             @Override
diff --git a/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern1.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern1.java
index d31e388638..2f39a6b3c4 100644
--- a/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern1.java
+++ b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/Pattern1.java
@@ -38,7 +38,7 @@ public Observable<T1> first() {
      * 
      * @param selector
      *            the function that will be invoked for elements in the source sequences.
-     * @return
+     * @return the plan for the matching
      * @throws NullPointerException
      *             if selector is null
      */
diff --git a/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperatorJoinPatterns.java b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperatorJoinPatterns.java
index 1079796f03..98e93479e7 100644
--- a/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperatorJoinPatterns.java
+++ b/rxjava-contrib/rxjava-joins/src/main/java/rx/joins/operators/OperatorJoinPatterns.java
@@ -121,7 +121,7 @@ public void call(ActivePlan0 activePlan) {
                         }));
                     }
                 } catch (Throwable t) {
-                	Observable.<R> error(t).unsafeSubscribe(t1);
+                    Observable.<R> error(t).unsafeSubscribe(t1);
                     return;
                 }
                 CompositeSubscription group = new CompositeSubscription();
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
index baad9ff8e6..d2071a9b49 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageDouble.java
@@ -35,7 +35,7 @@ public OperatorAverageDouble(Func1<? super T, Double> valueExtractor) {
 
     @Override
     public Subscriber<? super T> call(Subscriber<? super Double> child) {
-    	return new AverageObserver(child);
+        return new AverageObserver(child);
     }
 
     /** Computes the average. */
@@ -45,7 +45,7 @@ private final class AverageObserver extends Subscriber<T> {
         int count;
 
         public AverageObserver(Subscriber<? super Double> subscriber) {
-        	super(subscriber);
+            super(subscriber);
             this.child = subscriber;
         }
 
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
index 148d4f3d84..15ef0a7045 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageFloat.java
@@ -45,7 +45,7 @@ private final class AverageObserver extends Subscriber<T> {
         int count;
 
         public AverageObserver(Subscriber<? super Float> subscriber) {
-        	super(subscriber);
+            super(subscriber);
             this.child = subscriber;
         }
 
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
index ef037101bd..437975e887 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageInteger.java
@@ -45,7 +45,7 @@ private final class AverageObserver extends Subscriber<T> {
         int count;
 
         public AverageObserver(Subscriber<? super Integer> subscriber) {
-        	super(subscriber);
+            super(subscriber);
             this.child = subscriber;
         }
 
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
index 5f879a0528..a5725adfb2 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorAverageLong.java
@@ -45,7 +45,7 @@ private final class AverageObserver extends Subscriber<T> {
         int count;
 
         public AverageObserver(Subscriber<? super Long> subscriber) {
-        	super(subscriber);
+            super(subscriber);
             this.child = subscriber;
         }
 
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorMinMax.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorMinMax.java
index d3a42fc2f2..75d7696879 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorMinMax.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorMinMax.java
@@ -27,7 +27,7 @@
  * Returns the minimum element in an observable sequence.
  */
 public final class OperatorMinMax {
-	private OperatorMinMax() { throw new IllegalStateException("No instances!"); }
+    private OperatorMinMax() { throw new IllegalStateException("No instances!"); }
 
     public static <T extends Comparable<? super T>> Observable<T> min(
             Observable<T> source) {
diff --git a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorSum.java b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorSum.java
index 19bd0e9fa3..cdd3acf21d 100644
--- a/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorSum.java
+++ b/rxjava-contrib/rxjava-math/src/main/java/rx/math/operators/OperatorSum.java
@@ -26,7 +26,7 @@
  *      Observable.Sum</a>
  */
 public final class OperatorSum {
-	private OperatorSum() { throw new IllegalStateException("No instances!"); }
+    private OperatorSum() { throw new IllegalStateException("No instances!"); }
 
     public static Observable<Integer> sumIntegers(Observable<Integer> source) {
         return source.reduce(0, ACCUM_INT);
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorAverageTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorAverageTest.java
index b53d19d874..938255dc87 100644
--- a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorAverageTest.java
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorAverageTest.java
@@ -358,6 +358,6 @@ public Double call(String t1) {
     }
     
     static class CustomException extends RuntimeException {
-		private static final long serialVersionUID = 6873927510089089979L;
+        private static final long serialVersionUID = 6873927510089089979L;
     }
 }
diff --git a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorSumTest.java b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorSumTest.java
index ddb057c0a9..b3e4fc9e20 100644
--- a/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorSumTest.java
+++ b/rxjava-contrib/rxjava-math/src/test/java/rx/math/operators/OperatorSumTest.java
@@ -354,6 +354,6 @@ public Double call(String t1) {
     }
 
     static class CustomException extends RuntimeException {
-		private static final long serialVersionUID = 8825937249852675778L;
+        private static final long serialVersionUID = 8825937249852675778L;
     }
 }
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
index 86785acdc0..941ddb8c05 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/ChannelObservable.java
@@ -82,7 +82,7 @@ public static <T> Observable<T> from(ReceivePort<T> channel, Scheduler scheduler
      * @param <T>     the type of messages that can be sent to the channel and the type of items to be
      *                received by the Observer
      * @param channel the target {@link SendPort}
-     * @return
+     * @return the observer
      */
     public static <T> Observer<T> to(final SendPort<T> channel) {
         return new Observer<T>() {
@@ -116,7 +116,7 @@ public void onError(Throwable e) {
      * <p>
      * @param <T>        the type of messages emitted by the observable and received on the channel.
      * @param bufferSize the channel's buffer size
-     * @param policy     the channel's {@link Channels.OverflowPolicy OverflowPolicy}
+     * @param policy     the channel's {@link Channels.OverflowPolicy}
      * @param o          the observable
      * @return A new channel with the given buffer size and overflow policy that will receive all events emitted by the observable.
      */
diff --git a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
index 7893a447df..6706ac9d28 100644
--- a/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
+++ b/rxjava-contrib/rxjava-quasar/src/main/java/rx/quasar/NewFiberScheduler.java
@@ -73,7 +73,7 @@ public Subscription schedule(final Action0 action) {
             }
 
             final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
-            final Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
+            final Subscription s = Subscriptions.from(new Fiber<Void>(fiberScheduler, new SuspendableRunnable() {
 
                 @Override
                 public void run() throws SuspendExecution {
@@ -109,7 +109,7 @@ public void call() {
         public Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit) {
             final AtomicReference<Subscription> sf = new AtomicReference<Subscription>();
 
-            final Subscription s = Subscriptions.from(new Fiber(fiberScheduler, new SuspendableRunnable() {
+            final Subscription s = Subscriptions.from(new Fiber<Void>(fiberScheduler, new SuspendableRunnable() {
 
                 @Override
                 public void run() throws InterruptedException, SuspendExecution  {
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
index 3a640ac00d..5ff2bcf6da 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/BlockingObservableTest.java
@@ -25,13 +25,9 @@
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
-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 co.paralleluniverse.strands.channels.ProducerException;
 import co.paralleluniverse.strands.channels.ReceivePort;
 
@@ -249,13 +245,12 @@ public void testToChannelManyTimes() throws Exception {
 
     @Test(expected = TestException.class)
     public void testToChannelWithException() throws Throwable {
-        BlockingObservable<String> obs = BlockingObservable.from(Observable.create(new Observable.OnSubscribeFunc<String>() {
+        BlockingObservable<String> obs = BlockingObservable.from(Observable.create(new Observable.OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new TestException());
-                return Subscriptions.empty();
             }
         }));
 
@@ -274,11 +269,10 @@ public Subscription onSubscribe(Observer<? super String> observer) {
     @Test
     public void testForEachWithError() {
         try {
-            BlockingObservable.from(Observable.create(new Observable.OnSubscribeFunc<String>() {
+            BlockingObservable.from(Observable.create(new Observable.OnSubscribe<String>() {
 
                 @Override
-                public Subscription onSubscribe(final Observer<? super String> observer) {
-                    final BooleanSubscription subscription = new BooleanSubscription();
+                public void call(final Subscriber<? super String> observer) {
                     new Thread(new Runnable() {
 
                         @Override
@@ -289,7 +283,6 @@ public void run() {
                             observer.onCompleted();
                         }
                     }).start();
-                    return subscription;
                 }
             })).forEach(new Action1<String>() {
 
diff --git a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
index b048ae57a9..6890cc9536 100644
--- a/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
+++ b/rxjava-contrib/rxjava-quasar/src/test/java/rx/quasar/ChannelObservableTest.java
@@ -34,6 +34,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.subjects.PublishSubject;
 import co.paralleluniverse.fibers.Fiber;
 import co.paralleluniverse.fibers.SuspendExecution;
@@ -122,7 +123,7 @@ public void testObserverChannelWithError() throws Exception {
         ReceivePort<String> c = ChannelObservable.subscribe(10, Channels.OverflowPolicy.BLOCK, o);
 
         o.onNext("a");
-        o.onError(new MyException());
+        o.onError(new TestException());
         o.onNext("c");
 
         assertThat(c.receive(), equalTo("a"));
@@ -130,7 +131,7 @@ public void testObserverChannelWithError() throws Exception {
             c.receive();
             fail();
         } catch (ProducerException e) {
-            assertThat(e.getCause(), instanceOf(MyException.class));
+            assertThat(e.getCause(), instanceOf(TestException.class));
         }
         assertThat(c.isClosed(), is(true));
     }
@@ -186,7 +187,7 @@ public String run() throws SuspendExecution, InterruptedException {
     public void whenGetAndObservableEmitsTwoValuesThenBlowup() throws Exception {
         final PublishSubject<String> o = PublishSubject.create();
 
-        Fiber<String> f = new Fiber<String>(new SuspendableCallable<String>() {
+        new Fiber<String>(new SuspendableCallable<String>() {
 
             @Override
             public String run() throws SuspendExecution, InterruptedException {
@@ -207,8 +208,4 @@ public String run() throws SuspendExecution, InterruptedException {
         } catch (Exception e) {
         }
     }
-
-    static class MyException extends RuntimeException {
-
-    }
 }
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 16f410bf6d..d99df380c7 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,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.
@@ -39,11 +39,11 @@
 public class StringObservable {
     /**
      * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
-     * {@link byte[]}s
+     * {@code byte[]}s
      * 
      * @param i
      *            Source {@link InputStream}
-     * @return
+     * @return the Observable containing read byte arrays from the input
      */
     public static Observable<byte[]> from(final InputStream i) {
         return from(i, 8 * 1024);
@@ -51,13 +51,13 @@ public static Observable<byte[]> from(final InputStream i) {
 
     /**
      * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
-     * {@link byte[]}s
+     * {@code byte[]}s
      * 
      * @param i
      *            Source {@link InputStream}
      * @param size
      *            internal buffer size
-     * @return
+     * @return the Observable containing read byte arrays from the input
      */
     public static Observable<byte[]> from(final InputStream i, final int size) {
         return Observable.create(new OnSubscribe<byte[]>() {
@@ -89,7 +89,7 @@ public void call(Subscriber<? super byte[]> o) {
      * 
      * @param i
      *            Source {@link Reader}
-     * @return
+     * @return the Observable of Strings read from the source
      */
     public static Observable<String> from(final Reader i) {
         return from(i, 8 * 1024);
@@ -103,7 +103,7 @@ public static Observable<String> from(final Reader i) {
      *            Source {@link Reader}
      * @param size
      *            internal buffer size
-     * @return
+     * @return the Observable of Strings read from the source
      */
     public static Observable<String> from(final Reader i, final int size) {
         return Observable.create(new OnSubscribe<String>() {
@@ -135,7 +135,7 @@ public void call(Subscriber<? super String> o) {
      * 
      * @param src
      * @param charsetName
-     * @return
+     * @return the Observable returning a stream of decoded strings
      */
     public static Observable<String> decode(Observable<byte[]> src, String charsetName) {
         return decode(src, Charset.forName(charsetName));
@@ -147,7 +147,7 @@ public static Observable<String> decode(Observable<byte[]> src, String charsetNa
      * 
      * @param src
      * @param charset
-     * @return
+     * @return the Observable returning a stream of decoded strings
      */
     public static Observable<String> decode(Observable<byte[]> src, Charset charset) {
         return decode(src, charset.newDecoder().onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE));
@@ -160,7 +160,7 @@ public static Observable<String> decode(Observable<byte[]> src, Charset charset)
      * 
      * @param src
      * @param charsetDecoder
-     * @return
+     * @return the Observable returning a stream of decoded strings
      */
     public static Observable<String> decode(final Observable<byte[]> src, final CharsetDecoder charsetDecoder) {
         return src.lift(new Operator<String, byte[]>() {
@@ -249,7 +249,7 @@ public boolean process(byte[] next, ByteBuffer last, boolean endOfInput) {
      * 
      * @param src
      * @param charsetName
-     * @return
+     * @return the Observable with a stream of encoded byte arrays
      */
     public static Observable<byte[]> encode(Observable<String> src, String charsetName) {
         return encode(src, Charset.forName(charsetName));
@@ -260,7 +260,7 @@ public static Observable<byte[]> encode(Observable<String> src, String charsetNa
      * 
      * @param src
      * @param charset
-     * @return
+     * @return the Observable with a stream of encoded byte arrays
      */
     public static Observable<byte[]> encode(Observable<String> src, Charset charset) {
         return encode(src, charset.newEncoder().onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE));
@@ -272,7 +272,7 @@ public static Observable<byte[]> encode(Observable<String> src, Charset charset)
      * 
      * @param src
      * @param charsetEncoder
-     * @return
+     * @return the Observable with a stream of encoded byte arrays
      */
     public static Observable<byte[]> encode(Observable<String> src, final CharsetEncoder charsetEncoder) {
         return src.map(new Func1<String, byte[]>() {
@@ -295,7 +295,7 @@ public byte[] call(String str) {
      * this on infinite streams.
      * 
      * @param src
-     * @return
+     * @return the Observable returing all strings concatenated as a single string
      */
     public static Observable<String> stringConcat(Observable<String> src) {
         return src.reduce(new Func2<String, String, String>() {
@@ -318,7 +318,7 @@ public String call(String a, String b) {
      * 
      * @param src
      * @param regex
-     * @return
+     * @return the Observable streaming the split values
      */
     public static Observable<String> split(final Observable<String> src, String regex) {
         final Pattern pattern = Pattern.compile(regex);
@@ -489,7 +489,7 @@ public String toString() {
      * Splits the {@link Observable} of Strings by lines and numbers them (zero based index)
      * 
      * @param source
-     * @return
+     * @return the Observable conaining the split lines of the source
      */
     public static Observable<Line> byLine(Observable<String> source) {
         return split(source, System.getProperty("line.separator")).map(new Func1<String, Line>() {
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 566ee92666..aced4c12b8 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,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.
@@ -15,13 +15,18 @@
  */
 package rx.observables;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+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.io.ByteArrayInputStream;
 import java.io.IOException;
-import java.io.NotSerializableException;
 import java.io.StringReader;
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetDecoder;
@@ -29,8 +34,6 @@
 import java.util.Arrays;
 import java.util.List;
 
-import junit.framework.Assert;
-
 import org.junit.Test;
 
 import rx.Observable;
@@ -141,10 +144,11 @@ public void testSplit(String message, String regex, int limit, Observable<String
 
     @Test
     public void testJoinMixed() {
-        Observable<Object> source = Observable.<Object> from(Arrays.asList("a", 1, "c"));
+        Observable<Object> source = Observable.<Object> from(Arrays.<Object>asList("a", 1, "c"));
 
         Observable<String> result = StringObservable.join(source, ", ");
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
 
         result.subscribe(new TestObserver<Object>(observer));
@@ -160,6 +164,7 @@ public void testJoinWithEmptyString() {
 
         Observable<String> result = StringObservable.join(source, ", ");
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
 
         result.subscribe(new TestObserver<Object>(observer));
@@ -175,6 +180,7 @@ public void testJoinWithNull() {
 
         Observable<String> result = StringObservable.join(source, ", ");
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
 
         result.subscribe(new TestObserver<Object>(observer));
@@ -190,6 +196,7 @@ public void testJoinSingle() {
 
         Observable<String> result = StringObservable.join(source, ", ");
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
 
         result.subscribe(new TestObserver<Object>(observer));
@@ -205,6 +212,7 @@ public void testJoinEmpty() {
 
         Observable<String> result = StringObservable.join(source, ", ");
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
 
         result.subscribe(new TestObserver<Object>(observer));
@@ -220,6 +228,7 @@ public void testJoinThrows() {
 
         Observable<String> result = StringObservable.join(source, ", ");
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
 
         result.subscribe(new TestObserver<Object>(observer));
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 ab22538e2e..3b3c74e1aa 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
@@ -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-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/schedulers/SwingScheduler.java
index e8d5529c8c..c63655a3a4 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
@@ -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-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
index 1099bbc240..649fa6baae 100644
--- a/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.java
+++ b/rxjava-contrib/rxjava-swing/src/main/java/rx/subscriptions/SwingSubscriptions.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-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 037c9fa9e0..b88bace482 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
@@ -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-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 eb2b3a5c41..6ad91d2f44 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
@@ -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-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 1b5107de08..0d7b93d293 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
@@ -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-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 d14ef8d471..cf4367eeca 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
@@ -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-contrib/rxjava-swing/src/main/java/rx/swing/sources/SwingTestHelper.java b/rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/SwingTestHelper.java
index 1a34d026ae..76a83accad 100644
--- 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
@@ -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-contrib/rxjava-swing/src/test/java/rx/schedulers/SwingSchedulerTest.java b/rxjava-contrib/rxjava-swing/src/test/java/rx/schedulers/SwingSchedulerTest.java
index 36f57b1d1f..40b6a475d3 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
@@ -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 894760032d..752f5684f5 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -122,7 +122,7 @@ public void call(Subscriber<? super T> observer) {
     }
 
     /**
-     * @deprecated use {@link #OnSubscribe}
+     * @deprecated use {@link OnSubscribe}
      */
     @Deprecated
     public static interface OnSubscribeFunc<T> extends Function {
@@ -2104,7 +2104,6 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Combining-Observables#wiki-mergedelayerror">RxJava Wiki: mergeDelayError()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229099.aspx">MSDN: Observable.Merge</a>
      */
-    @SuppressWarnings("unchecked")
     // suppress because the types are checked by the method signature before using a vararg
     public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1, Observable<? extends T> t2, Observable<? extends T> t3, Observable<? extends T> t4, Observable<? extends T> t5, Observable<? extends T> t6, Observable<? extends T> t7, Observable<? extends T> t8) {
         return mergeDelayError(from(t1, t2, t3, t4, t5, t6, t7, t8));
@@ -2247,7 +2246,7 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/pivot.ex.png">
      * 
      * @param groups
-     * @return
+     * @return an Observable containing a stream of nested GroupedObservables with swapped inner-outer keys.
      */
     public static final <K1, K2, T> Observable<GroupedObservable<K2, GroupedObservable<K1, T>>> pivot(Observable<GroupedObservable<K1, GroupedObservable<K2, T>>> groups) {
         return groups.lift(new OperatorPivot<K1, K2, T>());
@@ -6568,7 +6567,7 @@ public final <E> Observable<T> takeUntil(Observable<? extends E> other) {
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhile()</a>
      */
     public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate) {
-        return lift(new OperatorTakeWhile(predicate));
+        return lift(new OperatorTakeWhile<T>(predicate));
     }
 
     /**
@@ -6587,7 +6586,7 @@ public final Observable<T> takeWhile(final Func1<? super T, Boolean> predicate)
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Conditional-and-Boolean-Operators#wiki-takewhile-and-takewhilewithindex">RxJava Wiki: takeWhileWithIndex()</a>
      */
     public final Observable<T> takeWhileWithIndex(final Func2<? super T, ? super Integer, Boolean> predicate) {
-        return lift(new OperatorTakeWhile(predicate));
+        return lift(new OperatorTakeWhile<T>(predicate));
     }
 
     /**
@@ -6753,7 +6752,7 @@ public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Sche
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
      */
     public final Observable<TimeInterval<T>> timeInterval() {
-        return lift(new OperatorTimeInterval(Schedulers.immediate()));
+        return lift(new OperatorTimeInterval<T>(Schedulers.immediate()));
     }
 
     /**
@@ -6769,7 +6768,7 @@ public final Observable<TimeInterval<T>> timeInterval() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212107.aspx">MSDN: Observable.TimeInterval</a>
      */
     public final Observable<TimeInterval<T>> timeInterval(Scheduler scheduler) {
-        return lift(new OperatorTimeInterval(scheduler));
+        return lift(new OperatorTimeInterval<T>(scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 1d45006649..aadc3f290f 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/functions/Actions.java b/rxjava-core/src/main/java/rx/functions/Actions.java
index 0a9f79726e..ff2e07ebe4 100644
--- a/rxjava-core/src/main/java/rx/functions/Actions.java
+++ b/rxjava-core/src/main/java/rx/functions/Actions.java
@@ -30,6 +30,7 @@ public static final <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> EmptyAction<T0, T1,
         return (EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>) EMPTY_ACTION;
     }
 
+    @SuppressWarnings("rawtypes")
     private static final EmptyAction EMPTY_ACTION = new EmptyAction();
 
     private static final class EmptyAction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> implements
diff --git a/rxjava-core/src/main/java/rx/functions/Functions.java b/rxjava-core/src/main/java/rx/functions/Functions.java
index becfe31c43..3b19abeea5 100644
--- a/rxjava-core/src/main/java/rx/functions/Functions.java
+++ b/rxjava-core/src/main/java/rx/functions/Functions.java
@@ -364,6 +364,7 @@ public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> NullFunction<T0, T1, T
         return (NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R>) NULL_FUNCTION;
     }
 
+    @SuppressWarnings("rawtypes")
     private static final NullFunction NULL_FUNCTION = new NullFunction();
 
     private static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
diff --git a/rxjava-core/src/main/java/rx/observers/EmptyObserver.java b/rxjava-core/src/main/java/rx/observers/EmptyObserver.java
index 99ba2f5d04..7667fd769b 100644
--- a/rxjava-core/src/main/java/rx/observers/EmptyObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/EmptyObserver.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.observers;
 
 import rx.Observer;
diff --git a/rxjava-core/src/main/java/rx/observers/Observers.java b/rxjava-core/src/main/java/rx/observers/Observers.java
index 81c3c8330d..bd1f6294e1 100644
--- a/rxjava-core/src/main/java/rx/observers/Observers.java
+++ b/rxjava-core/src/main/java/rx/observers/Observers.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.observers;
 
 import rx.Observer;
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java b/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
index c9103ba954..0572fddb07 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedObserver.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedObserver.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.observers;
 
 import rx.Observer;
@@ -183,7 +198,9 @@ void drainQueue(FastList list) {
             } else if (v.getClass() == ErrorSentinel.class) {
                 actual.onError(((ErrorSentinel) v).e);
             } else {
-                actual.onNext((T) v);
+                @SuppressWarnings("unchecked")
+                T t = (T)v;
+                actual.onNext(t);
             }
         }
     }
diff --git a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
index b42fd04440..b9b2476052 100644
--- a/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SerializedSubscriber.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.observers;
 
 import rx.Observer;
diff --git a/rxjava-core/src/main/java/rx/observers/Subscribers.java b/rxjava-core/src/main/java/rx/observers/Subscribers.java
index 4fb8f9dd48..1f47f4cb6b 100644
--- a/rxjava-core/src/main/java/rx/observers/Subscribers.java
+++ b/rxjava-core/src/main/java/rx/observers/Subscribers.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.observers;
 
 import rx.Observer;
@@ -6,8 +21,10 @@
 import rx.functions.Action0;
 import rx.functions.Action1;
 
-public class Subscribers {
-    @SuppressWarnings("unchecked")
+public final class Subscribers {
+    private Subscribers() {
+        throw new IllegalStateException("No instances!");
+    }
     public static <T> Subscriber<T> empty() {
         return from(Observers.empty());
     }
diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index 1392bb6de6..dfade9ea49 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -110,7 +110,6 @@ public void onError(Throwable e) {
     }
 
     @Override
-    @SuppressWarnings({ "unchecked", "rawtypes" })
     public void onNext(T t) {
         state.observerRef.get().onNext(t);
     }
diff --git a/rxjava-core/src/main/java/rx/operators/NotificationLite.java b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
index f4779916fc..d94fcd40c8 100644
--- a/rxjava-core/src/main/java/rx/operators/NotificationLite.java
+++ b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
@@ -1,8 +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;
 
 import java.io.Serializable;
 
-import rx.Notification;
 import rx.Notification.Kind;
 import rx.Observer;
 
@@ -25,6 +39,7 @@ public final class NotificationLite<T> {
     private NotificationLite() {
     }
 
+    @SuppressWarnings("rawtypes")
     private static final NotificationLite INSTANCE = new NotificationLite();
 
     @SuppressWarnings("unchecked")
@@ -54,7 +69,7 @@ public OnErrorSentinel(Throwable e) {
      * be unwrapped and sent with the {@link #accept} method.
      * 
      * @param t
-     * @return
+     * @return the value or a null token
      */
     public Object next(T t) {
         if (t == null)
@@ -67,7 +82,7 @@ public Object next(T t) {
      * Creates a lite onComplete notification without doing any allocation. Can be unwrapped and
      * sent with the {@link #accept} method.
      * 
-     * @return
+     * @return the completion token
      */
     public Object completed() {
         return ON_COMPLETED_SENTINEL;
@@ -79,7 +94,7 @@ public Object completed() {
      * be small. Can be unwrapped and sent with the {@link #accept} method.
      * 
      * @param e
-     * @return
+     * @return an object encapsulating the exception
      */
     public Object error(Throwable e) {
         return new OnErrorSentinel(e);
@@ -96,7 +111,6 @@ public Object error(Throwable e) {
      * @throws NullPointerException
      *             if the {@link Observer} is null.
      */
-    @SuppressWarnings("unchecked")
     public void accept(Observer<? super T> o, Object n) {
         switch (kind(n)) {
         case OnNext:
@@ -121,10 +135,10 @@ public boolean isError(Object n) {
 
     /**
      * If there is custom logic that isn't as simple as call the right method on an {@link Observer}
-     * then this method can be used to get the {@link Notification.Kind}
+     * then this method can be used to get the {@link rx.Notification.Kind}
      * 
      * @param n
-     * @return
+     * @return the kind of the raw object
      */
     public Kind kind(Object n) {
         if (n == null)
@@ -144,7 +158,7 @@ else if (n instanceof OnErrorSentinel)
      * when it is appropriate.
      * 
      * @param n
-     * @return
+     * @return the unwrapped value, which can be null
      */
     @SuppressWarnings("unchecked")
     public T getValue(Object n) {
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSingleObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSingleObservable.java
index e6efffb383..be9e9f2f72 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSingleObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithSingleObservable.java
@@ -17,6 +17,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Observer;
@@ -81,7 +82,7 @@ public Subscriber<? super T> call(final Subscriber<? super List<T>> child) {
             child.onError(t);
             return Subscribers.empty();
         }
-        final BufferingSubscriber<T> bsub = new BufferingSubscriber<T>(new SerializedSubscriber<List<T>>(child));
+        final BufferingSubscriber bsub = new BufferingSubscriber(new SerializedSubscriber<List<T>>(child));
 
         Subscriber<TClosing> closingSubscriber = new Subscriber<TClosing>() {
 
@@ -109,7 +110,7 @@ public void onCompleted() {
         return bsub;
     }
     
-    final class BufferingSubscriber<T> extends Subscriber<T> {
+    final class BufferingSubscriber extends Subscriber<T> {
         final Subscriber<? super List<T>> child;
         /** Guarded by this. */
         List<T> chunk;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java
index 931238e580..22931fb38a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorBufferWithStartEndObservable.java
@@ -32,7 +32,7 @@
  * values from the specified {@link Observable} source and stores them in the currently active chunks.
  * Initially there are no chunks active.
  * <p>
- * Chunks can be created by pushing a {@link rx.util.TOpening} value to the "bufferOpenings"
+ * Chunks can be created by pushing a {@code TOpening} value to the "bufferOpenings"
  * {@link Observable}. This creates a new buffer which will then start recording values which are produced
  * by the "source" {@link Observable}. Additionally the "bufferClosingSelector" will be used to construct an
  * {@link Observable} which can produce values. When it does so it will close this (and only this) newly
@@ -52,7 +52,7 @@ public final class OperatorBufferWithStartEndObservable<T, TOpening, TClosing> i
 
     /**
      * @param bufferOpenings
-     *            an {@link Observable} which when it produces a {@link rx.util.TOpening} value will create a
+     *            an {@link Observable} which when it produces a {@code TOpening} value will create a
      *            new buffer which instantly starts recording the "source" {@link Observable}
      * @param bufferClosingSelector
      *            a {@link Func1} object which produces {@link Observable}s. These {@link Observable}s determine
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java b/rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java
index 5492a813a6..526ed3c4b1 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorCombineLatest.java
@@ -16,23 +16,14 @@
 package rx.operators;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.BitSet;
 import java.util.LinkedList;
 import java.util.List;
+
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 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.observers.SerializedSubscriber;
 
 /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
index 01d647316c..d51262538a 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
@@ -15,7 +15,6 @@
  */
 package rx.operators;
 
-import java.util.BitSet;
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaObservable.java b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaObservable.java
index 4ef61927a0..7be9fe1f82 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaObservable.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorOnErrorResumeNextViaObservable.java
@@ -18,7 +18,6 @@
 import rx.Observable;
 import rx.Observable.Operator;
 import rx.Subscriber;
-import rx.subscriptions.SerialSubscription;
 
 /**
  * Instruct an Observable to pass control to another Observable rather than invoking
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorReplay.java b/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
index f07eae0f0c..67dd9e5496 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
@@ -276,7 +276,7 @@ public interface VirtualList<T> {
         /**
          * Returns the current content as a list.
          * 
-         * @return
+         * @return the {@link java.util.List} representation of this virtual list
          */
         List<T> toList();
     }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSkip.java b/rxjava-core/src/main/java/rx/operators/OperatorSkip.java
index cc0ec068c2..29602d49f2 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSkip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSkip.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;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorSwitch.java b/rxjava-core/src/main/java/rx/operators/OperatorSwitch.java
index 00d206da35..d3719e2d08 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorSwitch.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorSwitch.java
@@ -42,7 +42,6 @@ public Subscriber<? super Observable<? extends T>> call(final Subscriber<? super
         
         return new Subscriber<Observable<? extends T>>(child) {
             final Object guard = new Object();
-            final Subscriber<?> self = this;
             final NotificationLite<?> nl = NotificationLite.instance();
             /** Guarded by guard. */
             int index;
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorZip.java b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
index eae0b5ac61..8a2b7d8e9e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorZip.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorZip.java
@@ -134,7 +134,7 @@ public void onNext(Observable[] observables) {
         };
     }
 
-    static final NotificationLite on = NotificationLite.instance();
+    static final NotificationLite<Object> on = NotificationLite.instance();
     private static class Zip<R> {
         @SuppressWarnings("rawtypes")
         final Observable[] os;
@@ -199,6 +199,8 @@ void tick() {
                             // independently subscribed
                             childSubscription.unsubscribe();
                             return;
+                        default:
+                            // shouldn't get here
                         }
                     }
                     if (allHaveValues) {
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java b/rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java
deleted file mode 100644
index af496c05d7..0000000000
--- a/rxjava-core/src/main/java/rx/operators/SafeObservableSubscription.java
+++ /dev/null
@@ -1,83 +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.Subscription;
-
-/**
- * Thread-safe wrapper around Observable Subscription that ensures unsubscribe can be called only once.
- * 
- * @deprecated since `Observer` now implements `Subscription` and `CompositeSubscription` etc handle these things
- */
-@Deprecated
-public final class SafeObservableSubscription implements Subscription {
-
-    private static final Subscription UNSUBSCRIBED = new Subscription()
-    {
-        @Override
-        public void unsubscribe()
-        {
-        }
-
-        @Override
-        public boolean isUnsubscribed() {
-            return true;
-        }
-    };
-    private final AtomicReference<Subscription> actualSubscription = new AtomicReference<Subscription>();
-
-    public SafeObservableSubscription() {
-    }
-
-    public SafeObservableSubscription(Subscription actualSubscription) {
-        this.actualSubscription.set(actualSubscription);
-    }
-
-    /**
-     * Wraps the actual subscription once it exists (if it wasn't available when constructed)
-     * 
-     * @param actualSubscription
-     *            the wrapped subscription
-     * @throws IllegalStateException
-     *             if trying to set more than once (or use this method after setting via constructor)
-     */
-    public SafeObservableSubscription wrap(Subscription actualSubscription) {
-        if (!this.actualSubscription.compareAndSet(null, actualSubscription)) {
-            if (this.actualSubscription.get() == UNSUBSCRIBED) {
-                actualSubscription.unsubscribe();
-                return this;
-            }
-            throw new IllegalStateException("Can not set subscription more than once.");
-        }
-        return this;
-    }
-
-    @Override
-    public void unsubscribe() {
-        // get the real thing and set to null in an atomic operation so we will only ever call unsubscribe once
-        Subscription actual = actualSubscription.getAndSet(UNSUBSCRIBED);
-        // if it's not null we will unsubscribe
-        if (actual != null) {
-            actual.unsubscribe();
-        }
-    }
-
-    public boolean isUnsubscribed() {
-        return actualSubscription.get() == UNSUBSCRIBED;
-    }
-}
diff --git a/rxjava-core/src/main/java/rx/operators/SafeObserver.java b/rxjava-core/src/main/java/rx/operators/SafeObserver.java
deleted file mode 100644
index 9a583ab87d..0000000000
--- a/rxjava-core/src/main/java/rx/operators/SafeObserver.java
+++ /dev/null
@@ -1,170 +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.Arrays;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-import rx.Observer;
-import rx.Subscriber;
-import rx.Subscription;
-import rx.exceptions.CompositeException;
-import rx.exceptions.OnErrorNotImplementedException;
-import rx.observers.SerializedObserver;
-import rx.plugins.RxJavaPlugins;
-import rx.subscriptions.Subscriptions;
-
-/**
- * Wrapper around Observer to ensure compliance with Rx contract.
- * <p>
- * The following is taken from <a href="http://go.microsoft.com/fwlink/?LinkID=205219">the Rx Design Guidelines
- * document</a>:
- * <pre>
- * Messages sent to instances of the IObserver interface follow the following grammar:
- * 
- * OnNext* (OnCompleted | OnError)?
- * 
- * This grammar allows observable sequences to send any amount (0 or more) of OnNext messages to the subscribed
- * observer instance, optionally followed by a single success (OnCompleted) or failure (OnError) message.
- * 
- * The single message indicating that an observable sequence has finished ensures that consumers of the
- * observable sequence can deterministically establish that it is safe to perform cleanup operations.
- * 
- * A single failure further ensures that abort semantics can be maintained for operators that work on
- * multiple observable sequences (see paragraph 6.6).
- * </pre>
- * 
- * <p>
- * This wrapper will do the following:
- * <ul>
- * <li>Allow only single execution of either onError or onCompleted.</li>
- * <li>Once an onComplete or onError are performed, no further calls can be executed</li>
- * <li>If unsubscribe is called, this means we call completed() and don't allow any further onNext calls.</li>
- * <li>When onError or onComplete occur it will unsubscribe from the Observable (if executing asynchronously).</li>
- * </ul>
- * <p>
- * It will not synchronize onNext execution. Use the {@link SerializedObserver} to do that.
- * 
- * @param <T>
- * @deprecated replaced by SafeSubscriber
- */
-@Deprecated
-public class SafeObserver<T> extends Subscriber<T> {
-
-    private final Observer<? super T> actual;
-    private final AtomicBoolean isFinished = new AtomicBoolean(false);
-    private final Subscription subscription;
-
-    public SafeObserver(Observer<? super T> actual) {
-        this.subscription = Subscriptions.empty();
-        this.actual = actual;
-    }
-
-    public SafeObserver(SafeObservableSubscription subscription, Observer<? super T> actual) {
-        this.subscription = subscription;
-        this.actual = actual;
-    }
-
-    @Override
-    public void onCompleted() {
-        if (isFinished.compareAndSet(false, true)) {
-            try {
-                actual.onCompleted();
-            } catch (Throwable e) {
-                // handle errors if the onCompleted implementation fails, not just if the Observable fails
-                _onError(e);
-            } finally {
-                // auto-unsubscribe
-                subscription.unsubscribe();
-            }
-        }
-    }
-
-    @Override
-    public void onError(Throwable e) {
-        if (isFinished.compareAndSet(false, true)) {
-            _onError(e);
-        }
-    }
-
-    @Override
-    public void onNext(T args) {
-        try {
-            if (!isFinished.get()) {
-                actual.onNext(args);
-            }
-        } catch (Throwable e) {
-            // handle errors if the onNext implementation fails, not just if the Observable fails
-            onError(e);
-        }
-    }
-
-    /*
-     * 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 {
-            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
-                 * 
-                 * 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."
-                 */
-                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 {
-                /*
-                 * throw since the Rx contract is broken if onError failed
-                 * 
-                 * https://github.com/Netflix/RxJava/issues/198
-                 */
-                RxJavaPlugins.getInstance().getErrorHandler().handleError(e2);
-                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)));
-            }
-        }
-        // 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/schedulers/EventLoopsScheduler.java b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
index ef41d86432..733c0b805e 100644
--- a/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.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.schedulers;
 
 import java.util.concurrent.ThreadFactory;
diff --git a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java b/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
index cbc3a57d4e..55997916d5 100644
--- a/rxjava-core/src/main/java/rx/schedulers/ImmediateScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/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/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index acbe6c81cc..2b7306abac 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/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/schedulers/Schedulers.java b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
index 089b428b0b..d7096b7751 100644
--- a/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
+++ b/rxjava-core/src/main/java/rx/schedulers/Schedulers.java
@@ -103,7 +103,7 @@ public static Scheduler computation() {
      * <p>
      * Do not perform computational work on this scheduler. Use {@link #computation()} instead.
      * 
-     * @return {@link ExecutorScheduler} for IO-bound work
+     * @return {@link Scheduler} for IO-bound work
      */
     public static Scheduler io() {
         return INSTANCE.ioScheduler;
diff --git a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
index 016df2d87e..bb13734475 100644
--- a/rxjava-core/src/main/java/rx/schedulers/SleepingAction.java
+++ b/rxjava-core/src/main/java/rx/schedulers/SleepingAction.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/schedulers/TrampolineScheduler.java b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
index ea7f101600..736dc3e14f 100644
--- a/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/TrampolineScheduler.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/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index bd5f16b571..3277219351 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -19,9 +19,7 @@
 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.functions.Action0;
 import rx.functions.Action1;
diff --git a/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java b/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
index ec3f3c824b..e489faf99d 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/Subscriptions.java
@@ -16,10 +16,11 @@
 package rx.subscriptions;
 
 import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Subscription;
 import rx.functions.Action0;
-import rx.operators.SafeObservableSubscription;
+import rx.functions.Actions;
 
 /**
  * Helper methods and utilities for creating and working with {@link Subscription} objects
@@ -42,22 +43,32 @@ public static Subscription empty() {
      * @return {@link Subscription}
      */
     public static Subscription create(final Action0 unsubscribe) {
-        return new SafeObservableSubscription(new Subscription() {
-
-            private volatile boolean unsubscribed = false;
-
-            @Override
-            public void unsubscribe() {
-                unsubscribed = true;
-                unsubscribe.call();
-            }
-
+        return new ActionSubscription(unsubscribe);
+    }
+    /**
+     * Subscription that delegates the unsubscription action to an Action0 instance
+     */
+    private static final class ActionSubscription implements Subscription {
+        private final AtomicReference<Action0> actual;
+        public ActionSubscription(Action0 action) {
+            this.actual = new AtomicReference<Action0>(action != null ? action : Actions.empty());
+        }
+        @Override
+        public boolean isUnsubscribed() {
+            return actual.get() == UNSUBSCRIBED_ACTION;
+        }
+        @Override
+        public void unsubscribe() {
+            Action0 a = actual.getAndSet(UNSUBSCRIBED_ACTION);
+            a.call();
+        }
+        /** The no-op unique action indicating an unsubscribed state. */
+        private static final Action0 UNSUBSCRIBED_ACTION = new Action0() {
             @Override
-            public boolean isUnsubscribed() {
-                return unsubscribed;
+            public void call() {
+                
             }
-
-        });
+        };
     }
 
     /**
diff --git a/rxjava-core/src/test/java/rx/ConcatTests.java b/rxjava-core/src/test/java/rx/ConcatTests.java
index cf5cc5bd33..0dae3e327a 100644
--- a/rxjava-core/src/test/java/rx/ConcatTests.java
+++ b/rxjava-core/src/test/java/rx/ConcatTests.java
@@ -26,8 +26,7 @@
 import rx.CovarianceTest.HorrorMovie;
 import rx.CovarianceTest.Media;
 import rx.CovarianceTest.Movie;
-import rx.Observable.OnSubscribeFunc;
-import rx.subscriptions.Subscriptions;
+import rx.Observable.OnSubscribe;
 
 public class ConcatTests {
 
@@ -85,6 +84,8 @@ public void testConcatCovariance() {
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
         List<Media> values = Observable.concat(os).toList().toBlockingObservable().single();
+        
+        assertEquals(4, values.size());
     }
 
     @Test
@@ -95,6 +96,8 @@ public void testConcatCovariance2() {
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
         List<Media> values = Observable.concat(os).toList().toBlockingObservable().single();
+
+        assertEquals(5, values.size());
     }
 
     @Test
@@ -113,15 +116,14 @@ public void testConcatCovariance3() {
     @Test
     public void testConcatCovariance4() {
 
-        Observable<Movie> o1 = Observable.create(new OnSubscribeFunc<Movie>() {
+        Observable<Movie> o1 = Observable.create(new OnSubscribe<Movie>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super Movie> o) {
+            public void call(Subscriber<? super Movie> o) {
                 o.onNext(new HorrorMovie());
                 o.onNext(new Movie());
                 //                o.onNext(new Media()); // correctly doesn't compile
                 o.onCompleted();
-                return Subscriptions.empty();
             }
         });
 
diff --git a/rxjava-core/src/test/java/rx/MergeTests.java b/rxjava-core/src/test/java/rx/MergeTests.java
index 9b1020a0ac..115c0b6a93 100644
--- a/rxjava-core/src/test/java/rx/MergeTests.java
+++ b/rxjava-core/src/test/java/rx/MergeTests.java
@@ -15,6 +15,7 @@
  */
 package rx;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 import java.util.List;
@@ -24,8 +25,7 @@
 import rx.CovarianceTest.HorrorMovie;
 import rx.CovarianceTest.Media;
 import rx.CovarianceTest.Movie;
-import rx.Observable.OnSubscribeFunc;
-import rx.subscriptions.Subscriptions;
+import rx.Observable.OnSubscribe;
 
 public class MergeTests {
 
@@ -47,6 +47,8 @@ public void testMergeCovariance() {
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
         List<Media> values = Observable.merge(os).toList().toBlockingObservable().single();
+        
+        assertEquals(4, values.size());
     }
 
     @Test
@@ -57,6 +59,8 @@ public void testMergeCovariance2() {
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
         List<Media> values = Observable.merge(os).toList().toBlockingObservable().single();
+
+        assertEquals(5, values.size());
     }
 
     @Test
@@ -75,15 +79,14 @@ public void testMergeCovariance3() {
     @Test
     public void testMergeCovariance4() {
 
-        Observable<Movie> o1 = Observable.create(new OnSubscribeFunc<Movie>() {
+        Observable<Movie> o1 = Observable.create(new OnSubscribe<Movie>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super Movie> o) {
+            public void call(Subscriber<? super Movie> o) {
                 o.onNext(new HorrorMovie());
                 o.onNext(new Movie());
                 //                o.onNext(new Media()); // correctly doesn't compile
                 o.onCompleted();
-                return Subscriptions.empty();
             }
         });
 
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index 8dbeb63832..e7da099eb6 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -44,8 +44,8 @@
 import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import rx.Observable.OnSubscribe;
 
-import rx.Observable.OnSubscribeFunc;
 import rx.functions.Action1;
 import rx.functions.Action2;
 import rx.functions.Func1;
@@ -53,7 +53,6 @@
 import rx.observables.ConnectableObservable;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.BooleanSubscription;
-import rx.subscriptions.Subscriptions;
 
 public class ObservableTests {
 
@@ -112,15 +111,14 @@ public void fromArityArgs1() {
     @Test
     public void testCreate() {
 
-        Observable<String> observable = Observable.create(new OnSubscribeFunc<String>() {
+        Observable<String> observable = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> Observer) {
+            public void call(Subscriber<? super String> Observer) {
                 Observer.onNext("one");
                 Observer.onNext("two");
                 Observer.onNext("three");
                 Observer.onCompleted();
-                return Subscriptions.empty();
             }
 
         });
@@ -159,11 +157,10 @@ public void testCountZeroItems() {
 
     @Test
     public void testCountError() {
-        Observable<String> o = Observable.create(new OnSubscribeFunc<String>() {
+        Observable<String> o = Observable.create(new OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> obsv) {
+            public void call(Subscriber<? super String> obsv) {
                 obsv.onError(new RuntimeException());
-                return Subscriptions.empty();
             }
         });
         o.count().subscribe(w);
@@ -308,10 +305,10 @@ public void testOnSubscribeFails() {
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
         final RuntimeException re = new RuntimeException("bad impl");
-        Observable<String> o = Observable.create(new OnSubscribeFunc<String>() {
+        Observable<String> o = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> t1) {
+            public void call(Subscriber<? super String> t1) {
                 throw re;
             }
 
@@ -348,10 +345,10 @@ public void testCustomObservableWithErrorInObserverAsynchronous() throws Interru
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribeFunc<String>() {
+        Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
+            public void call(final Subscriber<? super String> observer) {
                 final BooleanSubscription s = new BooleanSubscription();
                 new Thread(new Runnable() {
 
@@ -370,7 +367,6 @@ public void run() {
                         }
                     }
                 }).start();
-                return s;
             }
         }).subscribe(new Subscriber<String>() {
             @Override
@@ -414,16 +410,15 @@ public void onNext(String v) {
     public void testCustomObservableWithErrorInObserverSynchronous() {
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribeFunc<String>() {
+        Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("1");
                 observer.onNext("2");
                 observer.onNext("three");
                 observer.onNext("4");
                 observer.onCompleted();
-                return Subscriptions.empty();
             }
         }).subscribe(new Subscriber<String>() {
 
@@ -465,10 +460,10 @@ public void onNext(String v) {
     public void testCustomObservableWithErrorInObservableSynchronous() {
         final AtomicInteger count = new AtomicInteger();
         final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribeFunc<String>() {
+        Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("1");
                 observer.onNext("2");
                 throw new NumberFormatException();
@@ -504,11 +499,10 @@ public void onNext(String v) {
     @Test
     public void testPublish() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        ConnectableObservable<String> o = Observable.create(new OnSubscribeFunc<String>() {
+        ConnectableObservable<String> o = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
-                final BooleanSubscription subscription = new BooleanSubscription();
+            public void call(final Subscriber<? super String> observer) {
                 new Thread(new Runnable() {
 
                     @Override
@@ -518,7 +512,6 @@ public void run() {
                         observer.onCompleted();
                     }
                 }).start();
-                return subscription;
             }
         }).publish();
 
@@ -558,11 +551,10 @@ public void call(String v) {
     @Test
     public void testPublishLast() throws InterruptedException {
         final AtomicInteger count = new AtomicInteger();
-        ConnectableObservable<String> connectable = Observable.create(new OnSubscribeFunc<String>() {
+        ConnectableObservable<String> connectable = Observable.create(new OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
+            public void call(final Subscriber<? super String> observer) {
                 count.incrementAndGet();
-                final BooleanSubscription subscription = new BooleanSubscription();
                 new Thread(new Runnable() {
                     @Override
                     public void run() {
@@ -571,7 +563,6 @@ public void run() {
                         observer.onCompleted();
                     }
                 }).start();
-                return subscription;
             }
         }).publishLast();
 
@@ -588,7 +579,7 @@ public void call(String value) {
         // subscribe twice
         connectable.subscribe(new Action1<String>() {
             @Override
-            public void call(String _) {
+            public void call(String ignored) {
             }
         });
 
@@ -601,11 +592,10 @@ public void call(String _) {
     @Test
     public void testReplay() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        ConnectableObservable<String> o = Observable.create(new OnSubscribeFunc<String>() {
+        ConnectableObservable<String> o = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
-                final BooleanSubscription subscription = new BooleanSubscription();
+            public void call(final Subscriber<? super String> observer) {
                 new Thread(new Runnable() {
 
                     @Override
@@ -615,7 +605,6 @@ public void run() {
                         observer.onCompleted();
                     }
                 }).start();
-                return subscription;
             }
         }).replay();
 
@@ -658,11 +647,10 @@ public void call(String v) {
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new OnSubscribeFunc<String>() {
+        Observable<String> o = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
-                final BooleanSubscription subscription = new BooleanSubscription();
+            public void call(final Subscriber<? super String> observer) {
                 new Thread(new Runnable() {
 
                     @Override
@@ -672,7 +660,6 @@ public void run() {
                         observer.onCompleted();
                     }
                 }).start();
-                return subscription;
             }
         }).cache();
 
@@ -746,10 +733,10 @@ public void call(Object t1) {
     public void testErrorThrownWithoutErrorHandlerAsynchronous() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
-        Observable.create(new OnSubscribeFunc<String>() {
+        Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
+            public void call(final Subscriber<? super String> observer) {
                 new Thread(new Runnable() {
 
                     @Override
@@ -763,7 +750,6 @@ public void run() {
                         latch.countDown();
                     }
                 }).start();
-                return Subscriptions.empty();
             }
         }).subscribe(new Action1<String>() {
 
diff --git a/rxjava-core/src/test/java/rx/RefCountTests.java b/rxjava-core/src/test/java/rx/RefCountTests.java
index 43726456dd..6d2d5242d9 100644
--- a/rxjava-core/src/test/java/rx/RefCountTests.java
+++ b/rxjava-core/src/test/java/rx/RefCountTests.java
@@ -27,6 +27,7 @@
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.MockitoAnnotations;
+import rx.Observable.OnSubscribe;
 
 import rx.functions.Action0;
 import rx.functions.Action1;
@@ -46,16 +47,16 @@ public void setUp() {
     public void onlyFirstShouldSubscribeAndLastUnsubscribe() {
         final AtomicInteger subscriptionCount = new AtomicInteger();
         final AtomicInteger unsubscriptionCount = new AtomicInteger();
-        Observable<Integer> observable = Observable.create(new Observable.OnSubscribeFunc<Integer>() {
+        Observable<Integer> observable = Observable.create(new OnSubscribe<Integer>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Integer> observer) {
+            public void call(Subscriber<? super Integer> observer) {
                 subscriptionCount.incrementAndGet();
-                return Subscriptions.create(new Action0() {
+                observer.add(Subscriptions.create(new Action0() {
                     @Override
                     public void call() {
                         unsubscriptionCount.incrementAndGet();
                     }
-                });
+                }));
             }
         });
         Observable<Integer> refCounted = observable.publish().refCount();
@@ -140,7 +141,7 @@ public void call(Long t1) {
         // subscribing a new one should start over because the source should have been unsubscribed
         // subscribe list3
         final List<Long> list3 = new ArrayList<Long>();
-        Subscription s3 = interval.subscribe(new Action1<Long>() {
+        interval.subscribe(new Action1<Long>() {
 
             @Override
             public void call(Long t1) {
diff --git a/rxjava-core/src/test/java/rx/StartWithTests.java b/rxjava-core/src/test/java/rx/StartWithTests.java
index 33f7e15d92..b077046f89 100644
--- a/rxjava-core/src/test/java/rx/StartWithTests.java
+++ b/rxjava-core/src/test/java/rx/StartWithTests.java
@@ -45,7 +45,7 @@ public void startWithIterable() {
         assertEquals("two", values.get(3));
     }
 
-	@Test
+    @Test
     public void startWithObservable() {
         List<String> li = new ArrayList<String>();
         li.add("alpha");
diff --git a/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
index c0fa66b537..5cc1e661b8 100644
--- a/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.java
+++ b/rxjava-core/src/test/java/rx/exceptions/CompositeExceptionTest.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.
@@ -48,6 +48,9 @@ public void testMultipleWithSameCause() {
         Throwable e2 = new Throwable("2", rootCause);
         Throwable e3 = new Throwable("3", rootCause);
         CompositeException ce = new CompositeException("3 failures with same root cause", Arrays.asList(e1, e2, e3));
+        
+        assertEquals(3, ce.getExceptions().size());
+        
     }
 
     @Test(timeout = 1000)
diff --git a/rxjava-core/src/test/java/rx/exceptions/TestException.java b/rxjava-core/src/test/java/rx/exceptions/TestException.java
new file mode 100644
index 0000000000..8d44a6f3af
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/exceptions/TestException.java
@@ -0,0 +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.
+ */
+package rx.exceptions;
+
+/**
+ * Custom exception for operator testing; makes sure an unwanted exception is
+ * not mixed up with a wanted exception.
+ */
+public final class TestException extends RuntimeException {
+    /** */
+    private static final long serialVersionUID = -1138830497957801910L;
+    /** Create the test exception without any message. */
+    public TestException() {
+        super();
+    }
+    /**
+     * Create the test exception with the provided message.
+     * @param message the mesage to use
+     */
+    public TestException(String message) {
+        super(message);
+    }
+}
diff --git a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
index 1d32cf357e..d9312e651f 100644
--- a/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
+++ b/rxjava-core/src/test/java/rx/observables/BlockingObservableTest.java
@@ -28,13 +28,10 @@
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
-import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
+import rx.exceptions.TestException;
 import rx.functions.Action1;
 import rx.functions.Func1;
-import rx.subscriptions.BooleanSubscription;
-import rx.subscriptions.Subscriptions;
 
 public class BlockingObservableTest {
 
@@ -261,13 +258,12 @@ public void testToIterableManyTimes() {
 
     @Test(expected = TestException.class)
     public void testToIterableWithException() {
-        BlockingObservable<String> obs = BlockingObservable.from(Observable.create(new Observable.OnSubscribeFunc<String>() {
+        BlockingObservable<String> obs = BlockingObservable.from(Observable.create(new Observable.OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new TestException());
-                return Subscriptions.empty();
             }
         }));
 
@@ -284,11 +280,10 @@ public Subscription onSubscribe(Observer<? super String> observer) {
     @Test
     public void testForEachWithError() {
         try {
-            BlockingObservable.from(Observable.create(new Observable.OnSubscribeFunc<String>() {
+            BlockingObservable.from(Observable.create(new Observable.OnSubscribe<String>() {
 
                 @Override
-                public Subscription onSubscribe(final Observer<? super String> observer) {
-                    final BooleanSubscription subscription = new BooleanSubscription();
+                public void call(final Subscriber<? super String> observer) {
                     new Thread(new Runnable() {
 
                         @Override
@@ -299,7 +294,6 @@ public void run() {
                             observer.onCompleted();
                         }
                     }).start();
-                    return subscription;
                 }
             })).forEach(new Action1<String>() {
 
@@ -383,8 +377,4 @@ public Boolean call(String args) {
         });
         assertEquals("default", first);
     }
-
-    private static class TestException extends RuntimeException {
-        private static final long serialVersionUID = 1L;
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
index 27174fb599..925f413e08 100644
--- a/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
+++ b/rxjava-core/src/test/java/rx/observers/SerializedObserverTest.java
@@ -21,7 +21,6 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -63,7 +62,6 @@ private Observer<String> serializedObserver(Observer<String> o) {
 
     @Test
     public void testSingleThreadedBasic() {
-        Subscription s = mock(Subscription.class);
         TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable("one", "two", "three");
         Observable<String> w = Observable.create(onSubscribe);
 
@@ -251,7 +249,6 @@ public void runConcurrencyTest() {
             }
 
             waitOnThreads(f1, f2, f3, f4, f5, f6, f7, f8, f10);
-            @SuppressWarnings("unused")
             int numNextEvents = tw.assertEvents(null); // no check of type since we don't want to test barging results here, just interleaving behavior
             assertEquals(173500, numNextEvents);
             // System.out.println("Number of events executed: " + numNextEvents);
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
index b841fab2fa..c165c65411 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
@@ -27,6 +27,7 @@
 import org.junit.Test;
 
 import rx.Observable;
+import rx.exceptions.TestException;
 import rx.observables.BlockingObservable;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
@@ -75,10 +76,6 @@ public void testMostRecentWithException() {
         it.next();
     }
 
-    private static class TestException extends RuntimeException {
-        private static final long serialVersionUID = 1L;
-    }
-
     @Test(timeout = 1000)
     public void testSingleSourceManyIterators() {
         TestScheduler scheduler = new TestScheduler();
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
index 28cc6bbecb..2a260c541c 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
@@ -32,13 +32,12 @@
 import org.junit.Test;
 
 import rx.Observable;
-import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
+import rx.exceptions.TestException;
 import rx.observables.BlockingObservable;
 import rx.schedulers.Schedulers;
 import rx.subjects.PublishSubject;
 import rx.subjects.Subject;
-import rx.subscriptions.Subscriptions;
 
 public class BlockingOperatorNextTest {
 
@@ -222,11 +221,6 @@ public void testNextWithCallingHasNextMultipleTimes() {
         }
     }
 
-    @SuppressWarnings("serial")
-    private static class TestException extends RuntimeException {
-
-    }
-
     /**
      * Confirm that no buffering or blocking of the Observable onNext calls occurs and it just grabs the next emitted value.
      * <p/>
@@ -241,10 +235,10 @@ public void testNoBufferingOrBlockingOfSequence() throws Throwable {
         final CountDownLatch timeHasPassed = new CountDownLatch(COUNT);
         final AtomicBoolean running = new AtomicBoolean(true);
         final AtomicInteger count = new AtomicInteger(0);
-        final Observable<Integer> obs = Observable.create(new Observable.OnSubscribeFunc<Integer>() {
+        final Observable<Integer> obs = Observable.create(new Observable.OnSubscribe<Integer>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super Integer> o) {
+            public void call(final Subscriber<? super Integer> o) {
                 new Thread(new Runnable() {
 
                     @Override
@@ -262,7 +256,6 @@ public void run() {
                         }
                     }
                 }).start();
-                return Subscriptions.empty();
             }
 
         });
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorToFutureTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToFutureTest.java
index e0460cc84d..f32bfa56bb 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorToFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToFutureTest.java
@@ -29,11 +29,9 @@
 import org.junit.Test;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
+import rx.Observable.OnSubscribe;
 import rx.Subscriber;
-import rx.Subscription;
-import rx.subscriptions.Subscriptions;
+import rx.exceptions.TestException;
 
 public class BlockingOperatorToFutureTest {
 
@@ -63,13 +61,12 @@ public void testExceptionWithMoreThanOneElement() throws InterruptedException, E
 
     @Test
     public void testToFutureWithException() {
-        Observable<String> obs = Observable.create(new OnSubscribeFunc<String>() {
+        Observable<String> obs = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new TestException());
-                return Subscriptions.empty();
             }
         });
 
@@ -109,8 +106,4 @@ public void call(Subscriber<? super T> unused) {
             // do nothing
         }
     }
-
-    private static class TestException extends RuntimeException {
-        private static final long serialVersionUID = 1L;
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
index fce243f192..dd95b66d39 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorToIteratorTest.java
@@ -23,10 +23,9 @@
 import org.junit.Test;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
-import rx.Subscription;
-import rx.subscriptions.Subscriptions;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.exceptions.TestException;
 
 public class BlockingOperatorToIteratorTest {
 
@@ -51,13 +50,12 @@ public void testToIterator() {
 
     @Test(expected = TestException.class)
     public void testToIteratorWithException() {
-        Observable<String> obs = Observable.create(new OnSubscribeFunc<String>() {
+        Observable<String> obs = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new TestException());
-                return Subscriptions.empty();
             }
         });
 
@@ -69,9 +67,4 @@ public Subscription onSubscribe(Observer<? super String> observer) {
         assertEquals(true, it.hasNext());
         it.next();
     }
-
-    private static class TestException extends RuntimeException {
-        private static final long serialVersionUID = 1L;
-    }
-
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java
index c1773f1c4d..b42f78c658 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorAsObservableTest.java
@@ -17,11 +17,16 @@
 package rx.operators;
 
 import static org.junit.Assert.assertFalse;
-import org.junit.Test;
 import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Test;
+
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.subjects.PublishSubject;
 
 public class OperatorAsObservableTest {
@@ -33,6 +38,7 @@ public void testHiding() {
         
         assertFalse(dst instanceof PublishSubject);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         dst.subscribe(o);
@@ -52,14 +58,15 @@ public void testHidingError() {
         
         assertFalse(dst instanceof PublishSubject);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         dst.subscribe(o);
         
-        src.onError(new OperationReduceTest.CustomException());
+        src.onError(new TestException());
         
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java b/rxjava-core/src/test/java/rx/operators/OperatorBufferTest.java
similarity index 89%
rename from rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorBufferTest.java
index 39cb174b0a..ef21c947ed 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationBufferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorBufferTest.java
@@ -17,7 +17,11 @@
 
 import static org.junit.Assert.assertFalse;
 import static org.mockito.Matchers.any;
-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.util.ArrayList;
 import java.util.Arrays;
@@ -33,16 +37,17 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
+import rx.Subscriber;
 import rx.Subscription;
+import rx.exceptions.TestException;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
 
-public class OperationBufferTest {
+public class OperatorBufferTest {
 
     private Observer<List<String>> observer;
     private TestScheduler scheduler;
@@ -58,11 +63,10 @@ public void before() {
 
     @Test
     public void testComplete() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onCompleted();
-                return Subscriptions.empty();
             }
         });
 
@@ -76,15 +80,14 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testSkipAndCountOverlappingBuffers() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onNext("two");
                 observer.onNext("three");
                 observer.onNext("four");
                 observer.onNext("five");
-                return Subscriptions.empty();
             }
         });
 
@@ -102,16 +105,15 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testSkipAndCountGaplessBuffers() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onNext("two");
                 observer.onNext("three");
                 observer.onNext("four");
                 observer.onNext("five");
                 observer.onCompleted();
-                return Subscriptions.empty();
             }
         });
 
@@ -128,16 +130,15 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testSkipAndCountBuffersWithGaps() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onNext("two");
                 observer.onNext("three");
                 observer.onNext("four");
                 observer.onNext("five");
                 observer.onCompleted();
-                return Subscriptions.empty();
             }
         });
 
@@ -154,16 +155,15 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testTimedAndCount() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
                 push(observer, "two", 90);
                 push(observer, "three", 110);
                 push(observer, "four", 190);
                 push(observer, "five", 210);
                 complete(observer, 250);
-                return Subscriptions.empty();
             }
         });
 
@@ -186,9 +186,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testTimed() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 97);
                 push(observer, "two", 98);
                 /**
@@ -200,7 +200,6 @@ public Subscription onSubscribe(Observer<? super String> observer) {
                 push(observer, "four", 101);
                 push(observer, "five", 102);
                 complete(observer, 150);
-                return Subscriptions.empty();
             }
         });
 
@@ -220,38 +219,35 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testObservableBasedOpenerAndCloser() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
                 push(observer, "two", 60);
                 push(observer, "three", 110);
                 push(observer, "four", 160);
                 push(observer, "five", 210);
                 complete(observer, 500);
-                return Subscriptions.empty();
             }
         });
 
-        Observable<Object> openings = Observable.create(new Observable.OnSubscribeFunc<Object>() {
+        Observable<Object> openings = Observable.create(new Observable.OnSubscribe<Object>() {
             @Override
-            public Subscription onSubscribe(Observer<Object> observer) {
+            public void call(Subscriber<Object> observer) {
                 push(observer, new Object(), 50);
                 push(observer, new Object(), 200);
                 complete(observer, 250);
-                return Subscriptions.empty();
             }
         });
 
         Func1<Object, Observable<Object>> closer = new Func1<Object, Observable<Object>>() {
             @Override
             public Observable<Object> call(Object opening) {
-                return Observable.create(new Observable.OnSubscribeFunc<Object>() {
+                return Observable.create(new Observable.OnSubscribe<Object>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super Object> observer) {
+                    public void call(Subscriber<? super Object> observer) {
                         push(observer, new Object(), 100);
                         complete(observer, 101);
-                        return Subscriptions.empty();
                     }
                 });
             }
@@ -271,30 +267,28 @@ public Subscription onSubscribe(Observer<? super Object> observer) {
 
     @Test
     public void testObservableBasedCloser() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 push(observer, "one", 10);
                 push(observer, "two", 60);
                 push(observer, "three", 110);
                 push(observer, "four", 160);
                 push(observer, "five", 210);
                 complete(observer, 250);
-                return Subscriptions.empty();
             }
         });
 
         Func0<Observable<Object>> closer = new Func0<Observable<Object>>() {
             @Override
             public Observable<Object> call() {
-                return Observable.create(new Observable.OnSubscribeFunc<Object>() {
+                return Observable.create(new Observable.OnSubscribe<Object>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super Object> observer) {
+                    public void call(Subscriber<? super Object> observer) {
                         push(observer, new Object(), 100);
                         push(observer, new Object(), 200);
                         push(observer, new Object(), 300);
                         complete(observer, 301);
-                        return Subscriptions.empty();
                     }
                 });
             }
@@ -377,6 +371,7 @@ public void call() {
     public void testBufferStopsWhenUnsubscribed1() {
         Observable<Integer> source = Observable.never();
 
+        @SuppressWarnings("unchecked")
         Observer<List<Integer>> o = mock(Observer.class);
 
         Subscription s = source.buffer(100, 200, TimeUnit.MILLISECONDS, scheduler).subscribe(o);
@@ -501,9 +496,9 @@ public void bufferWithBOSourceThrows() {
 
         source.buffer(boundary).subscribe(o);
         source.onNext(1);
-        source.onError(new OperationReduceTest.CustomException());
+        source.onError(new TestException());
 
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
     }
@@ -519,9 +514,9 @@ public void bufferWithBOBoundaryThrows() {
         source.buffer(boundary).subscribe(o);
 
         source.onNext(1);
-        boundary.onError(new OperationReduceTest.CustomException());
+        boundary.onError(new TestException());
 
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
     }
@@ -531,6 +526,7 @@ public void bufferWithSizeTake1() {
         
         Observable<List<Integer>> result = source.buffer(2).take(1);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -546,6 +542,7 @@ public void bufferWithSizeSkipTake1() {
         
         Observable<List<Integer>> result = source.buffer(2, 3).take(1);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -560,6 +557,7 @@ public void bufferWithTimeTake1() {
         
         Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler).take(1);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -576,6 +574,7 @@ public void bufferWithTimeSkipTake2() {
         
         Observable<List<Long>> result = source.buffer(100, 60, TimeUnit.MILLISECONDS, scheduler).take(2);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
@@ -595,6 +594,7 @@ public void bufferWithBoundaryTake2() {
         
         Observable<List<Long>> result = source.buffer(boundary).take(2);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
@@ -623,6 +623,7 @@ public Observable<Long> call(Long t1) {
         
         Observable<List<Long>> result = source.buffer(start, end).take(2);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
@@ -641,6 +642,7 @@ public void bufferWithSizeThrows() {
         
         Observable<List<Integer>> result = source.buffer(2);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
@@ -649,10 +651,10 @@ public void bufferWithSizeThrows() {
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        source.onError(new OperationReduceTest.CustomException());
+        source.onError(new TestException());
         
         inOrder.verify(o).onNext(Arrays.asList(1, 2));
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(Arrays.asList(3));
         verify(o, never()).onCompleted();
@@ -665,6 +667,7 @@ public void bufferWithTimeThrows() {
         
         Observable<List<Integer>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
@@ -674,11 +677,11 @@ public void bufferWithTimeThrows() {
         source.onNext(2);
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         source.onNext(3);
-        source.onError(new OperationReduceTest.CustomException());
+        source.onError(new TestException());
         scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
         
         inOrder.verify(o).onNext(Arrays.asList(1, 2));
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(Arrays.asList(3));
         verify(o, never()).onCompleted();
@@ -690,6 +693,7 @@ public void bufferWithTimeAndSize() {
         
         Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, 2, scheduler).take(3);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
@@ -717,6 +721,7 @@ public Observable<Integer> call(Integer t1) {
 
         Observable<List<Integer>> result = source.buffer(start, end);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -724,11 +729,11 @@ public Observable<Integer> call(Integer t1) {
         start.onNext(1);
         source.onNext(1);
         source.onNext(2);
-        start.onError(new OperationReduceTest.CustomException());
+        start.onError(new TestException());
         
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
     @Test
     public void bufferWithStartEndEndFunctionThrows() {
@@ -737,7 +742,7 @@ public void bufferWithStartEndEndFunctionThrows() {
         Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
 
@@ -745,6 +750,7 @@ public Observable<Integer> call(Integer t1) {
 
         Observable<List<Integer>> result = source.buffer(start, end);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -755,7 +761,7 @@ public Observable<Integer> call(Integer t1) {
         
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
     @Test
     public void bufferWithStartEndEndThrows() {
@@ -764,7 +770,7 @@ public void bufferWithStartEndEndThrows() {
         Func1<Integer, Observable<Integer>> end = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
-                return Observable.error(new OperationReduceTest.CustomException());
+                return Observable.error(new TestException());
             }
         };
 
@@ -772,6 +778,7 @@ public Observable<Integer> call(Integer t1) {
 
         Observable<List<Integer>> result = source.buffer(start, end);
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -782,6 +789,6 @@ public Observable<Integer> call(Integer t1) {
         
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java b/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
index 43ae5fb2f9..9aa2895c5a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorCacheTest.java
@@ -28,7 +28,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -39,18 +39,16 @@
 import rx.subjects.PublishSubject;
 import rx.subjects.ReplaySubject;
 import rx.subjects.Subject;
-import rx.subscriptions.BooleanSubscription;
 
 public class OperatorCacheTest {
 
     @Test
     public void testCache() throws InterruptedException {
         final AtomicInteger counter = new AtomicInteger();
-        Observable<String> o = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> o = Observable.create(new Observable.OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
-                final BooleanSubscription subscription = new BooleanSubscription();
+            public void call(final Subscriber<? super String> observer) {
                 new Thread(new Runnable() {
 
                     @Override
@@ -61,7 +59,6 @@ public void run() {
                         observer.onCompleted();
                     }
                 }).start();
-                return subscription;
             }
         }).cache();
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorCombineLatestTest.java b/rxjava-core/src/test/java/rx/operators/OperatorCombineLatestTest.java
index 05995ca1c9..cabb967667 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorCombineLatestTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorCombineLatestTest.java
@@ -15,7 +15,6 @@
  */
 package rx.operators;
 
-import java.util.ArrayList;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.inOrder;
@@ -24,7 +23,9 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 
@@ -44,8 +45,8 @@
 import rx.functions.Func8;
 import rx.functions.Func9;
 import rx.functions.FuncN;
-import rx.subjects.PublishSubject;
 import rx.schedulers.Schedulers;
+import rx.subjects.PublishSubject;
 
 public class OperatorCombineLatestTest {
 
@@ -263,25 +264,6 @@ public String call(String a1, String a2, String a3) {
         return combineLatestFunction;
     }
 
-    private FuncN<String> getConcatCombineLatestFunction() {
-        FuncN<String> combineLatestFunction = new FuncN<String>() {
-
-            @Override
-            public String call(Object... args) {
-                String returnValue = "";
-                for (Object o : args) {
-                    if (o != null) {
-                        returnValue += getStringValue(o);
-                    }
-                }
-                System.out.println("returning: " + returnValue);
-                return returnValue;
-            }
-
-        };
-        return combineLatestFunction;
-    }
-
     private Func2<String, Integer, String> getConcatStringIntegerCombineLatestFunction() {
         Func2<String, Integer, String> combineLatestFunction = new Func2<String, Integer, String>() {
 
@@ -332,6 +314,7 @@ public void combineSimple() {
 
         Observable<Integer> source = Observable.combineLatest(a, b, or);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
         InOrder inOrder = inOrder(observer);
 
@@ -377,7 +360,9 @@ public void combineMultipleObservers() {
 
         Observable<Integer> source = Observable.combineLatest(a, b, or);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer1 = mock(Observer.class);
+        @SuppressWarnings("unchecked")
         Observer<Object> observer2 = mock(Observer.class);
 
         InOrder inOrder1 = inOrder(observer1);
@@ -434,6 +419,7 @@ public void testFirstNeverProduces() {
 
         Observable<Integer> source = Observable.combineLatest(a, b, or);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
         InOrder inOrder = inOrder(observer);
 
@@ -457,6 +443,7 @@ public void testSecondNeverProduces() {
 
         Observable<Integer> source = Observable.combineLatest(a, b, or);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> observer = mock(Observer.class);
         InOrder inOrder = inOrder(observer);
 
@@ -498,6 +485,7 @@ public List<Object> call(Object... args) {
             
             Observable<List<Object>> result = Observable.combineLatest(sources, func);
             
+            @SuppressWarnings("unchecked")
             Observer<List<Object>> o = mock(Observer.class);
             
             result.subscribe(o);
@@ -528,6 +516,7 @@ public List<Object> call(Object... args) {
             
             Observable<List<Object>> result = Observable.combineLatest(sources, func);
             
+            @SuppressWarnings("unchecked")
             final Observer<List<Object>> o = mock(Observer.class);
             
             final CountDownLatch cdl = new CountDownLatch(1);
@@ -573,6 +562,7 @@ public List<Integer> call(Integer t1, Integer t2) {
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -595,6 +585,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3) {
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -618,6 +609,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4) {
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -642,6 +634,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Intege
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -667,6 +660,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Intege
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -693,6 +687,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Intege
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -720,6 +715,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Intege
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -748,6 +744,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Intege
             }
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
@@ -758,7 +755,7 @@ public List<Integer> call(Integer t1, Integer t2, Integer t3, Integer t4, Intege
     }
     @Test
     public void testZeroSources() {
-        Observable<Object> result = Observable.combineLatest(Arrays.<Observable<Object>>asList(), new FuncN<Object>() {
+        Observable<Object> result = Observable.combineLatest(Collections.<Observable<Object>>emptyList(), new FuncN<Object>() {
 
             @Override
             public Object call(Object... args) {
@@ -767,6 +764,7 @@ public Object call(Object... args) {
             
         });
         
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
         
         result.subscribe(o);
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorConcatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorConcatTest.java
index 122610bbac..d9763720f7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorConcatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorConcatTest.java
@@ -41,7 +41,6 @@
 import rx.Subscription;
 import rx.schedulers.TestScheduler;
 import rx.subscriptions.BooleanSubscription;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorConcatTest {
 
@@ -56,7 +55,6 @@ public void testConcat() {
         final Observable<String> odds = Observable.from(o);
         final Observable<String> even = Observable.from(e);
 
-        @SuppressWarnings("unchecked")
         Observable<String> concat = Observable.concat(odds, even);
         concat.subscribe(observer);
 
@@ -93,16 +91,14 @@ public void testConcatObservableOfObservables() {
         final Observable<String> odds = Observable.from(o);
         final Observable<String> even = Observable.from(e);
 
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
+            public void call(Subscriber<? super Observable<String>> observer) {
                 // simulate what would happen in an observable
                 observer.onNext(odds);
                 observer.onNext(even);
                 observer.onCompleted();
-
-                return Subscriptions.empty();
             }
 
         });
@@ -158,11 +154,12 @@ public void testNestedAsyncConcat() throws Throwable {
 
         final AtomicReference<Thread> parent = new AtomicReference<Thread>();
         final CountDownLatch parentHasStarted = new CountDownLatch(1);
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super Observable<String>> observer) {
+            public void call(final Subscriber<? super Observable<String>> observer) {
                 final BooleanSubscription s = new BooleanSubscription();
+                observer.add(s);
                 parent.set(new Thread(new Runnable() {
 
                     @Override
@@ -200,7 +197,6 @@ public void run() {
                 }));
                 parent.get().start();
                 parentHasStarted.countDown();
-                return s;
             }
         });
 
@@ -336,16 +332,14 @@ public void testConcatNonBlockingObservables() {
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
+            public void call(Subscriber<? super Observable<String>> observer) {
                 // simulate what would happen in an observable
                 observer.onNext(Observable.create(w1));
                 observer.onNext(Observable.create(w2));
                 observer.onCompleted();
-
-                return Subscriptions.empty();
             }
 
         });
@@ -388,7 +382,7 @@ public void testConcatUnsubscribe() {
 
         @SuppressWarnings("unchecked")
         final Observer<String> observer = mock(Observer.class);
-        @SuppressWarnings("unchecked")
+
         final Observable<String> concat = Observable.concat(Observable.create(w1), Observable.create(w2));
 
         try {
@@ -462,7 +456,7 @@ public void testConcatUnsubscribeConcurrent() {
         verify(observer, never()).onError(any(Throwable.class));
     }
 
-    private static class TestObservable<T> implements Observable.OnSubscribeFunc<T> {
+    private static class TestObservable<T> implements Observable.OnSubscribe<T> {
 
         private final Subscription s = new Subscription() {
 
@@ -508,7 +502,8 @@ public TestObservable(T seed, int size) {
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super T> observer) {
+        public void call(final Subscriber<? super T> observer) {
+            observer.add(s);
             t = new Thread(new Runnable() {
 
                 @Override
@@ -538,7 +533,6 @@ public void run() {
             });
             t.start();
             threadHasStarted.countDown();
-            return s;
         }
 
         void waitForThreadDone() throws InterruptedException {
@@ -549,7 +543,9 @@ void waitForThreadDone() throws InterruptedException {
 
     @Test
     public void testMultipleObservers() {
+        @SuppressWarnings("unchecked")
         Observer<Object> o1 = mock(Observer.class);
+        @SuppressWarnings("unchecked")
         Observer<Object> o2 = mock(Observer.class);
 
         TestScheduler s = new TestScheduler();
@@ -608,6 +604,7 @@ public void call(Subscriber<? super Observable<Integer>> s) {
         
         Observable<List<Integer>> result = Observable.concat(source).toList();
         
+        @SuppressWarnings("unchecked")
         Observer<List<Integer>> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
@@ -639,6 +636,7 @@ public void call(Subscriber<? super Observable<Integer>> s) {
         
         Observable<List<Integer>> result = Observable.concat(source).take(n / 2).toList();
         
+        @SuppressWarnings("unchecked")
         Observer<List<Integer>> o = mock(Observer.class);
         InOrder inOrder = inOrder(o);
         
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDebounceTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDebounceTest.java
index 3f4785c779..2df439c8f1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorDebounceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDebounceTest.java
@@ -32,12 +32,12 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Scheduler;
-import rx.Subscription;
+import rx.Subscriber;
+import rx.exceptions.TestException;
 import rx.functions.Action0;
 import rx.functions.Func1;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorDebounceTest {
 
@@ -55,15 +55,13 @@ public void before() {
 
     @Test
     public void testDebounceWithCompleted() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 publishNext(observer, 100, "one");    // Should be skipped since "two" will arrive before the timeout expires.
                 publishNext(observer, 400, "two");    // Should be published since "three" will arrive after the timeout expires.
                 publishNext(observer, 900, "three");   // Should be skipped since onCompleted will arrive before the timeout expires.
                 publishCompleted(observer, 1000);     // Should be published as soon as the timeout expires.
-
-                return Subscriptions.empty();
             }
         });
 
@@ -82,9 +80,9 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testDebounceNeverEmits() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 // all should be skipped since they are happening faster than the 200ms timeout
                 publishNext(observer, 100, "a");    // Should be skipped
                 publishNext(observer, 200, "b");    // Should be skipped
@@ -95,8 +93,6 @@ public Subscription onSubscribe(Observer<? super String> observer) {
                 publishNext(observer, 700, "g");    // Should be skipped
                 publishNext(observer, 800, "h");    // Should be skipped
                 publishCompleted(observer, 900);     // Should be published as soon as the timeout expires.
-
-                return Subscriptions.empty();
             }
         });
 
@@ -113,15 +109,13 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testDebounceWithError() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 Exception error = new TestException();
                 publishNext(observer, 100, "one");    // Should be published since "two" will arrive after the timeout expires.
                 publishNext(observer, 600, "two");    // Should be skipped since onError will arrive before the timeout expires.
                 publishError(observer, 700, error);   // Should be published as soon as the timeout expires.
-
-                return Subscriptions.empty();
             }
         });
 
@@ -165,10 +159,6 @@ public void call() {
         }, delay, TimeUnit.MILLISECONDS);
     }
 
-    @SuppressWarnings("serial")
-    private class TestException extends Exception {
-    }
-
     @Test
     public void debounceSelectorNormal1() {
         PublishSubject<Integer> source = PublishSubject.create();
@@ -214,7 +204,7 @@ public void debounceSelectorFuncThrows() {
 
             @Override
             public Observable<Integer> call(Integer t1) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
 
@@ -227,7 +217,7 @@ public Observable<Integer> call(Integer t1) {
 
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 
     @Test
@@ -237,7 +227,7 @@ public void debounceSelectorObservableThrows() {
 
             @Override
             public Observable<Integer> call(Integer t1) {
-                return Observable.error(new OperationReduceTest.CustomException());
+                return Observable.error(new TestException());
             }
         };
 
@@ -250,7 +240,7 @@ public Observable<Integer> call(Integer t1) {
 
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
     @Test
     public void debounceTimedLastIsNotLost() {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java
index 321f6e1d28..8ef622d1a5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDefaultIfEmptyTest.java
@@ -15,13 +15,17 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.TestException;
 
 public class OperatorDefaultIfEmptyTest {
 
@@ -57,12 +61,13 @@ public void testDefaultIfEmptyWithEmpty() {
     
     @Test
     public void testEmptyButClientThrows() {
+        @SuppressWarnings("unchecked")
         final Observer<Integer> o = mock(Observer.class);
         
         Observable.<Integer>empty().defaultIfEmpty(1).subscribe(new Subscriber<Integer>() {
             @Override
             public void onNext(Integer t) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
 
             @Override
@@ -76,7 +81,7 @@ public void onCompleted() {
             }
         });
         
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any(Integer.class));
         verify(o, never()).onCompleted();
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDeferTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDeferTest.java
index 710b75f794..c7a4f4e1d1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorDeferTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDeferTest.java
@@ -15,12 +15,19 @@
  */
 package rx.operators;
 
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+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.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.Func0;
 
 @SuppressWarnings("unchecked")
@@ -65,7 +72,7 @@ public void testDefer() throws Throwable {
     public void testDeferFunctionThrows() {
         Func0<Observable<String>> factory = mock(Func0.class);
         
-        when(factory.call()).thenThrow(new OperationReduceTest.CustomException());
+        when(factory.call()).thenThrow(new TestException());
         
         Observable<String> result = Observable.defer(factory);
         
@@ -73,7 +80,7 @@ public void testDeferFunctionThrows() {
         
         result.subscribe(o);
         
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any(String.class));
         verify(o, never()).onCompleted();
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDelayTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDelayTest.java
index 67357b4fe1..ffbb370461 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorDelayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDelayTest.java
@@ -16,6 +16,7 @@
 package rx.operators;
 
 import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
 import static org.mockito.Matchers.anyLong;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -31,12 +32,12 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
-import static org.mockito.Matchers.anyInt;
 import org.mockito.Mock;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Subscription;
+import rx.exceptions.TestException;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.schedulers.TestScheduler;
@@ -318,10 +319,10 @@ public Observable<Integer> call(Integer t1) {
 
         source.delay(delayFunc).subscribe(o);
         source.onNext(1);
-        source.onError(new OperationReduceTest.CustomException());
+        source.onError(new TestException());
         delay.onNext(1);
 
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
@@ -335,7 +336,7 @@ public void testDelayWithObservableDelayFunctionThrows() {
 
             @Override
             public Observable<Integer> call(Integer t1) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
         @SuppressWarnings("unchecked")
@@ -345,7 +346,7 @@ public Observable<Integer> call(Integer t1) {
         source.delay(delayFunc).subscribe(o);
         source.onNext(1);
 
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
@@ -369,9 +370,9 @@ public Observable<Integer> call(Integer t1) {
 
         source.delay(delayFunc).subscribe(o);
         source.onNext(1);
-        delay.onError(new OperationReduceTest.CustomException());
+        delay.onError(new TestException());
 
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
@@ -420,7 +421,7 @@ public void testDelayWithObservableSubscriptionFunctionThrows() {
         Func0<Observable<Integer>> subFunc = new Func0<Observable<Integer>>() {
             @Override
             public Observable<Integer> call() {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
         Func1<Integer, Observable<Integer>> delayFunc = new Func1<Integer, Observable<Integer>>() {
@@ -442,7 +443,7 @@ public Observable<Integer> call(Integer t1) {
 
         source.onNext(2);
 
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
@@ -473,11 +474,11 @@ public Observable<Integer> call(Integer t1) {
         source.delay(subFunc, delayFunc).subscribe(o);
 
         source.onNext(1);
-        delay.onError(new OperationReduceTest.CustomException());
+        delay.onError(new TestException());
 
         source.onNext(2);
 
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorDematerializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorDematerializeTest.java
index 3280ed3fd0..99456e59cc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorDematerializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorDematerializeTest.java
@@ -26,6 +26,7 @@
 import rx.Notification;
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.observers.Subscribers;
 import rx.observers.TestSubscriber;
 
@@ -82,6 +83,7 @@ public void testErrorPassThru() {
         Observable<Integer> observable = Observable.error(exception);
         Observable<Integer> dematerialize = observable.dematerialize();
 
+        @SuppressWarnings("unchecked")
         Observer<Integer> observer = mock(Observer.class);
         dematerialize.subscribe(observer);
 
@@ -95,6 +97,7 @@ public void testCompletePassThru() {
         Observable<Integer> observable = Observable.empty();
         Observable<Integer> dematerialize = observable.dematerialize();
 
+        @SuppressWarnings("unchecked")
         Observer<Integer> observer = mock(Observer.class);
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>(observer);
         dematerialize.subscribe(ts);
@@ -112,6 +115,7 @@ public void testHonorsContractWhenCompleted() {
         
         Observable<Integer> result = source.materialize().dematerialize();
         
+        @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         
         result.unsafeSubscribe(Subscribers.from(o));
@@ -123,16 +127,17 @@ public void testHonorsContractWhenCompleted() {
     
     @Test
     public void testHonorsContractWhenThrows() {
-        Observable<Integer> source = Observable.error(new OperationReduceTest.CustomException());
+        Observable<Integer> source = Observable.error(new TestException());
         
         Observable<Integer> result = source.materialize().dematerialize();
         
+        @SuppressWarnings("unchecked")
         Observer<Integer> o = mock(Observer.class);
         
         result.unsafeSubscribe(Subscribers.from(o));
         
         verify(o, never()).onNext(any(Integer.class));
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index a18070add1..212cca5027 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -44,13 +44,11 @@
 import rx.Observable.OnSubscribe;
 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;
 
 public class OperatorGroupByTest {
 
@@ -173,10 +171,10 @@ public void testGroupedEventStream() throws Throwable {
         final int count = 100;
         final int groupCount = 2;
 
-        Observable<Event> es = Observable.create(new Observable.OnSubscribeFunc<Event>() {
+        Observable<Event> es = Observable.create(new Observable.OnSubscribe<Event>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super Event> observer) {
+            public void call(final Subscriber<? super Event> observer) {
                 System.out.println("*** Subscribing to EventStream ***");
                 subscribeCounter.incrementAndGet();
                 new Thread(new Runnable() {
@@ -193,7 +191,6 @@ public void run() {
                     }
 
                 }).start();
-                return Subscriptions.empty();
             }
 
         });
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
index 5be5dcbccc..6f3e05efee 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
@@ -27,10 +27,7 @@
 
 import rx.Notification;
 import rx.Observable;
-import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorMaterializeTest {
 
@@ -119,7 +116,7 @@ public void onNext(Notification<String> value) {
 
     }
 
-    private static class TestAsyncErrorObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestAsyncErrorObservable implements Observable.OnSubscribe<String> {
 
         String[] valuesToReturn;
 
@@ -130,7 +127,7 @@ private static class TestAsyncErrorObservable implements Observable.OnSubscribeF
         volatile Thread t;
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             t = new Thread(new Runnable() {
 
                 @Override
@@ -155,8 +152,6 @@ public void run() {
 
             });
             t.start();
-
-            return Subscriptions.empty();
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
index 87b6ba8144..70d47ecafb 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeDelayErrorTest.java
@@ -18,7 +18,13 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+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.ArrayList;
 import java.util.List;
@@ -33,9 +39,8 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.exceptions.CompositeException;
-import rx.subscriptions.Subscriptions;
+import rx.exceptions.TestException;
 
 public class OperatorMergeDelayErrorTest {
 
@@ -52,7 +57,6 @@ public void testErrorDelayed1() {
         final Observable<String> o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
         final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", "three"));
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
 
@@ -73,7 +77,6 @@ public void testErrorDelayed2() {
         final Observable<String> o3 = Observable.create(new TestErrorObservable("seven", "eight", null));
         final Observable<String> o4 = Observable.create(new TestErrorObservable("nine"));
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
 
@@ -97,7 +100,6 @@ public void testErrorDelayed3() {
         final Observable<String> o3 = Observable.create(new TestErrorObservable("seven", "eight", null));
         final Observable<String> o4 = Observable.create(new TestErrorObservable("nine"));
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
 
@@ -121,7 +123,6 @@ public void testErrorDelayed4() {
         final Observable<String> o3 = Observable.create(new TestErrorObservable("seven", "eight"));
         final Observable<String> o4 = Observable.create(new TestErrorObservable("nine", null));
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
         m.subscribe(stringObserver);
 
@@ -146,7 +147,6 @@ public void testErrorDelayed4WithThreading() {
         // throw the error at the very end so no onComplete will be called after it
         final TestAsyncErrorObservable o4 = new TestAsyncErrorObservable("nine", null);
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(Observable.create(o1), Observable.create(o2), Observable.create(o3), Observable.create(o4));
         m.subscribe(stringObserver);
 
@@ -177,7 +177,6 @@ public void testCompositeErrorDelayed1() {
         final Observable<String> o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
         final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", null));
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
 
@@ -196,7 +195,6 @@ public void testCompositeErrorDelayed2() {
         final Observable<String> o1 = Observable.create(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
         final Observable<String> o2 = Observable.create(new TestErrorObservable("one", "two", null));
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         CaptureObserver w = new CaptureObserver();
         m.subscribe(w);
@@ -220,16 +218,14 @@ public void testMergeObservableOfObservables() {
         final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
         final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
 
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
+            public void call(Subscriber<? super Observable<String>> observer) {
                 // simulate what would happen in an observable
                 observer.onNext(o1);
                 observer.onNext(o2);
                 observer.onCompleted();
-
-                return Subscriptions.empty();
             }
 
         });
@@ -246,7 +242,6 @@ public void testMergeArray() {
         final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
         final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(o1, o2);
         m.subscribe(stringObserver);
 
@@ -276,7 +271,6 @@ public void testMergeArrayWithThreading() {
         final TestASynchronousObservable o1 = new TestASynchronousObservable();
         final TestASynchronousObservable o2 = new TestASynchronousObservable();
 
-        @SuppressWarnings("unchecked")
         Observable<String> m = Observable.mergeDelayError(Observable.create(o1), Observable.create(o2));
         m.subscribe(stringObserver);
 
@@ -319,51 +313,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<String> {
-
-        Observer<? super String> 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<? super String> observer) {
-            this.observer = observer;
-            return s;
-        }
-    }
-
     private static class TestErrorObservable implements Observable.OnSubscribe<String> {
 
         String[] valuesToReturn;
@@ -476,7 +425,7 @@ public void call(Subscriber<? super Integer> t1) {
             @Override
             public void onNext(Integer t) {
                 if (calls++ == 0) {
-                    throw new OperationReduceTest.CustomException();
+                    throw new TestException();
                 }
                 o.onNext(t);
             }
@@ -497,7 +446,7 @@ public void onCompleted() {
         inOrder.verify(o, never()).onNext(0);
         inOrder.verify(o, never()).onNext(1);
         inOrder.verify(o, never()).onNext(anyInt());
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         verify(o, never()).onCompleted();
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeMapTest.java
index 604096b446..d99b6c29c6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeMapTest.java
@@ -28,6 +28,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -75,7 +76,7 @@ public void testCollectionFunctionThrows() {
         Func1<Integer, List<Integer>> func = new Func1<Integer, List<Integer>>() {
             @Override
             public List<Integer> call(Integer t1) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
         Func2<Integer, Integer, Integer> resFunc = new Func2<Integer, Integer, Integer>() {
@@ -92,7 +93,7 @@ public Integer call(Integer t1, Integer t2) {
 
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 
     @Test
@@ -112,7 +113,7 @@ public List<Integer> call(Integer t1) {
 
             @Override
             public Integer call(Integer t1, Integer t2) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
 
@@ -122,7 +123,7 @@ public Integer call(Integer t1, Integer t2) {
 
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 
     @Test
@@ -133,7 +134,7 @@ public void testMergeError() {
         Func1<Integer, Observable<Integer>> func = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
-                return Observable.error(new OperationReduceTest.CustomException());
+                return Observable.error(new TestException());
             }
         };
         Func2<Integer, Integer, Integer> resFunc = new Func2<Integer, Integer, Integer>() {
@@ -150,7 +151,7 @@ public Integer call(Integer t1, Integer t2) {
 
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 
     <T, R> Func1<T, R> just(final R value) {
@@ -226,7 +227,7 @@ <R> Func0<R> funcThrow0(R r) {
         return new Func0<R>() {
             @Override
             public R call() {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
     }
@@ -235,7 +236,7 @@ <T, R> Func1<T, R> funcThrow(T t, R r) {
         return new Func1<T, R>() {
             @Override
             public R call(T t) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
     }
@@ -252,7 +253,7 @@ public void testFlatMapTransformsOnNextFuncThrows() {
 
         source.mergeMap(funcThrow(1, onError), just(onError), just0(onCompleted)).subscribe(o);
 
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
@@ -263,14 +264,14 @@ public void testFlatMapTransformsOnErrorFuncThrows() {
         Observable<Integer> onCompleted = Observable.from(Arrays.asList(4));
         Observable<Integer> onError = Observable.from(Arrays.asList(5));
 
-        Observable<Integer> source = Observable.error(new OperationReduceTest.CustomException());
+        Observable<Integer> source = Observable.error(new TestException());
 
         @SuppressWarnings("unchecked")
         Observer<Object> 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).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
@@ -288,14 +289,14 @@ public void testFlatMapTransformsOnCompletedFuncThrows() {
 
         source.mergeMap(just(onNext), just(onError), funcThrow0(onCompleted)).subscribe(o);
 
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
 
     @Test
     public void testFlatMapTransformsMergeException() {
-        Observable<Integer> onNext = Observable.error(new OperationReduceTest.CustomException());
+        Observable<Integer> onNext = Observable.error(new TestException());
         Observable<Integer> onCompleted = Observable.from(Arrays.asList(4));
         Observable<Integer> onError = Observable.from(Arrays.asList(5));
 
@@ -306,7 +307,7 @@ public void testFlatMapTransformsMergeException() {
 
         source.mergeMap(just(onNext), just(onError), funcThrow0(onCompleted)).subscribe(o);
 
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
index 790eb96db2..e4a68e6c56 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
@@ -31,9 +31,8 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.schedulers.Schedulers;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorMergeMaxConcurrentTest {
 
@@ -92,7 +91,7 @@ public void testMaxConcurrent() {
         }
     }
 
-    private static class SubscriptionCheckObservable implements Observable.OnSubscribeFunc<String> {
+    private static class SubscriptionCheckObservable implements Observable.OnSubscribe<String> {
 
         private final AtomicInteger subscriptionCount;
         private final int maxConcurrent;
@@ -104,7 +103,7 @@ private static class SubscriptionCheckObservable implements Observable.OnSubscri
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> t1) {
+        public void call(final Subscriber<? super String> t1) {
             new Thread(new Runnable() {
 
                 @Override
@@ -124,8 +123,6 @@ public void run() {
                 }
 
             }).start();
-
-            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 61ad93e93b..7cec6e3e1f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -67,16 +67,14 @@ public void testMergeObservableOfObservables() {
         final Observable<String> o1 = Observable.create(new TestSynchronousObservable());
         final Observable<String> o2 = Observable.create(new TestSynchronousObservable());
 
-        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> observableOfObservables = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
+            public void call(Subscriber<? super Observable<String>> observer) {
                 // simulate what would happen in an observable
                 observer.onNext(o1);
                 observer.onNext(o2);
                 observer.onCompleted();
-
-                return Subscriptions.empty();
             }
 
         });
@@ -123,10 +121,10 @@ public void testUnSubscribeObservableOfObservables() throws InterruptedException
         final AtomicBoolean unsubscribed = new AtomicBoolean();
         final CountDownLatch latch = new CountDownLatch(1);
 
-        Observable<Observable<Long>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<Long>>() {
+        Observable<Observable<Long>> source = Observable.create(new Observable.OnSubscribe<Observable<Long>>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super Observable<Long>> observer) {
+            public void call(final Subscriber<? super Observable<Long>> observer) {
                 // verbose on purpose so I can track the inside of it
                 final Subscription s = Subscriptions.create(new Action0() {
 
@@ -137,6 +135,7 @@ public void call() {
                     }
 
                 });
+                observer.add(s);
 
                 new Thread(new Runnable() {
 
@@ -153,8 +152,6 @@ public void run() {
                         latch.countDown();
                     }
                 }).start();
-
-                return s;
             }
 
             ;
@@ -342,24 +339,22 @@ public void call(Subscriber<? super String> s) {
         System.out.println("Error: " + ts.getOnErrorEvents());
     }
 
-    private static class TestSynchronousObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestSynchronousObservable implements Observable.OnSubscribe<String> {
 
         @Override
-        public Subscription onSubscribe(Observer<? super String> observer) {
+        public void call(Subscriber<? super String> observer) {
 
             observer.onNext("hello");
             observer.onCompleted();
-
-            return Subscriptions.empty();
         }
     }
 
-    private static class TestASynchronousObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestASynchronousObservable implements Observable.OnSubscribe<String> {
         Thread t;
         final CountDownLatch onNextBeingSent = new CountDownLatch(1);
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             t = new Thread(new Runnable() {
 
                 @Override
@@ -373,12 +368,10 @@ public void run() {
 
             });
             t.start();
-
-            return Subscriptions.empty();
         }
     }
 
-    private static class TestErrorObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestErrorObservable implements Observable.OnSubscribe<String> {
 
         String[] valuesToReturn;
 
@@ -387,7 +380,7 @@ private static class TestErrorObservable implements Observable.OnSubscribeFunc<S
         }
 
         @Override
-        public Subscription onSubscribe(Observer<? super String> observer) {
+        public void call(Subscriber<? super String> observer) {
 
             for (String s : valuesToReturn) {
                 if (s == null) {
@@ -398,8 +391,6 @@ public Subscription onSubscribe(Observer<? super String> observer) {
                 }
             }
             observer.onCompleted();
-
-            return Subscriptions.empty();
         }
     }
 
@@ -526,8 +517,8 @@ public void call() {
 
             ts.awaitTerminalEvent();
             assertEquals(1, ts.getOnCompletedEvents().size());
-            assertEquals(30000, ts.getOnNextEvents().size());
             List<Integer> onNextEvents = ts.getOnNextEvents();
+            assertEquals(30000, onNextEvents.size());
             //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
         }
     }
@@ -567,8 +558,8 @@ public void call() {
 
             ts.awaitTerminalEvent();
             assertEquals(1, ts.getOnCompletedEvents().size());
-            assertEquals(300, ts.getOnNextEvents().size());
             List<Integer> onNextEvents = ts.getOnNextEvents();
+            assertEquals(300, onNextEvents.size());
             //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
         }
     }
@@ -605,8 +596,8 @@ public void call() {
 
             ts.awaitTerminalEvent();
             assertEquals(1, ts.getOnCompletedEvents().size());
-            assertEquals(30000, ts.getOnNextEvents().size());
             List<Integer> onNextEvents = ts.getOnNextEvents();
+            assertEquals(30000, onNextEvents.size());
             //            System.out.println("onNext: " + onNextEvents.size() + " onCompleted: " + ts.getOnCompletedEvents().size());
         }
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
index a7533d3d69..2e022107da 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaFunctionTest.java
@@ -35,20 +35,18 @@
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.observers.TestSubscriber;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorOnErrorResumeNextViaFunctionTest {
 
     @Test
     public void testResumeNextWithSynchronousExecution() {
         final AtomicReference<Throwable> receivedException = new AtomicReference<Throwable>();
-        Observable<String> w = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> w = Observable.create(new Observable.OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new Throwable("injected failure"));
-                return Subscriptions.empty();
             }
         });
 
@@ -229,7 +227,7 @@ public Observable<String> call(Throwable t1) {
         ts.assertReceivedOnNext(Arrays.asList("success"));
     }
 
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final Subscription s;
         final String[] values;
@@ -241,8 +239,9 @@ public TestObservable(Subscription s, String... values) {
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestObservable subscribed to ...");
+            observer.add(s);
             t = new Thread(new Runnable() {
 
                 @Override
@@ -263,7 +262,6 @@ public void run() {
             System.out.println("starting TestObservable thread");
             t.start();
             System.out.println("done starting TestObservable thread");
-            return s;
         }
 
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaObservableTest.java
index 600add9cee..9695895784 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorResumeNextViaObservableTest.java
@@ -26,6 +26,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Func1;
 
@@ -101,7 +102,7 @@ public String call(String s) {
         verify(observer, times(1)).onNext("threeResume");
     }
 
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final Subscription s;
         final String[] values;
@@ -113,8 +114,9 @@ public TestObservable(Subscription s, String... values) {
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestObservable subscribed to ...");
+            observer.add(s);
             t = new Thread(new Runnable() {
 
                 @Override
@@ -139,7 +141,6 @@ public void run() {
             System.out.println("starting TestObservable thread");
             t.start();
             System.out.println("done starting TestObservable thread");
-            return s;
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorReturnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorReturnTest.java
index a73d972025..4adf5e4b9f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnErrorReturnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnErrorReturnTest.java
@@ -30,15 +30,13 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Func1;
 
 public class OperatorOnErrorReturnTest {
 
     @Test
     public void testResumeNext() {
-        Subscription s = mock(Subscription.class);
-        TestObservable f = new TestObservable(s, "one");
+        TestObservable f = new TestObservable("one");
         Observable<String> w = Observable.create(f);
         final AtomicReference<Throwable> capturedException = new AtomicReference<Throwable>();
 
@@ -74,8 +72,7 @@ public String call(Throwable e) {
      */
     @Test
     public void testFunctionThrowsError() {
-        Subscription s = mock(Subscription.class);
-        TestObservable f = new TestObservable(s, "one");
+        TestObservable f = new TestObservable("one");
         Observable<String> w = Observable.create(f);
         final AtomicReference<Throwable> capturedException = new AtomicReference<Throwable>();
 
@@ -110,12 +107,10 @@ public String call(Throwable e) {
 
     private static class TestObservable implements Observable.OnSubscribe<String> {
 
-        final Subscription s;
         final String[] values;
         Thread t = null;
 
-        public TestObservable(Subscription s, String... values) {
-            this.s = s;
+        public TestObservable(String... values) {
             this.values = values;
         }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorOnExceptionResumeNextViaObservableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorOnExceptionResumeNextViaObservableTest.java
index a7d0a57a4f..bcbe2c62c9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorOnExceptionResumeNextViaObservableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorOnExceptionResumeNextViaObservableTest.java
@@ -28,16 +28,15 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.Subscription;
+import rx.Subscriber;
 import rx.functions.Func1;
 
 public class OperatorOnExceptionResumeNextViaObservableTest {
 
     @Test
     public void testResumeNextWithException() {
-        Subscription s = mock(Subscription.class);
         // Trigger failure on second element
-        TestObservable f = new TestObservable(s, "one", "EXCEPTION", "two", "three");
+        TestObservable f = new TestObservable("one", "EXCEPTION", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
@@ -64,9 +63,8 @@ public void testResumeNextWithException() {
 
     @Test
     public void testResumeNextWithRuntimeException() {
-        Subscription s = mock(Subscription.class);
         // Trigger failure on second element
-        TestObservable f = new TestObservable(s, "one", "RUNTIMEEXCEPTION", "two", "three");
+        TestObservable f = new TestObservable("one", "RUNTIMEEXCEPTION", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
@@ -93,9 +91,8 @@ public void testResumeNextWithRuntimeException() {
 
     @Test
     public void testThrowablePassesThru() {
-        Subscription s = mock(Subscription.class);
         // Trigger failure on second element
-        TestObservable f = new TestObservable(s, "one", "THROWABLE", "two", "three");
+        TestObservable f = new TestObservable("one", "THROWABLE", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
@@ -122,9 +119,8 @@ public void testThrowablePassesThru() {
 
     @Test
     public void testErrorPassesThru() {
-        Subscription s = mock(Subscription.class);
         // Trigger failure on second element
-        TestObservable f = new TestObservable(s, "one", "ERROR", "two", "three");
+        TestObservable f = new TestObservable("one", "ERROR", "two", "three");
         Observable<String> w = Observable.create(f);
         Observable<String> resume = Observable.from("twoResume", "threeResume");
         Observable<String> observable = w.onExceptionResumeNext(resume);
@@ -151,11 +147,10 @@ public void testErrorPassesThru() {
 
     @Test
     public void testMapResumeAsyncNext() {
-        Subscription sr = mock(Subscription.class);
         // Trigger multiple failures
         Observable<String> w = Observable.from("one", "fail", "two", "three", "fail");
         // Resume Observable is async
-        TestObservable f = new TestObservable(sr, "twoResume", "threeResume");
+        TestObservable f = new TestObservable("twoResume", "threeResume");
         Observable<String> resume = Observable.create(f);
 
         // Introduce map function that fails intermittently (Map does not prevent this when the observer is a
@@ -194,19 +189,17 @@ public String call(String s) {
         verify(observer, times(1)).onCompleted();
     }
 
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
-        final Subscription s;
         final String[] values;
         Thread t = null;
 
-        public TestObservable(Subscription s, String... values) {
-            this.s = s;
+        public TestObservable(String... values) {
             this.values = values;
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestObservable subscribed to ...");
             t = new Thread(new Runnable() {
 
@@ -238,7 +231,6 @@ else if ("THROWABLE".equals(s))
             System.out.println("starting TestObservable thread");
             t.start();
             System.out.println("done starting TestObservable thread");
-            return s;
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java b/rxjava-core/src/test/java/rx/operators/OperatorReduceTest.java
similarity index 86%
rename from rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorReduceTest.java
index 06e404f8cb..1a18e3c973 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationReduceTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorReduceTest.java
@@ -28,11 +28,12 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.Func1;
 import rx.functions.Func2;
 import rx.functions.Functions;
 
-public class OperationReduceTest {
+public class OperatorReduceTest {
     @Mock
     Observer<Object> observer;
 
@@ -60,20 +61,17 @@ public void testAggregateAsIntSum() {
         verify(observer, never()).onError(any(Throwable.class));
     }
 
-    static class CustomException extends RuntimeException {
-    }
-
     @Test
     public void testAggregateAsIntSumSourceThrows() {
         Observable<Integer> result = Observable.concat(Observable.from(1, 2, 3, 4, 5),
-                Observable.<Integer> error(new CustomException()))
+                Observable.<Integer> error(new TestException()))
                 .reduce(0, sum).map(Functions.<Integer> identity());
 
         result.subscribe(observer);
 
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        verify(observer, times(1)).onError(any(CustomException.class));
+        verify(observer, times(1)).onError(any(TestException.class));
     }
 
     @Test
@@ -81,7 +79,7 @@ public void testAggregateAsIntSumAccumulatorThrows() {
         Func2<Integer, Integer, Integer> sumErr = new Func2<Integer, Integer, Integer>() {
             @Override
             public Integer call(Integer t1, Integer t2) {
-                throw new CustomException();
+                throw new TestException();
             }
         };
 
@@ -92,7 +90,7 @@ public Integer call(Integer t1, Integer t2) {
 
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        verify(observer, times(1)).onError(any(CustomException.class));
+        verify(observer, times(1)).onError(any(TestException.class));
     }
 
     @Test
@@ -102,7 +100,7 @@ public void testAggregateAsIntSumResultSelectorThrows() {
 
             @Override
             public Integer call(Integer t1) {
-                throw new CustomException();
+                throw new TestException();
             }
         };
 
@@ -113,7 +111,7 @@ public Integer call(Integer t1) {
 
         verify(observer, never()).onNext(any());
         verify(observer, never()).onCompleted();
-        verify(observer, times(1)).onError(any(CustomException.class));
+        verify(observer, times(1)).onError(any(TestException.class));
     }
 
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
index 7c35bd27fe..8693017478 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
@@ -29,13 +29,11 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Observable.OnSubscribeFunc;
 import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
+import rx.exceptions.TestException;
 import rx.functions.Func1;
 import rx.schedulers.Schedulers;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorRepeatTest {
 
@@ -43,13 +41,12 @@ public class OperatorRepeatTest {
     public void testRepetition() {
         int NUM = 10;
         final AtomicInteger count = new AtomicInteger();
-        int value = Observable.create(new OnSubscribeFunc<Integer>() {
+        int value = Observable.create(new OnSubscribe<Integer>() {
 
             @Override
-            public Subscription onSubscribe(Observer<? super Integer> o) {
+            public void call(final Subscriber<? super Integer> o) {
                 o.onNext(count.incrementAndGet());
                 o.onCompleted();
-                return Subscriptions.empty();
             }
         }).repeat(Schedulers.computation()).take(NUM).toBlockingObservable().last();
 
@@ -128,9 +125,9 @@ public void testRepeatError() {
         @SuppressWarnings("unchecked")
                 Observer<Object> o = mock(Observer.class);
         
-        Observable.error(new CustomException()).repeat(10).subscribe(o);
+        Observable.error(new TestException()).repeat(10).subscribe(o);
         
-        verify(o).onError(any(CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
         
@@ -146,7 +143,4 @@ public void testRepeatZero() {
         verify(o, never()).onNext(any());
         verify(o, never()).onError(any(Throwable.class));
     }
-    
-    private static class CustomException extends RuntimeException {
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSequenceEqualTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSequenceEqualTest.java
index 1fe95d7f7d..731651c27f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSequenceEqualTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSequenceEqualTest.java
@@ -25,6 +25,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.Func2;
 
 public class OperatorSequenceEqualTest {
@@ -151,8 +152,4 @@ private void verifyError(Observable<Boolean> observable) {
         inOrder.verify(observer, times(1)).onError(isA(TestException.class));
         inOrder.verifyNoMoreInteractions();
     }
-
-    private class TestException extends RuntimeException {
-        private static final long serialVersionUID = 1L;
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
index 0f54774f9c..f42a56c6e7 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSerializeTest.java
@@ -19,16 +19,13 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
-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.Random;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -40,7 +37,6 @@
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
-import rx.Subscription;
 
 public class OperatorSerializeTest {
 
@@ -54,8 +50,7 @@ public void before() {
 
     @Test
     public void testSingleThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable(s, "one", "two", "three");
+        TestSingleThreadedObservable onSubscribe = new TestSingleThreadedObservable("one", "two", "three");
         Observable<String> w = Observable.create(onSubscribe);
 
         w.serialize().subscribe(observer);
@@ -73,8 +68,7 @@ public void testSingleThreadedBasic() {
 
     @Test
     public void testMultiThreadedBasic() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three");
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three");
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyobserver = new BusyObserver();
@@ -97,8 +91,7 @@ public void testMultiThreadedBasic() {
 
     @Test
     public void testMultiThreadedWithNPE() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null);
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null);
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyobserver = new BusyObserver();
@@ -127,8 +120,7 @@ public void testMultiThreadedWithNPE() {
 
     @Test
     public void testMultiThreadedWithNPEinMiddle() {
-        Subscription s = mock(Subscription.class);
-        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable(s, "one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
+        TestMultiThreadedObservable onSubscribe = new TestMultiThreadedObservable("one", "two", "three", null, "four", "five", "six", "seven", "eight", "nine");
         Observable<String> w = Observable.create(onSubscribe);
 
         BusyObserver busyobserver = new BusyObserver();
@@ -218,111 +210,20 @@ private static enum TestConcurrencyobserverEvent {
         onCompleted, onError, onNext
     }
 
-    private static class TestConcurrencyobserver extends Subscriber<String> {
-
-        /**
-         * used to store the order and number of events received
-         */
-        private final LinkedBlockingQueue<TestConcurrencyobserverEvent> events = new LinkedBlockingQueue<TestConcurrencyobserverEvent>();
-        private final int waitTime;
-
-        @SuppressWarnings("unused")
-        public TestConcurrencyobserver(int waitTimeInNext) {
-            this.waitTime = waitTimeInNext;
-        }
-
-        public TestConcurrencyobserver() {
-            this.waitTime = 0;
-        }
-
-        @Override
-        public void onCompleted() {
-            events.add(TestConcurrencyobserverEvent.onCompleted);
-        }
-
-        @Override
-        public void onError(Throwable e) {
-            events.add(TestConcurrencyobserverEvent.onError);
-        }
-
-        @Override
-        public void onNext(String args) {
-            events.add(TestConcurrencyobserverEvent.onNext);
-            // do some artificial work to make the thread scheduling/timing vary
-            int s = 0;
-            for (int i = 0; i < 20; i++) {
-                s += s * i;
-            }
-
-            if (waitTime > 0) {
-                try {
-                    Thread.sleep(waitTime);
-                } catch (InterruptedException e) {
-                    // ignore
-                }
-            }
-        }
-
-        /**
-         * Assert the order of events is correct and return the number of onNext executions.
-         * 
-         * @param expectedEndingEvent
-         * @return int count of onNext calls
-         * @throws IllegalStateException
-         *             If order of events was invalid.
-         */
-        public int assertEvents(TestConcurrencyobserverEvent expectedEndingEvent) throws IllegalStateException {
-            int nextCount = 0;
-            boolean finished = false;
-            for (TestConcurrencyobserverEvent e : events) {
-                if (e == TestConcurrencyobserverEvent.onNext) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onNext but we're already finished.");
-                    }
-                    nextCount++;
-                } else if (e == TestConcurrencyobserverEvent.onError) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onError but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onError != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onError ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                } else if (e == TestConcurrencyobserverEvent.onCompleted) {
-                    if (finished) {
-                        // already finished, we shouldn't get this again
-                        throw new IllegalStateException("Received onCompleted but we're already finished.");
-                    }
-                    if (expectedEndingEvent != null && TestConcurrencyobserverEvent.onCompleted != expectedEndingEvent) {
-                        throw new IllegalStateException("Received onCompleted ending event but expected " + expectedEndingEvent);
-                    }
-                    finished = true;
-                }
-            }
-
-            return nextCount;
-        }
-
-    }
-
     /**
      * This spawns a single thread for the subscribe execution
      */
-    private static class TestSingleThreadedObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestSingleThreadedObservable implements Observable.OnSubscribe<String> {
 
-        final Subscription s;
         final String[] values;
         private Thread t = null;
 
-        public TestSingleThreadedObservable(final Subscription s, final String... values) {
-            this.s = s;
+        public TestSingleThreadedObservable(final String... values) {
             this.values = values;
 
         }
 
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestSingleThreadedObservable subscribed to ...");
             t = new Thread(new Runnable() {
 
@@ -344,7 +245,6 @@ public void run() {
             System.out.println("starting TestSingleThreadedObservable thread");
             t.start();
             System.out.println("done starting TestSingleThreadedObservable thread");
-            return s;
         }
 
         public void waitToFinish() {
@@ -360,23 +260,20 @@ public void waitToFinish() {
     /**
      * This spawns a thread for the subscription, then a separate thread for each onNext call.
      */
-    private static class TestMultiThreadedObservable implements Observable.OnSubscribeFunc<String> {
-
-        final Subscription s;
+    private static class TestMultiThreadedObservable implements Observable.OnSubscribe<String> {
         final String[] values;
         Thread t = null;
         AtomicInteger threadsRunning = new AtomicInteger();
         AtomicInteger maxConcurrentThreads = new AtomicInteger();
         ExecutorService threadPool;
 
-        public TestMultiThreadedObservable(Subscription s, String... values) {
-            this.s = s;
+        public TestMultiThreadedObservable(String... values) {
             this.values = values;
             this.threadPool = Executors.newCachedThreadPool();
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestMultiThreadedObservable subscribed to ...");
             t = new Thread(new Runnable() {
 
@@ -431,7 +328,6 @@ public void run() {
             System.out.println("starting TestMultiThreadedObservable thread");
             t.start();
             System.out.println("done starting TestMultiThreadedObservable thread");
-            return s;
         }
 
         public void waitToFinish() {
@@ -504,68 +400,4 @@ public void onNext(String args) {
         }
 
     }
-
-    private static class ExternalBusyThread extends Thread {
-
-        private BusyObserver observer;
-        private Object lock;
-        private int lockTimes;
-        private int waitTime;
-        public volatile boolean fail;
-
-        public ExternalBusyThread(BusyObserver observer, Object lock, int lockTimes, int waitTime) {
-            this.observer = observer;
-            this.lock = lock;
-            this.lockTimes = lockTimes;
-            this.waitTime = waitTime;
-            this.fail = false;
-        }
-
-        @Override
-        public void run() {
-            Random r = new Random();
-            for (int i = 0; i < lockTimes; i++) {
-                synchronized (lock) {
-                    int oldOnNextCount = observer.onNextCount.get();
-                    boolean oldOnCompleted = observer.onCompleted;
-                    boolean oldOnError = observer.onError;
-                    try {
-                        Thread.sleep(r.nextInt(waitTime));
-                    } catch (InterruptedException e) {
-                        // ignore
-                    }
-                    // Since we own the lock, onNextCount, onCompleted and
-                    // onError must not be changed.
-                    int newOnNextCount = observer.onNextCount.get();
-                    boolean newOnCompleted = observer.onCompleted;
-                    boolean newOnError = observer.onError;
-                    if (oldOnNextCount != newOnNextCount) {
-                        System.out.println(">>> ExternalBusyThread received different onNextCount: "
-                                + oldOnNextCount
-                                + " -> "
-                                + newOnNextCount);
-                        fail = true;
-                        break;
-                    }
-                    if (oldOnCompleted != newOnCompleted) {
-                        System.out.println(">>> ExternalBusyThread received different onCompleted: "
-                                + oldOnCompleted
-                                + " -> "
-                                + newOnCompleted);
-                        fail = true;
-                        break;
-                    }
-                    if (oldOnError != newOnError) {
-                        System.out.println(">>> ExternalBusyThread received different onError: "
-                                + oldOnError
-                                + " -> "
-                                + newOnError);
-                        fail = true;
-                        break;
-                    }
-                }
-            }
-        }
-
-    }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
index 087462122e..9eaa8a98a2 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipLastTimedTest.java
@@ -28,7 +28,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.operators.OperatorSkipTimedTest.CustomException;
+import rx.exceptions.TestException;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -42,6 +42,7 @@ public void testSkipLastTimed() {
 
         Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);
@@ -80,6 +81,7 @@ public void testSkipLastTimedErrorBeforeTime() {
 
         Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);
@@ -87,11 +89,11 @@ public void testSkipLastTimedErrorBeforeTime() {
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        source.onError(new CustomException());
+        source.onError(new TestException());
 
         scheduler.advanceTimeBy(1050, TimeUnit.MILLISECONDS);
 
-        verify(o).onError(any(CustomException.class));
+        verify(o).onError(any(TestException.class));
 
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any());
@@ -105,6 +107,7 @@ public void testSkipLastTimedCompleteBeforeTime() {
 
         Observable<Integer> result = source.skipLast(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);
@@ -133,6 +136,7 @@ public void testSkipLastTimedWhenAllElementsAreValid() {
 
         Observable<Integer> result = source.skipLast(1, TimeUnit.MILLISECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         result.subscribe(o);
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
index d2889c5d39..6ec02256d8 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipTest.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 static org.mockito.Matchers.any;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSkipTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipTimedTest.java
index 1313b6d001..d248110f8b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSkipTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipTimedTest.java
@@ -28,6 +28,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -99,9 +100,6 @@ public void testSkipTimedFinishBeforeTime() {
         verify(o, never()).onError(any(Throwable.class));
     }
 
-    static class CustomException extends RuntimeException {
-    }
-
     @Test
     public void testSkipTimedErrorBeforeTime() {
         TestScheduler scheduler = new TestScheduler();
@@ -118,13 +116,13 @@ public void testSkipTimedErrorBeforeTime() {
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        source.onError(new CustomException());
+        source.onError(new TestException());
 
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
         InOrder inOrder = inOrder(o);
 
-        inOrder.verify(o).onError(any(CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
@@ -153,7 +151,7 @@ public void testSkipTimedErrorAfterTime() {
         source.onNext(5);
         source.onNext(6);
 
-        source.onError(new CustomException());
+        source.onError(new TestException());
 
         InOrder inOrder = inOrder(o);
 
@@ -163,7 +161,7 @@ public void testSkipTimedErrorAfterTime() {
         inOrder.verify(o).onNext(4);
         inOrder.verify(o).onNext(5);
         inOrder.verify(o).onNext(6);
-        inOrder.verify(o).onError(any(CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(o, never()).onCompleted();
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSkipWhileTest.java
similarity index 99%
rename from rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
rename to rxjava-core/src/test/java/rx/operators/OperatorSkipWhileTest.java
index e26d3b5ee2..a3ea8094d1 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationSkipWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSkipWhileTest.java
@@ -31,7 +31,7 @@
 import rx.functions.Func1;
 import rx.functions.Func2;
 
-public class OperationSkipWhileTest {
+public class OperatorSkipWhileTest {
 
     @SuppressWarnings("unchecked")
     Observer<Integer> w = mock(Observer.class);
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorSwitchTest.java b/rxjava-core/src/test/java/rx/operators/OperatorSwitchTest.java
index b90086e821..cb0283e61e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorSwitchTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorSwitchTest.java
@@ -28,15 +28,14 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
+
 import rx.Observable;
 import rx.Observer;
-
 import rx.Scheduler;
 import rx.Subscriber;
-import rx.Subscription;
+import rx.exceptions.TestException;
 import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorSwitchTest {
 
@@ -81,31 +80,27 @@ public void call(Subscriber<? super String> observer) {
 
     @Test
     public void testSwitchWhenInnerCompleteBeforeOuter() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
-                publishNext(observer, 10, Observable.create(new Observable.OnSubscribeFunc<String>() {
+            public void call(Subscriber<? super Observable<String>> observer) {
+                publishNext(observer, 10, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 0, "one");
                         publishNext(observer, 10, "two");
                         publishCompleted(observer, 20);
-                        return Subscriptions.empty();
                     }
                 }));
 
-                publishNext(observer, 100, Observable.create(new Observable.OnSubscribeFunc<String>() {
+                publishNext(observer, 100, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 0, "three");
                         publishNext(observer, 10, "four");
                         publishCompleted(observer, 20);
-                        return Subscriptions.empty();
                     }
                 }));
                 publishCompleted(observer, 200);
-
-                return Subscriptions.empty();
             }
         });
 
@@ -128,30 +123,26 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testSwitchWithComplete() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribeFunc<String>() {
+            public void call(Subscriber<? super Observable<String>> observer) {
+                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(final Subscriber<? super String> observer) {
                         publishNext(observer, 60, "one");
                         publishNext(observer, 100, "two");
-                        return Subscriptions.empty();
                     }
                 }));
 
-                publishNext(observer, 200, Observable.create(new Observable.OnSubscribeFunc<String>() {
+                publishNext(observer, 200, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(final Subscriber<? super String> observer) {
                         publishNext(observer, 0, "three");
                         publishNext(observer, 100, "four");
-                        return Subscriptions.empty();
                     }
                 }));
 
                 publishCompleted(observer, 250);
-
-                return Subscriptions.empty();
             }
         });
 
@@ -188,30 +179,26 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testSwitchWithError() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribeFunc<String>() {
+            public void call(Subscriber<? super Observable<String>> observer) {
+                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(final Subscriber<? super String> observer) {
                         publishNext(observer, 50, "one");
                         publishNext(observer, 100, "two");
-                        return Subscriptions.empty();
                     }
                 }));
 
-                publishNext(observer, 200, Observable.create(new Observable.OnSubscribeFunc<String>() {
+                publishNext(observer, 200, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 0, "three");
                         publishNext(observer, 100, "four");
-                        return Subscriptions.empty();
                     }
                 }));
 
                 publishError(observer, 250, new TestException());
-
-                return Subscriptions.empty();
             }
         });
 
@@ -248,35 +235,30 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testSwitchWithSubsequenceComplete() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribeFunc<String>() {
+            public void call(Subscriber<? super Observable<String>> observer) {
+                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "one");
                         publishNext(observer, 100, "two");
-                        return Subscriptions.empty();
                     }
                 }));
 
-                publishNext(observer, 130, Observable.create(new Observable.OnSubscribeFunc<String>() {
+                publishNext(observer, 130, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishCompleted(observer, 0);
-                        return Subscriptions.empty();
                     }
                 }));
 
-                publishNext(observer, 150, Observable.create(new Observable.OnSubscribeFunc<String>() {
+                publishNext(observer, 150, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "three");
-                        return Subscriptions.empty();
                     }
                 }));
-
-                return Subscriptions.empty();
             }
         });
 
@@ -303,35 +285,31 @@ public Subscription onSubscribe(Observer<? super String> observer) {
 
     @Test
     public void testSwitchWithSubsequenceError() {
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
-                publishNext(observer, 50, Observable.create(new Observable.OnSubscribeFunc<String>() {
+            public void call(Subscriber<? super Observable<String>> observer) {
+                publishNext(observer, 50, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "one");
                         publishNext(observer, 100, "two");
-                        return Subscriptions.empty();
                     }
                 }));
 
-                publishNext(observer, 130, Observable.create(new Observable.OnSubscribeFunc<String>() {
+                publishNext(observer, 130, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishError(observer, 0, new TestException());
-                        return Subscriptions.empty();
                     }
                 }));
 
-                publishNext(observer, 150, Observable.create(new Observable.OnSubscribeFunc<String>() {
+                publishNext(observer, 150, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> observer) {
                         publishNext(observer, 50, "three");
-                        return Subscriptions.empty();
                     }
                 }));
 
-                return Subscriptions.empty();
             }
         });
 
@@ -383,39 +361,32 @@ public void call() {
         }, delay, TimeUnit.MILLISECONDS);
     }
 
-    @SuppressWarnings("serial")
-    private class TestException extends Throwable {
-    }
-
     @Test
     public void testSwitchIssue737() {
         // https://github.com/Netflix/RxJava/issues/737
-        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribeFunc<Observable<String>>() {
+        Observable<Observable<String>> source = Observable.create(new Observable.OnSubscribe<Observable<String>>() {
             @Override
-            public Subscription onSubscribe(Observer<? super Observable<String>> observer) {
-                publishNext(observer, 0, Observable.create(new Observable.OnSubscribeFunc<String>() {
+            public void call(Subscriber<? super Observable<String>> observer) {
+                publishNext(observer, 0, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> 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<String>() {
+                publishNext(observer, 25, Observable.create(new Observable.OnSubscribe<String>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super String> observer) {
+                    public void call(Subscriber<? super String> 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();
             }
         });
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTimedTest.java
index b670c7e697..f188bbd8ce 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeLastTimedTest.java
@@ -15,18 +15,24 @@
  */
 package rx.operators;
 
+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 java.util.concurrent.TimeUnit;
+
 import org.junit.Test;
 import org.mockito.InOrder;
+
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
-import java.util.concurrent.TimeUnit;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.*;
-
 public class OperatorTakeLastTimedTest {
 
     @Test(expected = IndexOutOfBoundsException.class)
@@ -42,6 +48,7 @@ public void takeLastTimed() {
 
         Observable<Object> result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         InOrder inOrder = inOrder(o);
@@ -77,6 +84,7 @@ public void takeLastTimedDelayCompletion() {
 
         Observable<Object> result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         InOrder inOrder = inOrder(o);
@@ -109,6 +117,7 @@ public void takeLastTimedWithCapacity() {
 
         Observable<Object> result = source.takeLast(2, 1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         InOrder inOrder = inOrder(o);
@@ -134,10 +143,6 @@ public void takeLastTimedWithCapacity() {
         verify(o, never()).onError(any(Throwable.class));
     }
 
-    static final class CustomException extends RuntimeException {
-
-    }
-
     @Test
     public void takeLastTimedThrowingSource() {
         TestScheduler scheduler = new TestScheduler();
@@ -146,6 +151,7 @@ public void takeLastTimedThrowingSource() {
 
         Observable<Object> result = source.takeLast(1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         InOrder inOrder = inOrder(o);
@@ -162,9 +168,9 @@ public void takeLastTimedThrowingSource() {
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
         source.onNext(5); // T: 1000ms
         scheduler.advanceTimeBy(250, TimeUnit.MILLISECONDS);
-        source.onError(new CustomException()); // T: 1250ms
+        source.onError(new TestException()); // T: 1250ms
 
-        inOrder.verify(o, times(1)).onError(any(CustomException.class));
+        inOrder.verify(o, times(1)).onError(any(TestException.class));
 
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
@@ -178,6 +184,7 @@ public void takeLastTimedWithZeroCapacity() {
 
         Observable<Object> result = source.takeLast(0, 1, TimeUnit.SECONDS, scheduler);
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         InOrder inOrder = inOrder(o);
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
index 7a77dded65..ad2db450f4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
@@ -42,8 +42,8 @@
 import rx.Subscription;
 import rx.functions.Action1;
 import rx.functions.Func1;
+import rx.observers.Subscribers;
 import rx.schedulers.Schedulers;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorTakeTest {
 
@@ -120,12 +120,11 @@ public Integer call(Integer t1) {
 
     @Test
     public void testTakeDoesntLeakErrors() {
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 observer.onNext("one");
                 observer.onError(new Throwable("test failed"));
-                return Subscriptions.empty();
             }
         });
 
@@ -145,12 +144,11 @@ public Subscription onSubscribe(Observer<? super String> observer) {
     public void testTakeZeroDoesntLeakError() {
         final AtomicBoolean subscribed = new AtomicBoolean(false);
         final AtomicBoolean unSubscribed = new AtomicBoolean(false);
-        Observable<String> source = Observable.create(new Observable.OnSubscribeFunc<String>() {
+        Observable<String> source = Observable.create(new Observable.OnSubscribe<String>() {
             @Override
-            public Subscription onSubscribe(Observer<? super String> observer) {
+            public void call(Subscriber<? super String> observer) {
                 subscribed.set(true);
-                observer.onError(new Throwable("test failed"));
-                return new Subscription() {
+                observer.add(new Subscription() {
                     @Override
                     public void unsubscribe() {
                         unSubscribed.set(true);
@@ -160,7 +158,8 @@ public void unsubscribe() {
                     public boolean isUnsubscribed() {
                         return unSubscribed.get();
                     }
-                };
+                });
+                observer.onError(new Throwable("test failed"));
             }
         });
 
@@ -181,13 +180,17 @@ public boolean isUnsubscribed() {
     @Test
     public void testUnsubscribeAfterTake() {
         final Subscription s = mock(Subscription.class);
-        TestObservableFunc f = new TestObservableFunc(s, "one", "two", "three");
+        TestObservableFunc f = new TestObservableFunc("one", "two", "three");
         Observable<String> w = Observable.create(f);
 
         @SuppressWarnings("unchecked")
         Observer<String> observer = mock(Observer.class);
+        
+        Subscriber<String> subscriber = Subscribers.from(observer);
+        subscriber.add(s);
+        
         Observable<String> take = w.lift(new OperatorTake<String>(1));
-        take.subscribe(observer);
+        take.subscribe(subscriber);
 
         // wait for the Observable to complete
         try {
@@ -247,19 +250,17 @@ public void call(Integer t1) {
         assertEquals(1, count.get());
     }
 
-    private static class TestObservableFunc implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservableFunc implements Observable.OnSubscribe<String> {
 
-        final Subscription s;
         final String[] values;
         Thread t = null;
 
-        public TestObservableFunc(Subscription s, String... values) {
-            this.s = s;
+        public TestObservableFunc(String... values) {
             this.values = values;
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestObservable subscribed to ...");
             t = new Thread(new Runnable() {
 
@@ -281,7 +282,6 @@ public void run() {
             System.out.println("starting TestObservable thread");
             t.start();
             System.out.println("done starting TestObservable thread");
-            return s;
         }
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTimedTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTimedTest.java
index 5255636f93..d604ea6d0a 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTimedTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTimedTest.java
@@ -28,7 +28,7 @@
 
 import rx.Observable;
 import rx.Observer;
-import rx.operators.OperatorSkipTimedTest.CustomException;
+import rx.exceptions.TestException;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
@@ -82,7 +82,7 @@ public void testTakeTimedErrorBeforeTime() {
         source.onNext(1);
         source.onNext(2);
         source.onNext(3);
-        source.onError(new CustomException());
+        source.onError(new TestException());
 
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
@@ -92,7 +92,7 @@ public void testTakeTimedErrorBeforeTime() {
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onNext(2);
         inOrder.verify(o).onNext(3);
-        inOrder.verify(o).onError(any(CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
 
         verify(o, never()).onCompleted();
@@ -119,7 +119,7 @@ public void testTakeTimedErrorAfterTime() {
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
 
         source.onNext(4);
-        source.onError(new CustomException());
+        source.onError(new TestException());
 
         InOrder inOrder = inOrder(o);
         inOrder.verify(o).onNext(1);
@@ -129,6 +129,6 @@ public void testTakeTimedErrorAfterTime() {
         inOrder.verifyNoMoreInteractions();
 
         verify(o, never()).onNext(4);
-        verify(o, never()).onError(any(CustomException.class));
+        verify(o, never()).onError(any(TestException.class));
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeUntilTest.java
index 6f75578185..dab3882216 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeUntilTest.java
@@ -24,6 +24,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 
 public class OperatorTakeUntilTest {
@@ -158,7 +159,7 @@ public void testTakeUntilOtherCompleted() {
 
     }
 
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
         Observer<? super String> observer = null;
         Subscription s;
@@ -183,9 +184,9 @@ public void sendOnError(Throwable e) {
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(Subscriber<? super String> observer) {
             this.observer = observer;
-            return s;
+            observer.add(s);
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
index 4c5701aa53..00a8d5db34 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
@@ -181,7 +181,7 @@ public Boolean call(String s, Integer index) {
         verify(s, times(1)).unsubscribe();
     }
 
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
         final Subscription s;
         final String[] values;
@@ -193,8 +193,9 @@ public TestObservable(Subscription s, String... values) {
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(final Subscriber<? super String> observer) {
             System.out.println("TestObservable subscribed to ...");
+            observer.add(s);
             t = new Thread(new Runnable() {
 
                 @Override
@@ -215,7 +216,6 @@ public void run() {
             System.out.println("starting TestObservable thread");
             t.start();
             System.out.println("done starting TestObservable thread");
-            return s;
         }
     }
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorThrottleFirstTest.java b/rxjava-core/src/test/java/rx/operators/OperatorThrottleFirstTest.java
index b1c83e9325..28cb730186 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorThrottleFirstTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorThrottleFirstTest.java
@@ -31,6 +31,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscriber;
+import rx.exceptions.TestException;
 import rx.functions.Action0;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
@@ -126,10 +127,6 @@ public void call() {
         }, delay, TimeUnit.MILLISECONDS);
     }
 
-    @SuppressWarnings("serial")
-    private class TestException extends Exception {
-    }
-
     @Test
     public void testThrottle() {
         @SuppressWarnings("unchecked")
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
index 1776c00434..75a721a54b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimeoutWithSelectorTest.java
@@ -39,6 +39,7 @@
 import rx.Observable.OnSubscribe;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.TestException;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.observers.TestSubscriber;
@@ -137,7 +138,7 @@ public Observable<Integer> call(Integer t1) {
         Func0<Observable<Integer>> firstTimeoutFunc = new Func0<Observable<Integer>>() {
             @Override
             public Observable<Integer> call() {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
 
@@ -148,7 +149,7 @@ public Observable<Integer> call() {
 
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
 
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
 
@@ -162,7 +163,7 @@ public void testTimeoutSelectorSubsequentThrows() {
         Func1<Integer, Observable<Integer>> timeoutFunc = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
 
@@ -184,7 +185,7 @@ public Observable<Integer> call() {
         source.onNext(1);
 
         inOrder.verify(o).onNext(1);
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         verify(o, never()).onCompleted();
 
     }
@@ -204,7 +205,7 @@ public Observable<Integer> call(Integer t1) {
         Func0<Observable<Integer>> firstTimeoutFunc = new Func0<Observable<Integer>>() {
             @Override
             public Observable<Integer> call() {
-                return Observable.<Integer> error(new OperationReduceTest.CustomException());
+                return Observable.<Integer> error(new TestException());
             }
         };
 
@@ -215,7 +216,7 @@ public Observable<Integer> call() {
 
         source.timeout(firstTimeoutFunc, timeoutFunc, other).subscribe(o);
 
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
         verify(o, never()).onNext(any());
         verify(o, never()).onCompleted();
 
@@ -229,7 +230,7 @@ public void testTimeoutSelectorSubsequentObservableThrows() {
         Func1<Integer, Observable<Integer>> timeoutFunc = new Func1<Integer, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Integer t1) {
-                return Observable.<Integer> error(new OperationReduceTest.CustomException());
+                return Observable.<Integer> error(new TestException());
             }
         };
 
@@ -251,7 +252,7 @@ public Observable<Integer> call() {
         source.onNext(1);
 
         inOrder.verify(o).onNext(1);
-        inOrder.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(o).onError(any(TestException.class));
         verify(o, never()).onCompleted();
 
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTimerTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTimerTest.java
index eadf4b274a..995a2c8bea 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTimerTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTimerTest.java
@@ -16,24 +16,26 @@
 package rx.operators;
 
 
-import java.util.concurrent.TimeUnit;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.InOrder;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyLong;
-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 java.util.concurrent.TimeUnit;
+
+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.Subscriber;
 import rx.Subscription;
+import rx.exceptions.TestException;
 import rx.observables.ConnectableObservable;
 import rx.schedulers.TestScheduler;
 
@@ -236,7 +238,7 @@ public void testOnceObserverThrows() {
 
             @Override
             public void onNext(Long t) {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
 
             @Override
@@ -252,7 +254,7 @@ public void onCompleted() {
         
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
         
-        verify(observer).onError(any(OperationReduceTest.CustomException.class));
+        verify(observer).onError(any(TestException.class));
         verify(observer, never()).onNext(anyLong());
         verify(observer, never()).onCompleted();
     }
@@ -267,7 +269,7 @@ public void testPeriodicObserverThrows() {
             @Override
             public void onNext(Long t) {
                 if (t > 0) {
-                    throw new OperationReduceTest.CustomException();
+                    throw new TestException();
                 }
                 observer.onNext(t);
             }
@@ -286,7 +288,7 @@ public void onCompleted() {
         scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
         
         inOrder.verify(observer).onNext(0L);
-        inOrder.verify(observer).onError(any(OperationReduceTest.CustomException.class));
+        inOrder.verify(observer).onError(any(TestException.class));
         inOrder.verifyNoMoreInteractions();
         verify(observer, never()).onCompleted();
     }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorToMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToMapTest.java
index db3c9cd1b9..af62ca1061 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorToMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToMapTest.java
@@ -162,6 +162,9 @@ public void testToMapWithFactory() {
             @Override
             public Map<Integer, String> call() {
                 return new LinkedHashMap<Integer, String>() {
+                    /** */
+                    private static final long serialVersionUID = -3296811238780863394L;
+
                     @Override
                     protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
                         return size() > 3;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorToMultimapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToMultimapTest.java
index 42dfb16fb4..aa7f65a426 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorToMultimapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToMultimapTest.java
@@ -106,6 +106,9 @@ public void testToMultimapWithMapFactory() {
             @Override
             public Map<Integer, Collection<String>> call() {
                 return new LinkedHashMap<Integer, Collection<String>>() {
+                    /** */
+                    private static final long serialVersionUID = -2084477070717362859L;
+
                     @Override
                     protected boolean removeEldestEntry(Map.Entry<Integer, Collection<String>> eldest) {
                         return size() > 2;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorToObservableFutureTest.java b/rxjava-core/src/test/java/rx/operators/OperatorToObservableFutureTest.java
index 8fdd6999df..fa5e2ec2fe 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorToObservableFutureTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorToObservableFutureTest.java
@@ -35,9 +35,11 @@ public class OperatorToObservableFutureTest {
 
     @Test
     public void testSuccess() throws Exception {
+        @SuppressWarnings("unchecked")
         Future<Object> future = mock(Future.class);
         Object value = new Object();
         when(future.get()).thenReturn(value);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         Subscription sub = Observable.from(future).subscribe(new TestObserver<Object>(o));
@@ -51,9 +53,11 @@ public void testSuccess() throws Exception {
 
     @Test
     public void testFailure() throws Exception {
+        @SuppressWarnings("unchecked")
         Future<Object> future = mock(Future.class);
         RuntimeException e = new RuntimeException();
         when(future.get()).thenThrow(e);
+        @SuppressWarnings("unchecked")
         Observer<Object> o = mock(Observer.class);
 
         Subscription sub = Observable.from(future).subscribe(new TestObserver<Object>(o));
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
index 99281a6841..d07a64cc68 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUnsubscribeOnTest.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 static org.junit.Assert.assertNotNull;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
index 570d0a2440..dba65f5206 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
@@ -26,9 +26,11 @@
 import org.mockito.InOrder;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
+import rx.Observable.OnSubscribe;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
+import rx.exceptions.TestException;
 import rx.functions.Action0;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -36,10 +38,6 @@
 
 public class OperatorUsingTest {
 
-    @SuppressWarnings("serial")
-    private static class TestException extends RuntimeException {
-    }
-
     private static interface Resource extends Subscription {
         public String getTextFromWeb();
 
@@ -197,9 +195,9 @@ public Subscription call() {
         Func1<Subscription, Observable<Integer>> observableFactory = new Func1<Subscription, Observable<Integer>>() {
             @Override
             public Observable<Integer> call(Subscription subscription) {
-                return Observable.create(new OnSubscribeFunc<Integer>() {
+                return Observable.create(new OnSubscribe<Integer>() {
                     @Override
-                    public Subscription onSubscribe(Observer<? super Integer> t1) {
+                    public void call(Subscriber<? super Integer> t1) {
                         throw new TestException();
                     }
                 });
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
index 34f20933fb..d8d90aca1f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
@@ -33,6 +33,7 @@
 import rx.Observer;
 import rx.Scheduler;
 import rx.Subscriber;
+import rx.exceptions.TestException;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func0;
@@ -478,7 +479,7 @@ public void onCompleted() {
         source.onNext(1);
         source.onNext(2);
 
-        boundary.onError(new OperationReduceTest.CustomException());
+        boundary.onError(new TestException());
 
         assertEquals(1, values.size());
 
@@ -487,10 +488,10 @@ public void onCompleted() {
         verify(mo).onNext(0);
         verify(mo).onNext(1);
         verify(mo).onNext(2);
-        verify(mo).onError(any(OperationReduceTest.CustomException.class));
+        verify(mo).onError(any(TestException.class));
 
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 
     @Test
@@ -530,7 +531,7 @@ public void onCompleted() {
         source.onNext(1);
         source.onNext(2);
 
-        source.onError(new OperationReduceTest.CustomException());
+        source.onError(new TestException());
 
         assertEquals(1, values.size());
 
@@ -539,9 +540,9 @@ public void onCompleted() {
         verify(mo).onNext(0);
         verify(mo).onNext(1);
         verify(mo).onNext(2);
-        verify(mo).onError(any(OperationReduceTest.CustomException.class));
+        verify(mo).onError(any(TestException.class));
 
         verify(o, never()).onCompleted();
-        verify(o).onError(any(OperationReduceTest.CustomException.class));
+        verify(o).onError(any(TestException.class));
     }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java b/rxjava-core/src/test/java/rx/operators/OperatorZipCompletionTest.java
similarity index 98%
rename from rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
rename to rxjava-core/src/test/java/rx/operators/OperatorZipCompletionTest.java
index f776e88106..3ca1086ae3 100644
--- a/rxjava-core/src/test/java/rx/operators/OperationZipTestCompletion.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipCompletionTest.java
@@ -33,7 +33,7 @@
  * the resulting Observable is finite.
  * 
  */
-public class OperationZipTestCompletion {
+public class OperatorZipCompletionTest {
     Func2<String, String, String> concat2Strings;
 
     PublishSubject<String> s1;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
index 37e8f7c6c1..6f2c84486f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipIterableTest.java
@@ -30,9 +30,9 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.exceptions.TestException;
 import rx.functions.Func2;
 import rx.functions.Func3;
-import rx.operators.OperationReduceTest.CustomException;
 import rx.subjects.PublishSubject;
 
 public class OperatorZipIterableTest {
@@ -85,6 +85,7 @@ public String call(Object t1, Object t2, Object t3) {
     public void testZipIterableSameSize() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -110,6 +111,7 @@ public void testZipIterableSameSize() {
     public void testZipIterableEmptyFirstSize() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -130,6 +132,7 @@ public void testZipIterableEmptyFirstSize() {
     public void testZipIterableEmptySecond() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -152,6 +155,7 @@ public void testZipIterableEmptySecond() {
     public void testZipIterableFirstShorter() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -175,6 +179,7 @@ public void testZipIterableFirstShorter() {
     public void testZipIterableSecondShorter() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -199,6 +204,7 @@ public void testZipIterableSecondShorter() {
     public void testZipIterableFirstThrows() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -208,11 +214,11 @@ public void testZipIterableFirstThrows() {
 
         r1.onNext("one-");
         r1.onNext("two-");
-        r1.onError(new OperationReduceTest.CustomException());
+        r1.onError(new TestException());
 
         io.verify(o).onNext("one-1");
         io.verify(o).onNext("two-2");
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        io.verify(o).onError(any(TestException.class));
 
         verify(o, never()).onCompleted();
 
@@ -222,13 +228,14 @@ public void testZipIterableFirstThrows() {
     public void testZipIterableIteratorThrows() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
         Iterable<String> r2 = new Iterable<String>() {
             @Override
             public Iterator<String> iterator() {
-                throw new OperationReduceTest.CustomException();
+                throw new TestException();
             }
         };
 
@@ -236,9 +243,9 @@ public Iterator<String> iterator() {
 
         r1.onNext("one-");
         r1.onNext("two-");
-        r1.onError(new OperationReduceTest.CustomException());
+        r1.onError(new TestException());
 
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        io.verify(o).onError(any(TestException.class));
 
         verify(o, never()).onCompleted();
         verify(o, never()).onNext(any(String.class));
@@ -249,6 +256,7 @@ public Iterator<String> iterator() {
     public void testZipIterableHasNextThrows() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -264,7 +272,7 @@ public boolean hasNext() {
                         if (count == 0) {
                             return true;
                         }
-                        throw new CustomException();
+                        throw new TestException();
                     }
 
                     @Override
@@ -286,10 +294,10 @@ public void remove() {
         r1.zip(r2, zipr2).subscribe(o);
 
         r1.onNext("one-");
-        r1.onError(new OperationReduceTest.CustomException());
+        r1.onError(new TestException());
 
         io.verify(o).onNext("one-1");
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        io.verify(o).onError(any(TestException.class));
 
         verify(o, never()).onCompleted();
 
@@ -299,6 +307,7 @@ public void remove() {
     public void testZipIterableNextThrows() {
         PublishSubject<String> r1 = PublishSubject.create();
         /* define a Observer to receive aggregated events */
+        @SuppressWarnings("unchecked")
         Observer<String> o = mock(Observer.class);
         InOrder io = inOrder(o);
 
@@ -307,8 +316,6 @@ public void testZipIterableNextThrows() {
             @Override
             public Iterator<String> iterator() {
                 return new Iterator<String>() {
-                    int count;
-
                     @Override
                     public boolean hasNext() {
                         return true;
@@ -316,7 +323,7 @@ public boolean hasNext() {
 
                     @Override
                     public String next() {
-                        throw new CustomException();
+                        throw new TestException();
                     }
 
                     @Override
@@ -331,9 +338,9 @@ public void remove() {
 
         r1.zip(r2, zipr2).subscribe(o);
 
-        r1.onError(new OperationReduceTest.CustomException());
+        r1.onError(new TestException());
 
-        io.verify(o).onError(any(OperationReduceTest.CustomException.class));
+        io.verify(o).onError(any(TestException.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 202864339e..245dc85d2e 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -51,7 +51,6 @@
 import rx.functions.Functions;
 import rx.observers.TestSubscriber;
 import rx.subjects.PublishSubject;
-import rx.subscriptions.Subscriptions;
 
 public class OperatorZipTest {
     Func2<String, String, String> concat2Strings;
@@ -621,25 +620,6 @@ public String call(String a1, String a2, String a3) {
         return zipr;
     }
 
-    private FuncN<String> getConcatZipr() {
-        FuncN<String> zipr = new FuncN<String>() {
-
-            @Override
-            public String call(Object... args) {
-                String returnValue = "";
-                for (Object o : args) {
-                    if (o != null) {
-                        returnValue += getStringValue(o);
-                    }
-                }
-                System.out.println("returning: " + returnValue);
-                return returnValue;
-            }
-
-        };
-        return zipr;
-    }
-
     private Func2<String, Integer, String> getConcatStringIntegerZipr() {
         Func2<String, Integer, String> zipr = new Func2<String, Integer, String>() {
 
@@ -676,15 +656,14 @@ private static String getStringValue(Object o) {
         }
     }
 
-    private static class TestObservable implements Observable.OnSubscribeFunc<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
         Observer<? super String> observer;
 
         @Override
-        public Subscription onSubscribe(Observer<? super String> Observer) {
+        public void call(Subscriber<? super String> observer) {
             // just store the variable where it can be accessed so we can manually trigger it
-            this.observer = Observer;
-            return Subscriptions.empty();
+            this.observer = observer;
         }
 
     }
diff --git a/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java b/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
deleted file mode 100644
index 86f9893962..0000000000
--- a/rxjava-core/src/test/java/rx/operators/SafeObservableSubscriptionTest.java
+++ /dev/null
@@ -1,36 +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.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import org.junit.Test;
-
-import rx.Subscription;
-
-public class SafeObservableSubscriptionTest {
-
-    @Test
-    public void testWrapAfterUnsubscribe() {
-        SafeObservableSubscription atomicObservableSubscription = new SafeObservableSubscription();
-        atomicObservableSubscription.unsubscribe();
-        Subscription innerSubscription = mock(Subscription.class);
-        atomicObservableSubscription.wrap(innerSubscription);
-        verify(innerSubscription, times(1)).unsubscribe();
-    }
-}
diff --git a/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java b/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
index dde3f93b99..ced81bb3df 100644
--- a/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
+++ b/rxjava-core/src/test/java/rx/operators/SafeSubscriberTest.java
@@ -25,6 +25,7 @@
 
 import rx.Observable;
 import rx.Observer;
+import rx.Subscriber;
 import rx.Subscription;
 import rx.observers.SafeSubscriber;
 import rx.observers.TestSubscriber;
@@ -36,7 +37,7 @@ public class SafeSubscriberTest {
      */
     @Test
     public void testOnNextAfterOnError() {
-        TestObservable t = new TestObservable(null);
+        TestObservable t = new TestObservable();
         Observable<String> st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
@@ -58,7 +59,7 @@ public void testOnNextAfterOnError() {
      */
     @Test
     public void testOnCompletedAfterOnError() {
-        TestObservable t = new TestObservable(null);
+        TestObservable t = new TestObservable();
         Observable<String> st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
@@ -80,7 +81,7 @@ public void testOnCompletedAfterOnError() {
      */
     @Test
     public void testOnNextAfterOnCompleted() {
-        TestObservable t = new TestObservable(null);
+        TestObservable t = new TestObservable();
         Observable<String> st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
@@ -103,7 +104,7 @@ public void testOnNextAfterOnCompleted() {
      */
     @Test
     public void testOnErrorAfterOnCompleted() {
-        TestObservable t = new TestObservable(null);
+        TestObservable t = new TestObservable();
         Observable<String> st = Observable.create(t);
 
         @SuppressWarnings("unchecked")
@@ -123,13 +124,10 @@ public void testOnErrorAfterOnCompleted() {
     /**
      * 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<String> {
+    private static class TestObservable implements Observable.OnSubscribe<String> {
 
         Observer<? super String> observer = null;
 
-        public TestObservable(Subscription s) {
-        }
-
         /* used to simulate subscription */
         public void sendOnCompleted() {
             observer.onCompleted();
@@ -146,9 +144,9 @@ public void sendOnError(Throwable e) {
         }
 
         @Override
-        public Subscription onSubscribe(final Observer<? super String> observer) {
+        public void call(Subscriber<? super String> observer) {
             this.observer = observer;
-            return new Subscription() {
+            observer.add(new Subscription() {
 
                 @Override
                 public void unsubscribe() {
@@ -161,7 +159,7 @@ public boolean isUnsubscribed() {
                     return false;
                 }
 
-            };
+            });
         }
 
     }
diff --git a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
index ecf2aacfdc..a99797e129 100644
--- a/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
+++ b/rxjava-core/src/test/java/rx/plugins/RxJavaPluginsTest.java
@@ -68,7 +68,6 @@ public void testErrorHandlerViaProperty() {
     // inside test so it is stripped from Javadocs
     public static class RxJavaErrorHandlerTestImpl extends RxJavaErrorHandler {
 
-        @SuppressWarnings("unused")
         private volatile Throwable e;
         private volatile int count = 0;
 
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index a3ff320ad4..c1f1ef69c7 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -38,15 +38,11 @@
 
 import rx.Observable;
 import rx.Observable.OnSubscribe;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
 import rx.Scheduler;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
-import rx.subscriptions.Subscriptions;
 
 /**
  * Base tests for all schedulers including Immediate/Current.
@@ -353,10 +349,10 @@ public void call(Integer v) {
     public final void testConcurrentOnNextFailsValidation() throws InterruptedException {
         final int count = 10;
         final CountDownLatch latch = new CountDownLatch(count);
-        Observable<String> o = Observable.create(new OnSubscribeFunc<String>() {
+        Observable<String> o = Observable.create(new OnSubscribe<String>() {
 
             @Override
-            public Subscription onSubscribe(final Observer<? super String> observer) {
+            public void call(final Subscriber<? super String> observer) {
                 for (int i = 0; i < count; i++) {
                     final int v = i;
                     new Thread(new Runnable() {
@@ -369,7 +365,6 @@ public void run() {
                         }
                     }).start();
                 }
-                return Subscriptions.empty();
             }
         });
 
@@ -415,13 +410,12 @@ public final void testSubscribeOnNestedConcurrency() throws InterruptedException
 
                     @Override
                     public Observable<String> call(final String v) {
-                        return Observable.create(new OnSubscribeFunc<String>() {
+                        return Observable.create(new OnSubscribe<String>() {
 
                             @Override
-                            public Subscription onSubscribe(final Observer<? super String> observer) {
+                            public void call(Subscriber<? super String> observer) {
                                 observer.onNext("value_after_map-" + v);
                                 observer.onCompleted();
-                                return Subscriptions.empty();
                             }
                         }).subscribeOn(scheduler);
                     }
diff --git a/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index 7c6a90bf56..ae492f9997 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -91,8 +91,6 @@ public void call() {
 
     @Test
     public final void testComputationThreadPool1() {
-        final Scheduler scheduler = getScheduler();
-
         Observable<Integer> o1 = Observable.<Integer> from(1, 2, 3, 4, 5);
         Observable<Integer> o2 = Observable.<Integer> from(6, 7, 8, 9, 10);
         Observable<String> o = Observable.<Integer> merge(o1, o2).map(new Func1<Integer, String>() {
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index a1307a2713..739fbe2966 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -137,7 +137,7 @@ public void testCompletedStopsEmittingData() {
         Observer<Object> observerC = mock(Observer.class);
 
         Subscription a = channel.subscribe(observerA);
-        Subscription b = channel.subscribe(observerB);
+        channel.subscribe(observerB);
 
         InOrder inOrderA = inOrder(observerA);
         InOrder inOrderB = inOrder(observerB);
@@ -162,7 +162,7 @@ public void testCompletedStopsEmittingData() {
 
         inOrderB.verify(observerB).onCompleted();
 
-        Subscription c = channel.subscribe(observerC);
+        channel.subscribe(observerC);
 
         inOrderC.verify(observerC).onCompleted();
 
@@ -211,6 +211,7 @@ public void testCompletedAfterErrorIsNotSent2() {
         verify(observer, never()).onNext("two");
         verify(observer, never()).onCompleted();
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o2 = mock(Observer.class);
         subject.subscribe(o2);
         verify(o2, times(1)).onError(testException);
@@ -237,6 +238,7 @@ public void testCompletedAfterErrorIsNotSent3() {
         verify(observer, never()).onError(any(Throwable.class));
         verify(observer, never()).onNext("two");
 
+        @SuppressWarnings("unchecked")
         Observer<Object> o2 = mock(Observer.class);
         subject.subscribe(o2);
         verify(o2, times(1)).onCompleted();
diff --git a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
index 258ad98d26..7c636b09b6 100644
--- a/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/PublishSubjectTest.java
@@ -74,7 +74,7 @@ public void testCompletedStopsEmittingData() {
         Observer<Object> observerC = mock(Observer.class);
 
         Subscription a = channel.subscribe(observerA);
-        Subscription b = channel.subscribe(observerB);
+        channel.subscribe(observerB);
 
         InOrder inOrderA = inOrder(observerA);
         InOrder inOrderB = inOrder(observerB);
@@ -96,7 +96,7 @@ public void testCompletedStopsEmittingData() {
 
         inOrderB.verify(observerB).onCompleted();
 
-        Subscription c = channel.subscribe(observerC);
+        channel.subscribe(observerC);
 
         inOrderC.verify(observerC).onCompleted();
 
@@ -270,6 +270,7 @@ public void call(String v) {
     public void testReSubscribe() {
         final PublishSubject<Integer> ps = PublishSubject.create();
 
+        @SuppressWarnings("unchecked")
         Observer<Integer> o1 = mock(Observer.class);
         Subscription s1 = ps.subscribe(o1);
 
@@ -287,6 +288,7 @@ public void testReSubscribe() {
         // emit again but nothing will be there to receive it
         ps.onNext(2);
 
+        @SuppressWarnings("unchecked")
         Observer<Integer> o2 = mock(Observer.class);
         Subscription s2 = ps.subscribe(o2);
 
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 354701b041..7e0a58974b 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -17,7 +17,10 @@
 
 import static org.junit.Assert.assertEquals;
 
-import java.util.*;
+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.AtomicReference;
@@ -25,14 +28,11 @@
 import org.junit.Test;
 
 import rx.Observable;
-import rx.Observable.OnSubscribeFunc;
-import rx.Observer;
+import rx.Observable.OnSubscribe;
 import rx.Subscriber;
-import rx.Subscription;
 import rx.functions.Action1;
 import rx.observers.TestSubscriber;
 import rx.schedulers.Schedulers;
-import rx.subscriptions.Subscriptions;
 
 public class ReplaySubjectConcurrencyTest {
 
@@ -55,17 +55,16 @@ public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther(
 
             @Override
             public void run() {
-                Observable.create(new OnSubscribeFunc<Long>() {
+                Observable.create(new OnSubscribe<Long>() {
 
                     @Override
-                    public Subscription onSubscribe(Observer<? super Long> o) {
+                    public void call(Subscriber<? super Long> 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);
             }
@@ -165,17 +164,16 @@ public void testReplaySubjectConcurrentSubscriptions() throws InterruptedExcepti
 
             @Override
             public void run() {
-                Observable.create(new OnSubscribeFunc<Long>() {
+                Observable.create(new OnSubscribe<Long>() {
 
                     @Override
-                    public Subscription onSubscribe(Observer<? super Long> o) {
+                    public void call(Subscriber<? super Long> 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);
             }
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index dd018abd72..4996b511d2 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -80,7 +80,7 @@ public void testCompletedStopsEmittingData() {
         Observer<Object> observerD = mock(Observer.class);
 
         Subscription a = channel.subscribe(observerA);
-        Subscription b = channel.subscribe(observerB);
+        channel.subscribe(observerB);
 
         InOrder inOrderA = inOrder(observerA);
         InOrder inOrderB = inOrder(observerB);
@@ -108,7 +108,7 @@ public void testCompletedStopsEmittingData() {
         // B is subscribed so should receive onCompleted
         inOrderB.verify(observerB).onCompleted();
 
-        Subscription c = channel.subscribe(observerC);
+        channel.subscribe(observerC);
 
         // when C subscribes it should receive 42, 4711, onCompleted
         inOrderC.verify(observerC).onNext(42);
@@ -122,7 +122,7 @@ public void testCompletedStopsEmittingData() {
         channel.onError(new RuntimeException());
 
         // a new subscription should only receive what was emitted prior to terminal state onCompleted
-        Subscription d = channel.subscribe(observerD);
+        channel.subscribe(observerD);
 
         inOrderD.verify(observerD).onNext(42);
         inOrderD.verify(observerD).onNext(4711);
@@ -312,14 +312,14 @@ public void onNext(String v) {
         };
 
         ReplaySubject<String> subject = ReplaySubject.create();
-        Subscription s1 = subject.subscribe(observer1);
+        subject.subscribe(observer1);
         subject.onNext("one");
         assertEquals("one", lastValueForObserver1.get());
         subject.onNext("two");
         assertEquals("two", lastValueForObserver1.get());
 
         // use subscribeOn to make this async otherwise we deadlock as we are using CountDownLatches
-        Subscription s2 = subject.subscribeOn(Schedulers.newThread()).subscribe(observer2);
+        subject.subscribeOn(Schedulers.newThread()).subscribe(observer2);
 
         System.out.println("before waiting for one");
 

From c857ba3364a4ee72ba61e27736dcef3c4c7f92fc Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 6 May 2014 15:30:12 +0200
Subject: [PATCH 347/422] Removed unused interface

---
 .../java/rx/schedulers/EventLoopsScheduler.java  | 16 +++++++++++++++-
 .../java/rx/schedulers/NewThreadScheduler.java   | 15 ++-------------
 2 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
index 48443a9743..c9c1cc7854 100644
--- a/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/EventLoopsScheduler.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.schedulers;
 
 import java.util.concurrent.ThreadFactory;
@@ -7,7 +22,6 @@
 import rx.Scheduler;
 import rx.Subscription;
 import rx.functions.Action0;
-import rx.schedulers.NewThreadScheduler.NewThreadWorker.Remover;
 import rx.schedulers.NewThreadScheduler.NewThreadWorker.ScheduledAction;
 import rx.subscriptions.CompositeSubscription;
 import rx.subscriptions.Subscriptions;
diff --git a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
index 24be9bd8a7..7e258d7289 100644
--- a/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
+++ b/rxjava-core/src/main/java/rx/schedulers/NewThreadScheduler.java
@@ -69,11 +69,7 @@ public Worker createWorker() {
 
         @Override
         public Subscription schedule(final Action0 action) {
-            return schedule(action, null);
-        }
-
-        /* package */Subscription schedule(final Action0 action, final OnActionComplete onComplete) {
-            return scheduleActual(action, 0, null);
+            return schedule(action, 0, null);
         }
 
         @Override
@@ -98,7 +94,7 @@ public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit
         }
         
         /** Remove a child subscription from a composite when unsubscribing. */
-        public static final class Remover implements Subscription {
+        private static final class Remover implements Subscription {
             final Subscription s;
             final CompositeSubscription parent;
             final AtomicBoolean once;
@@ -185,11 +181,4 @@ public boolean isUnsubscribed() {
         }
 
     }
-
-    /* package */static interface OnActionComplete {
-
-        public void complete(Subscription s);
-
-    }
-
 }
\ No newline at end of file

From 8397f742884c01199534ffae564675d9223319ee Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 6 May 2014 22:10:04 +0800
Subject: [PATCH 348/422] Replace '+' with '::'

---
 .../examples/scala/rx/lang/scala/examples/RxScalaDemo.scala  | 5 +++--
 .../src/main/scala/rx/lang/scala/Observable.scala            | 2 +-
 .../src/test/scala/rx/lang/scala/CompletenessTest.scala      | 2 +-
 3 files changed, 5 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 a11ec76638..ac61b8d3e9 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
@@ -780,8 +780,9 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def startWithExample1(): Unit = {
-    val o = List(2, 3).toObservable + 1
-    assertEquals(List(1, 2, 3), o.toBlockingObservable.toList)
+    val o1 = List(3, 4).toObservable
+    val o2 = 1 :: 2 :: o1
+    assertEquals(List(1, 2, 3, 4), o2.toBlockingObservable.toList)
   }
 
   @Test def startWithExample2(): Unit = {
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 0473189e63..1b32033e4b 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
@@ -247,7 +247,7 @@ trait Observable[+T]
    * @param elem the item to emit
    * @return an Observable that emits the specified item before it begins to emit items emitted by the source Observable
    */
-  def +[U >: T](elem: U): Observable[U] = {
+  def ::[U >: T](elem: U): Observable[U] = {
     val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
     toScalaObservable(thisJava.startWith(elem))
   }
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 03b4d879bb..1dd6436060 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
@@ -167,7 +167,7 @@ class CompletenessTest extends JUnitSuite {
       "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]"
+      "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`]"

From 67cae348ece850b7e89f58714c5c4f9a4f651d5a Mon Sep 17 00:00:00 2001
From: Kirk Shoop <kirk.shoop@microsoft.com>
Date: Tue, 6 May 2014 07:57:35 -0700
Subject: [PATCH 349/422] fix to remove drift from schedulePeriodic

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

diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index 1d45006649..2aa3017476 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -99,15 +99,16 @@ public abstract static class Worker implements Subscription {
          */
         public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
             final long periodInNanos = unit.toNanos(period);
+            final long startInNanos = TimeUnit.MILLISECONDS.toNanos(now()) + unit.toNanos(initialDelay);
 
             final Action0 recursiveAction = new Action0() {
+                long count = 0;
                 @Override
                 public void call() {
                     if (!isUnsubscribed()) {
-                        long startedAt = now();
                         action.call();
-                        long timeTakenByActionInNanos = TimeUnit.MILLISECONDS.toNanos(now() - startedAt);
-                        schedule(this, periodInNanos - timeTakenByActionInNanos, TimeUnit.NANOSECONDS);
+                        long nextTick = startInNanos + (++count * periodInNanos);
+                        schedule(this, nextTick - TimeUnit.MILLISECONDS.toNanos(now()), TimeUnit.NANOSECONDS);
                     }
                 }
             };

From 012af02298aea5771c0da91dadfc4b0726cb1902 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 6 May 2014 09:58:05 -0700
Subject: [PATCH 350/422] Fix defer for Java 8 type-inference

Fixes https://github.com/Netflix/RxJava/issues/1157
---
 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 894760032d..46f8a655e1 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -884,7 +884,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      *         Observable factory function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-defer">RxJava Wiki: defer()</a>
      */
-    public final static <T> Observable<T> defer(Func0<? extends Observable<? extends T>> observableFactory) {
+    public final static <T> Observable<T> defer(Func0<Observable<? extends T>> observableFactory) {
         return create(new OperatorDefer<T>(observableFactory));
     }
 

From f6af2dc155022d74b891b58e0850fa4d40e2b9ec Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 6 May 2014 11:21:56 -0700
Subject: [PATCH 351/422] JMH Perf Tests for Schedulers.computation

---
 .../rx/jmh/InputWithIncrementingInteger.java  | 83 +++++++++++++++++++
 .../java/rx/operators/OperatorMapPerf.java    | 67 +--------------
 .../schedulers/ComputationSchedulerPerf.java  | 35 ++++++++
 3 files changed, 120 insertions(+), 65 deletions(-)
 create mode 100644 rxjava-core/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
 create mode 100644 rxjava-core/src/perf/java/rx/schedulers/ComputationSchedulerPerf.java

diff --git a/rxjava-core/src/perf/java/rx/jmh/InputWithIncrementingInteger.java b/rxjava-core/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
new file mode 100644
index 0000000000..7804709515
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/jmh/InputWithIncrementingInteger.java
@@ -0,0 +1,83 @@
+/**
+ * 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.jmh;
+
+import java.util.concurrent.CountDownLatch;
+
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.logic.BlackHole;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.Subscriber;
+
+/**
+ * Exposes an Observable and Observer that increments n Integers and consumes them in a Blackhole.
+ */
+@State(Scope.Thread)
+public class InputWithIncrementingInteger {
+    @Param({ "1", "1024", "1048576" })
+    public int size;
+
+    public Observable<Integer> observable;
+    public Observer<Integer> observer;
+
+    private CountDownLatch latch;
+
+    @Setup
+    public void setup() {
+        observable = Observable.create(new OnSubscribe<Integer>() {
+            @Override
+            public void call(Subscriber<? super Integer> o) {
+                for (int value = 0; value < size; value++) {
+                    if (o.isUnsubscribed())
+                        return;
+                    o.onNext(value);
+                }
+                o.onCompleted();
+            }
+        });
+
+        final BlackHole bh = new BlackHole();
+        latch = new CountDownLatch(1);
+
+        observer = new Observer<Integer>() {
+            @Override
+            public void onCompleted() {
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new RuntimeException(e);
+            }
+
+            @Override
+            public void onNext(Integer value) {
+                bh.consume(value);
+            }
+        };
+
+    }
+
+    public void awaitCompletion() throws InterruptedException {
+        latch.await();
+    }
+}
diff --git a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
index 2a41151e45..7a635e778a 100644
--- a/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
+++ b/rxjava-core/src/perf/java/rx/operators/OperatorMapPerf.java
@@ -15,28 +15,17 @@
  */
 package rx.operators;
 
-import java.util.concurrent.CountDownLatch;
-
 import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.logic.BlackHole;
 
-import rx.Observable;
-import rx.Observable.OnSubscribe;
 import rx.Observable.Operator;
-import rx.Observer;
-import rx.Subscriber;
 import rx.functions.Func1;
+import rx.jmh.InputWithIncrementingInteger;
 
 public class OperatorMapPerf {
 
     @GenerateMicroBenchmark
-    public void mapIdentityFunction(Input input) throws InterruptedException {
+    public void mapIdentityFunction(InputWithIncrementingInteger input) throws InterruptedException {
         input.observable.lift(MAP_OPERATOR).subscribe(input.observer);
-
         input.awaitCompletion();
     }
 
@@ -49,56 +38,4 @@ public Integer call(Integer value) {
 
     private static final Operator<Integer, Integer> MAP_OPERATOR = new OperatorMap<Integer, Integer>(IDENTITY_FUNCTION);
 
-    @State(Scope.Thread)
-    public static class Input {
-
-        @Param({ "1", "1024", "1048576" })
-        public int size;
-
-        public Observable<Integer> observable;
-        public Observer<Integer> observer;
-
-        private CountDownLatch latch;
-
-        @Setup
-        public void setup() {
-            observable = Observable.create(new OnSubscribe<Integer>() {
-                @Override
-                public void call(Subscriber<? super Integer> o) {
-                    for (int value = 0; value < size; value++) {
-                        if (o.isUnsubscribed())
-                            return;
-                        o.onNext(value);
-                    }
-                    o.onCompleted();
-                }
-            });
-
-            final BlackHole bh = new BlackHole();
-            latch = new CountDownLatch(1);
-
-            observer = new Observer<Integer>() {
-                @Override
-                public void onCompleted() {
-                    latch.countDown();
-                }
-
-                @Override
-                public void onError(Throwable e) {
-                    throw new RuntimeException(e);
-                }
-
-                @Override
-                public void onNext(Integer value) {
-                    bh.consume(value);
-                }
-            };
-
-        }
-
-        public void awaitCompletion() throws InterruptedException {
-            latch.await();
-        }
-    }
-
 }
diff --git a/rxjava-core/src/perf/java/rx/schedulers/ComputationSchedulerPerf.java b/rxjava-core/src/perf/java/rx/schedulers/ComputationSchedulerPerf.java
new file mode 100644
index 0000000000..9b44cdd3d6
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/schedulers/ComputationSchedulerPerf.java
@@ -0,0 +1,35 @@
+/**
+ * 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.schedulers;
+
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+
+import rx.jmh.InputWithIncrementingInteger;
+
+public class ComputationSchedulerPerf {
+
+    @GenerateMicroBenchmark
+    public void subscribeOn(InputWithIncrementingInteger input) throws InterruptedException {
+        input.observable.subscribeOn(Schedulers.computation()).subscribe(input.observer);
+        input.awaitCompletion();
+    }
+
+    @GenerateMicroBenchmark
+    public void observeOn(InputWithIncrementingInteger input) throws InterruptedException {
+        input.observable.observeOn(Schedulers.computation()).subscribe(input.observer);
+        input.awaitCompletion();
+    }
+}
\ No newline at end of file

From d81620ee1c59417ccf90f5ccaaee0b2cff1a43de Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Tue, 6 May 2014 11:49:38 -0700
Subject: [PATCH 352/422] Revert #1163 until decision made

Reverting change made in #1163 as it broke the build
---
 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 089c6421e4..752f5684f5 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -884,7 +884,7 @@ public final static <T> Observable<T> concat(Observable<? extends T> t1, Observa
      *         Observable factory function
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-defer">RxJava Wiki: defer()</a>
      */
-    public final static <T> Observable<T> defer(Func0<Observable<? extends T>> observableFactory) {
+    public final static <T> Observable<T> defer(Func0<? extends Observable<? extends T>> observableFactory) {
         return create(new OperatorDefer<T>(observableFactory));
     }
 

From 2e0e537f84fd2dfe15aac7a2807fb5bfdcf1aa4c Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 7 May 2014 04:33:36 +0000
Subject: [PATCH 353/422] [Gradle Release Plugin] - pre tag commit:  '0.18.3'.

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

diff --git a/gradle.properties b/gradle.properties
index 061f9ca491..0da9441cfa 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.3-SNAPSHOT
+version=0.18.3

From 5c7de063f3408686e87292b0b78253a6cfcf45a7 Mon Sep 17 00:00:00 2001
From: Bob T Builder <builds@netflix.com>
Date: Wed, 7 May 2014 04:33:40 +0000
Subject: [PATCH 354/422] [Gradle Release Plugin] - new version commit: 
 '0.18.4-SNAPSHOT'.

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

diff --git a/gradle.properties b/gradle.properties
index 0da9441cfa..733ef16f47 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-version=0.18.3
+version=0.18.4-SNAPSHOT

From 47a7744ef9e690f5a9a5b41298a580a30c734b69 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 7 May 2014 15:44:16 +0800
Subject: [PATCH 355/422] Update according to review in issue #1159

---
 .../src/main/scala/rx/lang/scala/Observable.scala             | 4 ++--
 1 file changed, 2 insertions(+), 2 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 1b32033e4b..3b49fc805d 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
@@ -1133,7 +1133,7 @@ trait Observable[+T]
    * @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
    */
-  def contains(elem: Any): Observable[Boolean] = {
+  def contains[U >: T](elem: U): Observable[Boolean] = {
     exists(_ == elem)
   }
 
@@ -2580,7 +2580,7 @@ trait Observable[+T]
    * <p>
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnTerminate.png">
    * <p>
-   * This differs from `finallyDo` in that this happens BEFORE onCompleted/onError are emitted.
+   * This differs from `finallyDo` in that this happens **before** `onCompleted/nError` are emitted.
    *
    * @param onTerminate the action to invoke when the source Observable calls `onCompleted` or `onError`
    * @return the source Observable with the side-effecting behavior applied

From 3bf7c4d06ef5b7ffa8c2978db823d38f531dbaef Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 7 May 2014 16:14:50 +0800
Subject: [PATCH 356/422] Remove () and update CompletenessTest

---
 .../scala/rx/lang/scala/examples/RxScalaDemo.scala        | 2 +-
 .../src/main/scala/rx/lang/scala/Observable.scala         | 6 +++---
 .../src/test/scala/rx/lang/scala/CompletenessTest.scala   | 8 ++------
 3 files changed, 6 insertions(+), 10 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 de2b5bed37..5cbcadc279 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
@@ -737,7 +737,7 @@ class RxScalaDemo extends JUnitSuite {
   }
 
   @Test def repeatExample1(): Unit = {
-    val o : Observable[String] = List("alice", "bob", "carol").toObservable.repeat().take(6)
+    val o : Observable[String] = List("alice", "bob", "carol").toObservable.repeat.take(6)
     assertEquals(List("alice", "bob", "carol", "alice", "bob", "carol"), o.toBlockingObservable.toList)
   }
 
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 6e10054ef4..f0eb2d8c13 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
@@ -1431,7 +1431,7 @@ trait Observable[+T]
    *
    * @return an [[rx.lang.scala.observables.ConnectableObservable]].
    */
-  def publish(): ConnectableObservable[T] = {
+  def publish: ConnectableObservable[T] = {
     new ConnectableObservable[T](asJavaObservable.publish())
   }
 
@@ -2649,7 +2649,7 @@ trait Observable[+T]
    * emits [1, 2, 3, 4, 5] then the complete output would be [1, 2, 1, 2, 3, 4, 5, onCompleted].
    * @return Observable with retry logic.
    */
-  def retry(): Observable[T] = {
+  def retry: Observable[T] = {
     toScalaObservable[T](asJavaObservable.retry())
   }
 
@@ -2662,7 +2662,7 @@ trait Observable[+T]
    * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
    * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
    */
-  def repeat(): Observable[T] = {
+  def repeat: Observable[T] = {
     toScalaObservable[T](asJavaObservable.repeat())
   }
 
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 4815428d1a..5615b1e6bc 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
@@ -83,13 +83,14 @@ class CompletenessTest extends JUnitSuite {
       "lift(Operator[_ <: R, _ >: T])" -> "lift(Subscriber[R] => Subscriber[T])",
       "mapMany(Func1[_ >: T, _ <: Observable[_ <: R]])" -> "flatMap(T => Observable[R])",
       "mapWithIndex(Func2[_ >: T, Integer, _ <: R])" -> "[combine `zipWithIndex` with `map` or with a for comprehension]",
+      "multicast(Subject[_ >: T, _ <: R])" -> "multicast(Subject[R])",
+      "multicast(Func0[_ <: Subject[_ >: T, _ <: TIntermediate]], Func1[_ >: Observable[TIntermediate], _ <: Observable[TResult]])" -> "multicast(() => Subject[R], Observable[R] => Observable[U])",
       "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)",
-      "publish()" -> "publish()",
       "publish(T)" -> "publish(U)",
       "publish(Func1[_ >: Observable[T], _ <: Observable[R]])" -> "publish(Observable[U] => Observable[R])",
       "publish(Func1[_ >: Observable[T], _ <: Observable[R]], T)" -> "publish(Observable[U] => Observable[R], U)",
@@ -103,7 +104,6 @@ class CompletenessTest extends JUnitSuite {
       "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Long, TimeUnit)" -> "replay(Observable[U] => Observable[R], Duration)",
       "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Long, TimeUnit, Scheduler)" -> "replay(Observable[U] => Observable[R], Duration, Scheduler)",
       "replay(Func1[_ >: Observable[T], _ <: Observable[R]], Scheduler)" -> "replay(Observable[U] => Observable[R], Scheduler)",
-      "retry()" -> "retry()",
       "scan(Func2[T, T, T])" -> unnecessary,
       "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)",
       "skip(Int)" -> "drop(Int)",
@@ -158,11 +158,7 @@ class CompletenessTest extends JUnitSuite {
       "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]]])",
-      "multicast(Subject[_ >: T, _ <: R])" -> "multicast(Subject[R])",
-      "multicast(Func0[_ <: Subject[_ >: T, _ <: TIntermediate]], Func1[_ >: Observable[TIntermediate], _ <: Observable[TResult]])" -> "multicast(() => Subject[R], Observable[R] => Observable[U])",
       "range(Int, Int)" -> "apply(Range)",
-      "repeat()" -> "repeat()",
-      "retry()" -> "retry()",
       "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])",

From be0a6be1292f4f2ad33a8a096e57de27724e0405 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 7 May 2014 18:23:00 +0800
Subject: [PATCH 357/422] Remove 'startWith', add '+:' and ':+'

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 21 ++-----
 .../main/scala/rx/lang/scala/Observable.scala | 60 ++++---------------
 .../rx/lang/scala/CompletenessTest.scala      | 12 ++--
 3 files changed, 23 insertions(+), 70 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 ac61b8d3e9..3ba3c90ff6 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
@@ -779,26 +779,15 @@ class RxScalaDemo extends JUnitSuite {
     }
   }
 
-  @Test def startWithExample1(): Unit = {
+  @Test def startWithExample(): Unit = {
     val o1 = List(3, 4).toObservable
-    val o2 = 1 :: 2 :: o1
+    val o2 = 1 +: 2 +: o1
     assertEquals(List(1, 2, 3, 4), o2.toBlockingObservable.toList)
   }
 
-  @Test def startWithExample2(): Unit = {
-    val prepended = List(2, 4).toObservable
-    val o = List(5, 6, 7, 8).toObservable.filter(_ % 2 == 0).startWith(prepended)
-    assertEquals(List(2, 4, 6, 8), o.toBlockingObservable.toList)
-  }
-
-  @Test def startWithExample3(): Unit = {
-    val o = List(5, 6, 7, 8).toObservable.filter(_ % 2 == 0).startWith(List(2, 4))
-    assertEquals(List(2, 4, 6, 8), o.toBlockingObservable.toList)
-  }
-
-  @Test def startWithExample4(): Unit = {
-    val o = List(5, 6, 7, 8).toObservable.filter(_ % 2 == 0).startWith(Array(2, 4))
-    assertEquals(List(2, 4, 6, 8), o.toBlockingObservable.toList)
+  @Test def appendExample(): Unit = {
+    val o = List(1, 2).toObservable :+ 3 :+ 4
+    assertEquals(List(1, 2, 3, 4), o.toBlockingObservable.toList)
   }
 
 }
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 3b49fc805d..9885797dd4 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
@@ -222,6 +222,16 @@ trait Observable[+T]
     (() => javaCO.connect(), toScalaObservable(javaCO))
   }
 
+  /**
+   * Returns an Observable that first emits the items emitted by `this`, and then `elem`.
+   *
+   * @param elem the item to be appended
+   * @return  an Observable that first emits the items emitted by `this`, and then `elem`.
+   */
+  def :+[U >: T](elem: U): Observable[U] = {
+    this ++ Observable.items(elem)
+  }
+
   /**
    * Returns an Observable that first emits the items emitted by `this`, and then the items emitted
    * by `that`.
@@ -247,57 +257,11 @@ trait Observable[+T]
    * @param elem the item to emit
    * @return an Observable that emits the specified item before it begins to emit items emitted by the source Observable
    */
-  def ::[U >: T](elem: U): Observable[U] = {
+  def +:[U >: T](elem: U): Observable[U] = {
     val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
     toScalaObservable(thisJava.startWith(elem))
   }
 
-  /**
-   * Returns an Observable that emits the items in a specified `Observable` before it begins to emit
-   * items emitted by the source Observable.
-   * <p>
-   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.o.png">
-   *
-   * @param that an Observable that contains the items you want the modified Observable to emit first
-   * @return an Observable that emits the items in the specified `Observable` and then emits the items
-   *         emitted by the source Observable
-   */
-  def startWith[U >: T](that: Observable[U]): Observable[U] = {
-    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
-    val thatJava = that.asJavaObservable.asInstanceOf[rx.Observable[U]]
-    toScalaObservable(thisJava.startWith(thatJava))
-  }
-
-  /**
-   * Returns an Observable that emits the items in a specified `Iterable` before it begins to emit items
-   * emitted by the source Observable.
-   * <p>
-   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.png">
-   *
-   * @param iterable an Iterable that contains the items you want the modified Observable to emit first
-   * @return an Observable that emits the items in the specified `Iterable` and then emits the items
-   *         emitted by the source Observable
-   */
-  def startWith[U >: T](iterable: Iterable[U]): Observable[U] = {
-    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
-    toScalaObservable(thisJava.startWith(iterable.asJava))
-  }
-
-  /**
-   * Returns an Observable that emits the items in a specified `Iterable`, on a specified `Scheduler`, before it begins to emit items emitted by the source Observable.
-   * <p>
-   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startWith.s.png">
-   *
-   * @param iterable 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 `Iterable`, on a specified `Scheduler`, and then emits the items
-   *         emitted by the source Observable
-   */
-  def startWith[U >: T](iterable: Iterable[U], scheduler: Scheduler): Observable[U] = {
-    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[U]]
-    toScalaObservable(thisJava.startWith(iterable.asJava, scalaSchedulerToJavaScheduler(scheduler)))
-  }
-
   /**
    * Returns an Observable that emits the items emitted by several Observables, one after the
    * other.
@@ -2580,7 +2544,7 @@ trait Observable[+T]
    * <p>
    * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/doOnTerminate.png">
    * <p>
-   * This differs from `finallyDo` in that this happens **before** `onCompleted/nError` are emitted.
+   * This differs from `finallyDo` in that this happens **before** `onCompleted/onError` are emitted.
    *
    * @param onTerminate the action to invoke when the source Observable calls `onCompleted` or `onError`
    * @return the source Observable with the side-effecting behavior applied
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 1dd6436060..2cc187f790 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
@@ -104,11 +104,11 @@ class CompletenessTest extends JUnitSuite {
       "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)",
       "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary,
       "skipUntil(Observable[U])" -> "dropUntil(Observable[E])",
-      "startWith(Array[T])" -> "startWith(Iterable[U])",
-      "startWith(Array[T], Scheduler)" -> "startWith(Iterable[U], Scheduler)",
-      "startWith(Iterable[T])" -> "startWith(Iterable[U])",
-      "startWith(Iterable[T], Scheduler)" -> "startWith(Iterable[U], Scheduler)",
-      "startWith(Observable[T])" -> "startWith(Observable[U])",
+      "startWith(Array[T])" -> "[use `Observable.items(items) ++ o`]",
+      "startWith(Array[T], Scheduler)" -> "[use `Observable.items(items).subscribeOn(scheduler) ++ o`]",
+      "startWith(Iterable[T])" -> "[use `Observable.from(iterable) ++ o`]",
+      "startWith(Iterable[T], Scheduler)" -> "[use `Observable.from(iterable).subscribeOn(scheduler) ++ o`]",
+      "startWith(Observable[T])" -> "[use `++`]",
       "skipLast(Int)" -> "dropRight(Int)",
       "skipLast(Long, TimeUnit)" -> "dropRight(Duration)",
       "skipLast(Long, TimeUnit, Scheduler)" -> "dropRight(Duration, Scheduler)",
@@ -167,7 +167,7 @@ class CompletenessTest extends JUnitSuite {
       "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]"
+      "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`]"

From 9f916a21b5ec41a2aab17522384647d516dba74d Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 7 May 2014 21:54:51 +0800
Subject: [PATCH 358/422] Update 'startWith' info in CompletenessTest

---
 .../src/test/scala/rx/lang/scala/CompletenessTest.scala      | 5 +++--
 1 file changed, 3 insertions(+), 2 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 2cc187f790..6d249289b0 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
@@ -104,6 +104,7 @@ class CompletenessTest extends JUnitSuite {
       "skipWhile(Func1[_ >: T, Boolean])" -> "dropWhile(T => Boolean)",
       "skipWhileWithIndex(Func2[_ >: T, Integer, Boolean])" -> unnecessary,
       "skipUntil(Observable[U])" -> "dropUntil(Observable[E])",
+      "startWith(T)" -> "[use `item +: o`]",
       "startWith(Array[T])" -> "[use `Observable.items(items) ++ o`]",
       "startWith(Array[T], Scheduler)" -> "[use `Observable.items(items).subscribeOn(scheduler) ++ o`]",
       "startWith(Iterable[T])" -> "[use `Observable.from(iterable) ++ o`]",
@@ -165,9 +166,9 @@ class CompletenessTest extends JUnitSuite {
       "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(
+  ) ++ List.iterate("T, T", 8)(s => s + ", T").map(
       // all 9 overloads of startWith:
-      "startWith(" + _ + ")" -> "[unnecessary because we can just use `++` instead]"
+      "startWith(" + _ + ")" -> "[use `Observable.items(...) ++ o`]"
   ).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`]"

From e6ae50b279b224d0560772e147e48397623b1693 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Thu, 8 May 2014 16:48:13 +0200
Subject: [PATCH 359/422] Change to batch dequeue.

---
 .../java/rx/operators/OperatorObserveOn.java  | 55 ++++++++++++++++---
 1 file changed, 47 insertions(+), 8 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
index 9412ef8324..972abf58f6 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorObserveOn.java
@@ -15,7 +15,8 @@
  */
 package rx.operators;
 
-import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicLong;
 
 import rx.Observable.Operator;
@@ -60,7 +61,7 @@ private static class ObserveOnSubscriber<T> extends Subscriber<T> {
         final Subscriber<? super T> observer;
         private final Scheduler.Worker recursiveScheduler;
 
-        private final ConcurrentLinkedQueue<Object> queue = new ConcurrentLinkedQueue<Object>();
+        private FastList queue = new FastList();
         final AtomicLong counter = new AtomicLong(0);
 
         public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> subscriber) {
@@ -72,19 +73,25 @@ public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> subscriber
 
         @Override
         public void onNext(final T t) {
-            queue.offer(on.next(t));
+            synchronized (this) {
+                queue.add(on.next(t));
+            }
             schedule();
         }
 
         @Override
         public void onCompleted() {
-            queue.offer(on.completed());
+            synchronized (this) {
+                queue.add(on.completed());
+            }
             schedule();
         }
 
         @Override
         public void onError(final Throwable e) {
-            queue.offer(on.error(e));
+            synchronized (this) {
+                queue.add(on.error(e));
+            }
             schedule();
         }
 
@@ -103,11 +110,43 @@ public void call() {
 
         private void pollQueue() {
             do {
-                Object v = queue.poll();
-                on.accept(observer, v);
-            } while (counter.decrementAndGet() > 0);
+                FastList vs;
+                synchronized (this) {
+                    vs = queue;
+                    queue = new FastList();
+                }
+                for (Object v : vs.array) {
+                    if (v == null) {
+                        break;
+                    }
+                    on.accept(observer, v);
+                }
+                if (counter.addAndGet(-vs.size) == 0) {
+                    break;
+                }
+            } while (true);
         }
 
     }
 
+    static final class FastList {
+        Object[] array;
+        int size;
+
+        public void add(Object o) {
+            int s = size;
+            Object[] a = array;
+            if (a == null) {
+                a = new Object[16];
+                array = a;
+            } else if (s == a.length) {
+                Object[] array2 = new Object[s + (s >> 2)];
+                System.arraycopy(a, 0, array2, 0, s);
+                a = array2;
+                array = a;
+            }
+            a[s] = o;
+            size = s + 1;
+        }
+    }
 }
\ No newline at end of file

From 3e58d902fb08fb87059d7a017b352885dd24f4ba Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Thu, 8 May 2014 23:37:52 +0200
Subject: [PATCH 360/422] Fixed synchronous ConnectableObservable.connect
 problem

---
 .../rx/observables/ConnectableObservable.java | 23 ++++++++-
 .../java/rx/operators/OperatorMulticast.java  | 31 ++++++------
 .../operators/OperatorMulticastSelector.java  | 15 +++---
 .../java/rx/operators/OperatorReplayTest.java | 50 +++++++++++++++++++
 4 files changed, 95 insertions(+), 24 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
index c99332b342..7fab378503 100644
--- a/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/ConnectableObservable.java
@@ -18,6 +18,7 @@
 import rx.Observable;
 import rx.Subscriber;
 import rx.Subscription;
+import rx.functions.Action1;
 import rx.operators.OperatorRefCount;
 
 /**
@@ -44,10 +45,28 @@ protected ConnectableObservable(OnSubscribe<T> onSubscribe) {
     /**
      * Call a ConnectableObservable's connect() method to instruct it to begin emitting the
      * items from its underlying {@link Observable} to its {@link Subscriber}s.
+     * <p>To disconnect from a synchronous source, use the {@link #connect(rx.functions.Action1)}
+     * method.
      * @return the subscription representing the connection
      */
-    public abstract Subscription connect();
-
+    public final Subscription connect() {
+        final Subscription[] out = new Subscription[1];
+        connect(new Action1<Subscription>() {
+            @Override
+            public void call(Subscription t1) {
+                out[0] = t1;
+            }
+        });
+        return out[0];
+    }
+    /**
+     * Call a ConnectableObservable's connect() method to instruct it to begin emitting the
+     * items from its underlying {@link Observable} to its {@link Subscriber}s.
+     * @param connection the action that receives the connection subscription
+     * before the subscription to source happens allowing the caller
+     * to synchronously disconnect a synchronous source.
+     */
+    public abstract void connect(Action1<? super Subscription> connection);
     /**
      * Returns an observable sequence that stays connected to the source as long
      * as there is at least one subscription to the observable sequence.
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
index d51262538a..db57ccebd4 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMulticast.java
@@ -19,6 +19,7 @@
 import rx.Subscriber;
 import rx.Subscription;
 import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.observables.ConnectableObservable;
 import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
@@ -48,7 +49,20 @@ public void call(Subscriber<? super R> subscriber) {
     }
 
     @Override
-    public Subscription connect() {
+    public void connect(Action1<? super Subscription> connection) {
+        connection.call(Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                Subscription s;
+                synchronized (guard) {
+                    s = subscription;
+                    subscription = null;
+                }
+                if (s != null) {
+                    s.unsubscribe();
+                }
+            }
+        }));
         Subscriber<T> s = null;
         synchronized (guard) {
             if (subscription == null) {
@@ -74,20 +88,5 @@ public void onNext(T args) {
         if (s != null) {
             source.unsafeSubscribe(s);
         }
-
-        return Subscriptions.create(new Action0() {
-            @Override
-            public void call() {
-                Subscription s;
-                synchronized (guard) {
-                    s = subscription;
-                    subscription = null;
-                }
-                if (s != null) {
-                    s.unsubscribe();
-                }
-            }
-        });
     }
-    
 }
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java b/rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java
index 401d8a78ef..b5d3647c9e 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorMulticastSelector.java
@@ -18,12 +18,13 @@
 import rx.Observable;
 import rx.Observable.OnSubscribe;
 import rx.Subscriber;
+import rx.Subscription;
+import rx.functions.Action1;
 import rx.functions.Func0;
 import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
 import rx.observers.SafeSubscriber;
 import rx.subjects.Subject;
-import rx.subscriptions.CompositeSubscription;
 
 /**
  * Returns an observable sequence that contains the elements of a sequence
@@ -63,14 +64,16 @@ public void call(Subscriber<? super TResult> child) {
             return;
         }
         
-        CompositeSubscription csub = new CompositeSubscription();
-        child.add(csub);
-        
-        SafeSubscriber<TResult> s = new SafeSubscriber<TResult>(child);
+        final SafeSubscriber<TResult> s = new SafeSubscriber<TResult>(child);
         
         observable.unsafeSubscribe(s);
         
-        csub.add(connectable.connect());
+        connectable.connect(new Action1<Subscription>() {
+            @Override
+            public void call(Subscription t1) {
+                s.add(t1);
+            }
+        });
     }
     
 }
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
index 96a8645fe9..b52c6d22d9 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
@@ -24,13 +24,17 @@
 
 import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Assert;
+import static org.junit.Assert.assertEquals;
 import org.junit.Test;
 import org.mockito.InOrder;
 
 import rx.Observable;
 import rx.Observer;
+import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
 import rx.operators.OperatorReplay.VirtualBoundedList;
@@ -470,4 +474,50 @@ public void testWindowedReplayError() {
             verify(observer1, never()).onCompleted();
         }
     }
+    @Test
+    public void testSynchronousDisconnect() {
+        final AtomicInteger effectCounter = new AtomicInteger();
+        Observable<Integer> source = Observable.from(1, 2, 3, 4)
+        .doOnNext(new Action1<Integer>() {
+            @Override
+            public void call(Integer v) {
+                effectCounter.incrementAndGet();
+                System.out.println("Sideeffect #" + v);
+            }
+        });
+        
+        Observable<Integer> result = source.replay(
+        new Func1<Observable<Integer>, Observable<Integer>>() {
+            @Override
+            public Observable<Integer> call(Observable<Integer> o) {
+                return o.take(2);
+            }
+        });
+        
+        for (int i = 1; i < 3; i++) {
+            effectCounter.set(0);
+            System.out.printf("- %d -%n", i);
+            result.subscribe(new Action1<Integer>() {
+
+                @Override
+                public void call(Integer t1) {
+                    System.out.println(t1);
+                }
+                
+            }, new Action1<Throwable>() {
+
+                @Override
+                public void call(Throwable t1) {
+                    t1.printStackTrace();
+                }
+            }, 
+            new Action0() {
+                @Override
+                public void call() {
+                    System.out.println("Done");
+                }
+            });
+            assertEquals(2, effectCounter.get());
+        }
+    }
 }

From f15a6dd660a241736263254778bfeaa6d1657868 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 9 May 2014 08:36:32 +0200
Subject: [PATCH 361/422] GroubByUntil to use BufferUntilSubscriber

---
 .../rx/operators/BufferUntilSubscriber.java   |  8 +-
 .../rx/operators/OperatorGroupByUntil.java    |  2 +-
 .../operators/OperatorGroupByUntilTest.java   | 82 +++++++++++++++++--
 3 files changed, 82 insertions(+), 10 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
index dfade9ea49..f4db4baa5f 100644
--- a/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
+++ b/rxjava-core/src/main/java/rx/operators/BufferUntilSubscriber.java
@@ -19,11 +19,11 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
-import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Action0;
 import rx.observers.Subscribers;
+import rx.subjects.Subject;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -44,7 +44,7 @@
  *
  * @param <T>
  */
-public class BufferUntilSubscriber<T> extends Observable<T> implements Observer<T> {
+public class BufferUntilSubscriber<T> extends Subject<T, T> {
 
     public static <T> BufferUntilSubscriber<T> create() {
         State<T> state = new State<T>();
@@ -122,7 +122,7 @@ public void onNext(T t) {
      * It will then immediately swap itself out for the actual (after a single notification), but since this is now
      * being done on the same producer thread no further buffering will occur.
      */
-    private static class PassThruObserver<T> extends Subscriber<T> {
+    private static final class PassThruObserver<T> extends Subscriber<T> {
 
         private final Observer<? super T> actual;
         // this assumes single threaded synchronous notifications (the Rx contract for a single Observer)
@@ -166,7 +166,7 @@ private void drainIfNeededAndSwitchToActual() {
 
     }
 
-    private static class BufferedObserver<T> extends Subscriber<T> {
+    private static final class BufferedObserver<T> extends Subscriber<T> {
         private final ConcurrentLinkedQueue<Object> buffer = new ConcurrentLinkedQueue<Object>();
         private final NotificationLite<T> nl = NotificationLite.instance();
 
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorGroupByUntil.java b/rxjava-core/src/main/java/rx/operators/OperatorGroupByUntil.java
index caecd15440..d40ca81d93 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorGroupByUntil.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorGroupByUntil.java
@@ -197,7 +197,7 @@ public void onCompleted() {
     public static final class GroupSubject<K, R> extends Subscriber<R> {
         
         static <K, R> GroupSubject<K, R> create(K key) {
-            PublishSubject<R> publish = PublishSubject.create();
+            Subject<R, R> publish = BufferUntilSubscriber.create();
             return new GroupSubject<K, R>(key, publish);
         }
         
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByUntilTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByUntilTest.java
index b21121ecb6..e252c79f68 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByUntilTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByUntilTest.java
@@ -31,12 +31,15 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
+import static org.mockito.Matchers.anyInt;
 import org.mockito.Mock;
+import static org.mockito.Mockito.mock;
 import org.mockito.MockitoAnnotations;
 
 import rx.Observable;
 import rx.Observer;
 import rx.Subscriber;
+import rx.exceptions.TestException;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.functions.Functions;
@@ -283,14 +286,44 @@ public void call(GroupedObservable<Integer, Integer> t1) {
 
         inner.get().subscribe(observer);
 
-        verify(observer, times(1)).onCompleted();
+        verify(observer).onNext(0);
+        verify(observer).onCompleted();
         verify(observer, never()).onError(any(Throwable.class));
-        verify(observer, never()).onNext(any());
+    }
+
+    @Test
+    public void innerEscapeCompletedTwice() {
+        Observable<Integer> source = Observable.from(0);
+
+        final AtomicReference<GroupedObservable<Integer, Integer>> inner = new AtomicReference<GroupedObservable<Integer, Integer>>();
+
+        Func1<GroupedObservable<Integer, Integer>, Observable<Object>> duration = just(Observable.never());
+
+        Observable<GroupedObservable<Integer, Integer>> m = source.groupByUntil(identity, dbl, duration);
+
+        m.subscribe(new Action1<GroupedObservable<Integer, Integer>>() {
+            @Override
+            public void call(GroupedObservable<Integer, Integer> t1) {
+                inner.set(t1);
+            }
+        });
+
+        inner.get().subscribe(observer);
+        
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o2 = mock(Observer.class);
+        
+        inner.get().subscribe(o2);
+
+        verify(o2, never()).onCompleted();
+        verify(o2, never()).onNext(anyInt());
+        verify(o2).onError(any(IllegalStateException.class));
     }
 
     @Test
     public void innerEscapeError() {
-        Observable<Integer> source = Observable.concat(Observable.from(0), Observable.<Integer> error(new RuntimeException("Forced failure")));
+        Observable<Integer> source = Observable.concat(Observable.from(0), Observable.<Integer> error(
+                new TestException("Forced failure")));
 
         final AtomicReference<GroupedObservable<Integer, Integer>> inner = new AtomicReference<GroupedObservable<Integer, Integer>>();
 
@@ -316,8 +349,47 @@ public void onCompleted() {
 
         inner.get().subscribe(observer);
 
-        verify(observer, times(1)).onError(any(Throwable.class));
+        verify(observer).onNext(0);
+        verify(observer).onError(any(TestException.class));
         verify(observer, never()).onCompleted();
-        verify(observer, never()).onNext(any());
+    }
+    
+    @Test
+    public void innerEscapeErrorTwice() {
+        Observable<Integer> source = Observable.concat(Observable.from(0), Observable.<Integer> error(
+                new TestException("Forced failure")));
+
+        final AtomicReference<GroupedObservable<Integer, Integer>> inner = new AtomicReference<GroupedObservable<Integer, Integer>>();
+
+        Func1<GroupedObservable<Integer, Integer>, Observable<Object>> duration = just(Observable.never());
+
+        Observable<GroupedObservable<Integer, Integer>> m = source.groupByUntil(identity, dbl, duration);
+
+        m.subscribe(new Subscriber<GroupedObservable<Integer, Integer>>() {
+            @Override
+            public void onNext(GroupedObservable<Integer, Integer> t1) {
+                inner.set(t1);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+            }
+
+            @Override
+            public void onCompleted() {
+            }
+
+        });
+
+        inner.get().subscribe(observer);
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o2 = mock(Observer.class);
+        
+        inner.get().subscribe(o2);
+
+        verify(o2, never()).onCompleted();
+        verify(o2, never()).onNext(anyInt());
+        verify(o2).onError(any(IllegalStateException.class));
     }
 }
\ No newline at end of file

From 716de90cb35d8cf5e9cf05b84b41e50edb550557 Mon Sep 17 00:00:00 2001
From: Alexandre Mazari <alexandre.mazari@gmail.com>
Date: Fri, 9 May 2014 12:45:45 +0200
Subject: [PATCH 362/422] Add facilities for creating Observables from JavaFX
 events and ObservableValues.

Provides:
 * a Scheduler implementation ensuring execution in the JavaFX UI thread
 * a Subscription implementation ensuring that un-subscription happens in JavaFX UI thread
 * an Observable factory method for observing UI events on JavaFX nodes
 * an Observable factory method for observing value changes of a JavaFX ObservableValue

Also the rxjava-javafx is added to the gradle build.
---
 rxjava-contrib/rxjava-javafx/build.gradle     |  30 +++
 .../rx/javafx/sources/NodeEventSource.java    |  41 +++
 .../javafx/sources/ObservableValueSource.java |  42 +++
 .../java/rx/observables/JavaFxObservable.java |  53 ++++
 .../java/rx/schedulers/JavaFxScheduler.java   | 136 ++++++++++
 .../rx/subscriptions/JavaFxSubscriptions.java |  56 ++++
 .../rx/schedulers/JavaFxSchedulerTest.java    | 244 ++++++++++++++++++
 settings.gradle                               |   1 +
 8 files changed, 603 insertions(+)
 create mode 100644 rxjava-contrib/rxjava-javafx/build.gradle
 create mode 100644 rxjava-contrib/rxjava-javafx/src/main/java/rx/javafx/sources/NodeEventSource.java
 create mode 100644 rxjava-contrib/rxjava-javafx/src/main/java/rx/javafx/sources/ObservableValueSource.java
 create mode 100644 rxjava-contrib/rxjava-javafx/src/main/java/rx/observables/JavaFxObservable.java
 create mode 100644 rxjava-contrib/rxjava-javafx/src/main/java/rx/schedulers/JavaFxScheduler.java
 create mode 100644 rxjava-contrib/rxjava-javafx/src/main/java/rx/subscriptions/JavaFxSubscriptions.java
 create mode 100644 rxjava-contrib/rxjava-javafx/src/test/java/rx/schedulers/JavaFxSchedulerTest.java

diff --git a/rxjava-contrib/rxjava-javafx/build.gradle b/rxjava-contrib/rxjava-javafx/build.gradle
new file mode 100644
index 0000000000..2b08a63150
--- /dev/null
+++ b/rxjava-contrib/rxjava-javafx/build.gradle
@@ -0,0 +1,30 @@
+apply plugin: 'osgi'
+
+sourceCompatibility = JavaVersion.VERSION_1_6
+targetCompatibility = JavaVersion.VERSION_1_6
+
+dependencies {
+    compile project(':rxjava-core')
+    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 = '<h2 class="title" style="padding-top:40px">RxJava</h2>'
+}
+
+jar {
+    manifest {
+        name = 'rxjava-javafx'
+        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-javafx/src/main/java/rx/javafx/sources/NodeEventSource.java b/rxjava-contrib/rxjava-javafx/src/main/java/rx/javafx/sources/NodeEventSource.java
new file mode 100644
index 0000000000..d51fe4c7f4
--- /dev/null
+++ b/rxjava-contrib/rxjava-javafx/src/main/java/rx/javafx/sources/NodeEventSource.java
@@ -0,0 +1,41 @@
+package rx.javafx.sources;
+
+import javafx.event.Event;
+import javafx.event.EventHandler;
+import javafx.event.EventType;
+import javafx.scene.Node;
+import rx.Observable;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.schedulers.JavaFxScheduler;
+import rx.subscriptions.JavaFxSubscriptions;
+
+public class NodeEventSource {
+    /**
+     * @see rx.observables.JavaFxObservable#fromNodeEvents
+     */
+    public static <T extends Event> Observable<T> fromNodeEvents(final Node source, final EventType<T> eventType) {
+
+        return Observable.create(new Observable.OnSubscribe<T>() {
+            @Override
+            public void call(final Subscriber<? super T> subscriber) {
+                final EventHandler<T> handler = new EventHandler<T>() {
+                    @Override
+                    public void handle(T t) {
+                        subscriber.onNext(t);
+                    }
+                };
+
+                source.addEventHandler(eventType, handler);
+
+                subscriber.add(JavaFxSubscriptions.unsubscribeInEventDispatchThread(new Action0() {
+                    @Override
+                    public void call() {
+                        source.removeEventHandler(eventType, handler);
+                    }
+                }));
+            }
+
+        }).subscribeOn(JavaFxScheduler.getInstance());
+    }
+}
diff --git a/rxjava-contrib/rxjava-javafx/src/main/java/rx/javafx/sources/ObservableValueSource.java b/rxjava-contrib/rxjava-javafx/src/main/java/rx/javafx/sources/ObservableValueSource.java
new file mode 100644
index 0000000000..faac9c0e6e
--- /dev/null
+++ b/rxjava-contrib/rxjava-javafx/src/main/java/rx/javafx/sources/ObservableValueSource.java
@@ -0,0 +1,42 @@
+package rx.javafx.sources;
+
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import rx.Observable;
+import rx.Subscriber;
+import rx.functions.Action0;
+import rx.subscriptions.JavaFxSubscriptions;
+
+public class ObservableValueSource {
+
+    /**
+     * @see rx.observables.JavaFxObservable#fromObservableValue
+     */
+    public static <T> Observable<T> fromObservableValue(final ObservableValue<T> fxObservable) {
+        return Observable.create(new Observable.OnSubscribe<T>() {
+            @Override
+            public void call(final Subscriber<? super T> subscriber) {
+                subscriber.onNext(fxObservable.getValue());
+
+                final ChangeListener<T> listener = new ChangeListener<T>() {
+                    @Override
+                    public void changed(final ObservableValue<? extends T> observableValue, final T prev, final T current) {
+                        subscriber.onNext(current);
+                    }
+                };
+
+                fxObservable.addListener(listener);
+
+                subscriber.add(JavaFxSubscriptions.unsubscribeInEventDispatchThread(new Action0() {
+                    @Override
+                    public void call() {
+                        fxObservable.removeListener(listener);
+                    }
+                }));
+
+            }
+        });
+    }
+
+
+}
diff --git a/rxjava-contrib/rxjava-javafx/src/main/java/rx/observables/JavaFxObservable.java b/rxjava-contrib/rxjava-javafx/src/main/java/rx/observables/JavaFxObservable.java
new file mode 100644
index 0000000000..4beba5b55c
--- /dev/null
+++ b/rxjava-contrib/rxjava-javafx/src/main/java/rx/observables/JavaFxObservable.java
@@ -0,0 +1,53 @@
+/**
+ * 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.observables;
+
+
+import javafx.beans.value.ObservableValue;
+import javafx.event.Event;
+import javafx.event.EventType;
+import javafx.scene.Node;
+import rx.Observable;
+import rx.javafx.sources.NodeEventSource;
+import rx.javafx.sources.ObservableValueSource;
+
+
+public enum JavaFxObservable {
+    ; // no instances
+
+
+    /**
+     * Creates an observable corresponding to javafx ui events.
+     *
+     * @param node      The target of the UI events.
+     * @param eventType The type of the observed UI events
+     * @return An Observable of UI events, appropriately typed
+     */
+    public static <T extends Event> Observable<T> fromNodeEvents(final Node node, final EventType<T> eventType) {
+        return NodeEventSource.fromNodeEvents(node, eventType);
+    }
+
+    /**
+     * Create an rx Observable from a javafx ObservableValue
+     *
+     * @param fxObservable the observed ObservableValue
+     * @param <T>          the type of the observed value
+     * @return an Observable emitting values as the wrapped ObservableValue changes
+     */
+    public static <T> Observable<T> fromObservableValue(final ObservableValue<T> fxObservable) {
+        return ObservableValueSource.fromObservableValue(fxObservable);
+    }
+}
diff --git a/rxjava-contrib/rxjava-javafx/src/main/java/rx/schedulers/JavaFxScheduler.java b/rxjava-contrib/rxjava-javafx/src/main/java/rx/schedulers/JavaFxScheduler.java
new file mode 100644
index 0000000000..9196c5f0e7
--- /dev/null
+++ b/rxjava-contrib/rxjava-javafx/src/main/java/rx/schedulers/JavaFxScheduler.java
@@ -0,0 +1,136 @@
+/**
+ * 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.schedulers;
+
+import javafx.animation.KeyFrame;
+import javafx.animation.Timeline;
+import javafx.application.Platform;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.util.Duration;
+import rx.Scheduler;
+import rx.Subscription;
+import rx.functions.Action0;
+import rx.subscriptions.BooleanSubscription;
+import rx.subscriptions.CompositeSubscription;
+import rx.subscriptions.Subscriptions;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Executes work on the JavaFx UI thread.
+ * This scheduler should only be used with actions that execute quickly.
+ */
+public final class JavaFxScheduler extends Scheduler {
+    private static final JavaFxScheduler INSTANCE = new JavaFxScheduler();
+
+    /* package for unit test */JavaFxScheduler() {
+    }
+
+    public static JavaFxScheduler getInstance() {
+        return INSTANCE;
+    }
+
+    private static void assertThatTheDelayIsValidForTheJavaFxTimer(long delay) {
+        if (delay < 0 || delay > Integer.MAX_VALUE) {
+            throw new IllegalArgumentException(String.format("The JavaFx timer only accepts non-negative delays up to %d milliseconds.", Integer.MAX_VALUE));
+        }
+    }
+
+    @Override
+    public Worker createWorker() {
+        return new InnerJavaFxScheduler();
+    }
+
+    private static class InnerJavaFxScheduler extends Worker {
+
+        private final CompositeSubscription innerSubscription = new CompositeSubscription();
+
+        @Override
+        public void unsubscribe() {
+            innerSubscription.unsubscribe();
+        }
+
+        @Override
+        public boolean isUnsubscribed() {
+            return innerSubscription.isUnsubscribed();
+        }
+
+        @Override
+        public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
+            long delay = unit.toMillis(delayTime);
+            assertThatTheDelayIsValidForTheJavaFxTimer(delay);
+            final BooleanSubscription s = BooleanSubscription.create();
+
+            final Timeline timeline = new Timeline(new KeyFrame(Duration.millis(delay), new EventHandler<ActionEvent>() {
+
+                @Override
+                public void handle(ActionEvent event) {
+                    if (innerSubscription.isUnsubscribed() || s.isUnsubscribed()) {
+                        return;
+                    }
+                    action.call();
+                    innerSubscription.remove(s);
+                }
+            }));
+
+            timeline.setCycleCount(1);
+            timeline.play();
+
+            innerSubscription.add(s);
+
+            // wrap for returning so it also removes it from the 'innerSubscription'
+            return Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    timeline.stop();
+                    s.unsubscribe();
+                    innerSubscription.remove(s);
+                }
+
+            });
+        }
+
+        @Override
+        public Subscription schedule(final Action0 action) {
+            final BooleanSubscription s = BooleanSubscription.create();
+            Platform.runLater(new Runnable() {
+                @Override
+                public void run() {
+                    if (innerSubscription.isUnsubscribed() || s.isUnsubscribed()) {
+                        return;
+                    }
+                    action.call();
+                    innerSubscription.remove(s);
+                }
+            });
+
+            innerSubscription.add(s);
+            // wrap for returning so it also removes it from the 'innerSubscription'
+            return Subscriptions.create(new Action0() {
+
+                @Override
+                public void call() {
+                    s.unsubscribe();
+                    innerSubscription.remove(s);
+                }
+
+            });
+        }
+
+    }
+}
diff --git a/rxjava-contrib/rxjava-javafx/src/main/java/rx/subscriptions/JavaFxSubscriptions.java b/rxjava-contrib/rxjava-javafx/src/main/java/rx/subscriptions/JavaFxSubscriptions.java
new file mode 100644
index 0000000000..3767e39bd2
--- /dev/null
+++ b/rxjava-contrib/rxjava-javafx/src/main/java/rx/subscriptions/JavaFxSubscriptions.java
@@ -0,0 +1,56 @@
+/**
+ * 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.subscriptions;
+
+
+import javafx.application.Platform;
+import rx.Scheduler.Worker;
+import rx.Subscription;
+import rx.functions.Action0;
+import rx.schedulers.JavaFxScheduler;
+
+public final class JavaFxSubscriptions {
+
+    private JavaFxSubscriptions() {
+        // no instance
+    }
+
+    /**
+     * Create an Subscription that always runs <code>unsubscribe</code> in the event dispatch thread.
+     *
+     * @param unsubscribe the action to be performed in the ui thread at un-subscription
+     * @return an Subscription that always runs <code>unsubscribe</code> in the event dispatch thread.
+     */
+    public static Subscription unsubscribeInEventDispatchThread(final Action0 unsubscribe) {
+        return Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                if (Platform.isFxApplicationThread()) {
+                    unsubscribe.call();
+                } else {
+                    final Worker inner = JavaFxScheduler.getInstance().createWorker();
+                    inner.schedule(new Action0() {
+                        @Override
+                        public void call() {
+                            unsubscribe.call();
+                            inner.unsubscribe();
+                        }
+                    });
+                }
+            }
+        });
+    }
+}
diff --git a/rxjava-contrib/rxjava-javafx/src/test/java/rx/schedulers/JavaFxSchedulerTest.java b/rxjava-contrib/rxjava-javafx/src/test/java/rx/schedulers/JavaFxSchedulerTest.java
new file mode 100644
index 0000000000..5f7e10fd38
--- /dev/null
+++ b/rxjava-contrib/rxjava-javafx/src/test/java/rx/schedulers/JavaFxSchedulerTest.java
@@ -0,0 +1,244 @@
+/**
+ * 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.schedulers;
+
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.stage.Stage;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.InOrder;
+import rx.Scheduler.Worker;
+import rx.functions.Action0;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.*;
+
+/**
+ * Executes work on the JavaFx UI thread.
+ * This scheduler should only be used with actions that execute quickly.
+ */
+public final class JavaFxSchedulerTest {
+
+    @Rule
+    public ExpectedException exception = ExpectedException.none();
+
+    private static void waitForEmptyEventQueue() throws Exception {
+        FXUtilities.runAndWait(new Runnable() {
+            @Override
+            public void run() {
+                // nothing to do, we're just waiting here for the event queue to be emptied
+            }
+        });
+    }
+
+    public static class AsNonApp extends Application {
+        @Override
+        public void start(Stage primaryStage) throws Exception {
+            // noop
+        }
+    }
+
+    @BeforeClass
+    public static void initJFX() {
+        Thread t = new Thread("JavaFX Init Thread") {
+            public void run() {
+                Application.launch(AsNonApp.class, new String[0]);
+            }
+        };
+        t.setDaemon(true);
+        t.start();
+    }
+
+    @Test
+    public void testInvalidDelayValues() {
+        final JavaFxScheduler scheduler = new JavaFxScheduler();
+        final Worker inner = scheduler.createWorker();
+        final Action0 action = mock(Action0.class);
+
+        exception.expect(IllegalArgumentException.class);
+        inner.schedulePeriodically(action, -1L, 100L, TimeUnit.SECONDS);
+
+        exception.expect(IllegalArgumentException.class);
+        inner.schedulePeriodically(action, 100L, -1L, TimeUnit.SECONDS);
+
+        exception.expect(IllegalArgumentException.class);
+        inner.schedulePeriodically(action, 1L + Integer.MAX_VALUE, 100L, TimeUnit.MILLISECONDS);
+
+        exception.expect(IllegalArgumentException.class);
+        inner.schedulePeriodically(action, 100L, 1L + Integer.MAX_VALUE / 1000, TimeUnit.SECONDS);
+    }
+
+    @Test
+    public void testPeriodicScheduling() throws Exception {
+        final JavaFxScheduler scheduler = new JavaFxScheduler();
+        final Worker inner = scheduler.createWorker();
+
+        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(Platform.isFxApplicationThread());
+                } finally {
+                    latch.countDown();
+                }
+            }
+        };
+
+        inner.schedulePeriodically(action, 50, 200, TimeUnit.MILLISECONDS);
+
+        if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
+            fail("timed out waiting for tasks to execute");
+        }
+
+        inner.unsubscribe();
+        waitForEmptyEventQueue();
+        verify(innerAction, times(4)).call();
+    }
+
+    @Test
+    public void testNestedActions() throws Exception {
+        final JavaFxScheduler scheduler = new JavaFxScheduler();
+        final Worker inner = scheduler.createWorker();
+
+        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(Platform.isFxApplicationThread());
+                firstStepStart.call();
+                firstStepEnd.call();
+            }
+        };
+        final Action0 secondAction = new Action0() {
+            @Override
+            public void call() {
+                assertTrue(Platform.isFxApplicationThread());
+                secondStepStart.call();
+                inner.schedule(firstAction);
+                secondStepEnd.call();
+            }
+        };
+        final Action0 thirdAction = new Action0() {
+            @Override
+            public void call() {
+                assertTrue(Platform.isFxApplicationThread());
+                thirdStepStart.call();
+                inner.schedule(secondAction);
+                thirdStepEnd.call();
+            }
+        };
+
+        InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd);
+
+        inner.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();
+    }
+
+    /*
+     * based on http://www.guigarage.com/2013/01/invokeandwait-for-javafx/
+     * by hendrikebbers
+     */
+    static public class FXUtilities {
+
+        /**
+         * Simple helper class.
+         *
+         * @author hendrikebbers
+         */
+        private static class ThrowableWrapper {
+            Throwable t;
+        }
+
+        /**
+         * Invokes a Runnable in JFX Thread and waits while it's finished. Like
+         * SwingUtilities.invokeAndWait does for EDT.
+         *
+         * @param run The Runnable that has to be called on JFX thread.
+         * @throws InterruptedException f the execution is interrupted.
+         * @throws ExecutionException   If a exception is occurred in the run method of the Runnable
+         */
+        public static void runAndWait( final Runnable run) throws InterruptedException, ExecutionException {
+            if (Platform.isFxApplicationThread()) {
+                try {
+                    run.run();
+                } catch (Exception e) {
+                    throw new ExecutionException(e);
+                }
+            } else {
+                final Lock lock = new ReentrantLock();
+                final Condition condition = lock.newCondition();
+                final ThrowableWrapper throwableWrapper = new ThrowableWrapper();
+                lock.lock();
+                try {
+                    Platform.runLater(new Runnable() {
+
+                        @Override
+                        public void run() {
+                            lock.lock();
+                            try {
+                                run.run();
+                            } catch (Throwable e) {
+                                throwableWrapper.t = e;
+                            } finally {
+                                try {
+                                    condition.signal();
+                                } finally {
+                                    lock.unlock();
+                                }
+                            }
+                        }
+                    });
+                    condition.await();
+                    if (throwableWrapper.t != null) {
+                        throw new ExecutionException(throwableWrapper.t);
+                    }
+                } finally {
+                    lock.unlock();
+                }
+            }
+        }
+    }
+}
diff --git a/settings.gradle b/settings.gradle
index 913516f575..48c277fbf6 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -6,6 +6,7 @@ include 'rxjava-core', \
 'language-adaptors:rxjava-scala', \
 'language-adaptors:rxjava-kotlin', \
 'rxjava-contrib:rxjava-swing', \
+'rxjava-contrib:rxjava-javafx', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-android-samples-build-wrapper', \
 'rxjava-contrib:rxjava-apache-http', \

From 91d54a7ad96dd8909d7726e43c5f96385be1c7d9 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 9 May 2014 18:44:39 +0200
Subject: [PATCH 363/422] Switch to direct accept and no instanceof

---
 .../java/rx/operators/NotificationLite.java   | 23 +++++++++++--------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/NotificationLite.java b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
index d94fcd40c8..025ba98df9 100644
--- a/rxjava-core/src/main/java/rx/operators/NotificationLite.java
+++ b/rxjava-core/src/main/java/rx/operators/NotificationLite.java
@@ -111,17 +111,22 @@ public Object error(Throwable e) {
      * @throws NullPointerException
      *             if the {@link Observer} is null.
      */
+    @SuppressWarnings("unchecked")
     public void accept(Observer<? super T> o, Object n) {
-        switch (kind(n)) {
-        case OnNext:
-            o.onNext(getValue(n));
-            break;
-        case OnCompleted:
+        if (n == ON_COMPLETED_SENTINEL) {
             o.onCompleted();
-            break;
-        case OnError:
-            o.onError(getError(n));
-            break;
+        } else
+        if (n == ON_NEXT_NULL_SENTINEL) {
+            o.onNext(null);
+        } else
+        if (n != null) {
+            if (n.getClass() == OnErrorSentinel.class) {
+                o.onError(((OnErrorSentinel)n).e);
+            } else {
+                o.onNext((T)n);
+            }
+        } else {
+            throw new IllegalArgumentException("The lite notification can not be null");
         }
     }
 

From cb60dd4bf72a806ab4609db8ae86fecb9e87e521 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Fri, 9 May 2014 10:56:11 -0700
Subject: [PATCH 364/422] Version 0.18.3

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

diff --git a/CHANGES.md b/CHANGES.md
index 49ae3853e3..31e703ad39 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,13 @@
 # RxJava Releases #
 
+### Version 0.18.3 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.3%22)) ###
+
+* [Pull 1161] (https://github.com/Netflix/RxJava/pull/1161) Removed use of deprecated API from tests & operators
+* [Pull 1162] (https://github.com/Netflix/RxJava/pull/1162) fix to remove drift from schedulePeriodic
+* [Pull 1159] (https://github.com/Netflix/RxJava/pull/1159) Rxscala improvement
+* [Pull 1164] (https://github.com/Netflix/RxJava/pull/1164) JMH Perf Tests for Schedulers.computation
+* [Pull 1158] (https://github.com/Netflix/RxJava/pull/1158) Scheduler correctness improvements.
+
 ### Version 0.18.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.2%22)) ###
 
 

From 4bb777c63a38d9e962766a0d7b612e6d8f73e980 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 9 May 2014 11:45:19 +0200
Subject: [PATCH 365/422] BehaviorSubject subscription timegap fix

---
 .../java/rx/subjects/BehaviorSubject.java     | 195 ++++++++++++++++--
 .../subjects/SubjectSubscriptionManager.java  |   4 +-
 .../java/rx/subjects/BehaviorSubjectTest.java |  65 ++++++
 3 files changed, 241 insertions(+), 23 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index c6c3214afa..d64bc93683 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -15,11 +15,14 @@
  */
 package rx.subjects;
 
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Notification;
 import rx.Observer;
+import rx.Subscriber;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
@@ -66,27 +69,40 @@
  * @param <T>
  */
 public final class BehaviorSubject<T> extends Subject<T, T> {
-
+    /**
+     * Create a {@link BehaviorSubject} without a default value.
+     * @param <T> the value type
+     * @return the constructed {@link BehaviorSubject}
+     */
+    public static <T> BehaviorSubject<T> create() {
+        return create(null, false);
+    }
     /**
      * Creates a {@link BehaviorSubject} which publishes the last and all subsequent events to each {@link Observer} that subscribes to it.
      * 
+     * @param <T> the value type
      * @param defaultValue
      *            the value which will be published to any {@link Observer} as long as the {@link BehaviorSubject} has not yet received any events
      * @return the constructed {@link BehaviorSubject}
      */
     public static <T> BehaviorSubject<T> create(T defaultValue) {
+        return create(defaultValue, true);
+    }
+    private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault) {
         final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
         // set a default value so subscriptions will immediately receive this until a new notification is received
-        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>(Notification.createOnNext(defaultValue));
+        final State<T> state = new State<T>();
+        if (hasDefault) {
+            state.lastNotification.set(Notification.createOnNext(defaultValue));
+        }
 
-        OnSubscribe<T> onSubscribe = subscriptionManager.getOnSubscribeFunc(
+        final OnSubscribe<T> onSubscribeBase = subscriptionManager.getOnSubscribeFunc(
                 /**
                  * This function executes at beginning of subscription.
                  * 
                  * This will always run, even if Subject is in terminal state.
                  */
                 new Action1<SubjectObserver<? super T>>() {
-
                     @Override
                     public void call(SubjectObserver<? super T> o) {
                         /*
@@ -94,37 +110,159 @@ public void call(SubjectObserver<? super T> o) {
                          * 
                          * Here we only emit if it's an onNext as terminal states are handled in the next function.
                          */
-                        Notification<T> n = lastNotification.get();
-                        if (n.isOnNext()) {
-                            n.accept(o);
-                        }
+                        state.addPending(o);
                     }
                 },
                 /**
                  * This function executes if the Subject is terminated before subscription occurs.
                  */
                 new Action1<SubjectObserver<? super T>>() {
-
                     @Override
                     public void call(SubjectObserver<? super T> 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);
+                        state.removePending(o);
                     }
-                }, null);
+                }, new Action1<SubjectObserver<? super T>>() {
+                    @Override
+                    public void call(SubjectObserver<? super T> o) {
+                        state.removePending(o);
+                    }
+                    
+                });
+        OnSubscribe<T> onSubscribe = new OnSubscribe<T>() {
 
-        return new BehaviorSubject<T>(onSubscribe, subscriptionManager, lastNotification);
+            @Override
+            public void call(Subscriber<? super T> t1) {
+                onSubscribeBase.call(t1);
+                state.removePendingSubscriber(t1);
+            }
+        };
+        return new BehaviorSubject<T>(onSubscribe, subscriptionManager, state);
     }
 
+    static final class State<T> {
+        final AtomicReference<Notification<T>> lastNotification;
+        /** Guarded by this. */
+        List<Object> pendingSubscriptions;
+        public State() {
+            this.lastNotification = new AtomicReference<Notification<T>>();
+        }
+        public void addPending(SubjectObserver<? super T> subscriber) {
+            synchronized (this) {
+                if (pendingSubscriptions == null) {
+                    pendingSubscriptions = new ArrayList<Object>(4);
+                }
+                pendingSubscriptions.add(subscriber);
+                List<Notification<T>> list = new ArrayList<Notification<T>>(4);
+                list.add(lastNotification.get());
+                pendingSubscriptions.add(list);
+            }
+        }
+        public void bufferValue(Notification<T> value) {
+            synchronized (this) {
+                if (pendingSubscriptions == null) {
+                    return;
+                }
+                for (int i = 1; i < pendingSubscriptions.size(); i += 2) {
+                    @SuppressWarnings("unchecked")
+                    List<Notification<T>> list = (List<Notification<T>>)pendingSubscriptions.get(i);
+                    list.add(value);
+                }
+            }
+        }
+        public void removePending(SubjectObserver<? super T> subscriber) {
+            List<Notification<T>> toCatchUp = null;
+            synchronized (this) {
+                if (pendingSubscriptions == null) {
+                    return;
+                }
+                int idx = pendingSubscriptions.indexOf(subscriber);
+                if (idx >= 0) {
+                    pendingSubscriptions.remove(idx);
+                    @SuppressWarnings("unchecked")
+                    List<Notification<T>> list = (List<Notification<T>>)pendingSubscriptions.remove(idx);
+                    toCatchUp = list;
+                    subscriber.caughtUp = true;
+                    if (pendingSubscriptions.isEmpty()) {
+                        pendingSubscriptions = null;
+                    }
+                }
+            }
+            if (toCatchUp != null) {
+                for (Notification<T> n : toCatchUp) {
+                    if (n != null) {
+                        n.accept(subscriber);
+                    }
+                }
+            }
+        }
+        public void removePendingSubscriber(Subscriber<? super T> subscriber) {
+            List<Notification<T>> toCatchUp = null;
+            synchronized (this) {
+                if (pendingSubscriptions == null) {
+                    return;
+                }
+                for (int i = 0; i < pendingSubscriptions.size(); i += 2) {
+                    @SuppressWarnings("unchecked")
+                    SubjectObserver<? super T> so = (SubjectObserver<? super T>)pendingSubscriptions.get(i);
+                    if (so.getActual() == subscriber && !so.caughtUp) {
+                        @SuppressWarnings("unchecked")
+                        List<Notification<T>> list = (List<Notification<T>>)pendingSubscriptions.get(i + 1);
+                        toCatchUp = list;
+                        so.caughtUp = true;
+                        pendingSubscriptions.remove(i);
+                        pendingSubscriptions.remove(i);
+                        if (pendingSubscriptions.isEmpty()) {
+                            pendingSubscriptions = null;
+                        }
+                        break;
+                    }
+                }
+            }
+            if (toCatchUp != null) {
+                for (Notification<T> n : toCatchUp) {
+                    if (n != null) {
+                        n.accept(subscriber);
+                    }
+                }
+            }
+        }
+        public void replayAllPending() {
+            List<Object> localPending;
+            synchronized (this) {
+                localPending = pendingSubscriptions;
+                pendingSubscriptions = null;
+            }
+            if (localPending != null) {
+                for (int i = 0; i < localPending.size(); i += 2) {
+                    @SuppressWarnings("unchecked")
+                    SubjectObserver<? super T> so = (SubjectObserver<? super T>)localPending.get(i);
+                    if (!so.caughtUp) {
+                        @SuppressWarnings("unchecked")
+                        List<Notification<T>> list = (List<Notification<T>>)localPending.get(i + 1);
+                        for (Notification<T> v : list) {
+                            if (v != null) {
+                                v.accept(so);
+                            }
+                        }
+                        so.caughtUp = true;
+                    }
+                }
+            }
+        }
+    }
+    
+    private final State<T> state;
     private final SubjectSubscriptionManager<T> subscriptionManager;
-    final AtomicReference<Notification<T>> lastNotification;
 
-    protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, AtomicReference<Notification<T>> lastNotification) {
+    protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, 
+            State<T> state) {
         super(onSubscribe);
         this.subscriptionManager = subscriptionManager;
-        this.lastNotification = lastNotification;
+        this.state = state;
     }
 
     @Override
@@ -133,10 +271,13 @@ public void onCompleted() {
 
             @Override
             public void call() {
-                lastNotification.set(Notification.<T> createOnCompleted());
+                final Notification<T> ne = Notification.<T>createOnCompleted();
+                state.bufferValue(ne);
+                state.lastNotification.set(ne);
             }
         });
         if (observers != null) {
+            state.replayAllPending();
             for (Observer<? super T> o : observers) {
                 o.onCompleted();
             }
@@ -149,10 +290,13 @@ public void onError(final Throwable e) {
 
             @Override
             public void call() {
-                lastNotification.set(Notification.<T> createOnError(e));
+                final Notification<T> ne = Notification.<T>createOnError(e);
+                state.bufferValue(ne);
+                state.lastNotification.set(ne);
             }
         });
         if (observers != null) {
+            state.replayAllPending();
             for (Observer<? super T> o : observers) {
                 o.onError(e);
             }
@@ -163,12 +307,19 @@ public void call() {
     public void onNext(T v) {
         // do not overwrite a terminal notification
         // so new subscribers can get them
-        if (lastNotification.get().isOnNext()) {
-            lastNotification.set(Notification.createOnNext(v));
-            for (Observer<? super T> o : subscriptionManager.rawSnapshot()) {
-                o.onNext(v);
+        Notification<T> last = state.lastNotification.get();
+        if (last == null || last.isOnNext()) {
+            Notification<T> n = Notification.createOnNext(v);
+            state.bufferValue(n);
+            state.lastNotification.set(n);
+            
+            for (SubjectObserver<? super T> o : subscriptionManager.rawSnapshot()) {
+                if (o.caughtUp) {
+                    o.onNext(v);
+                } else {
+                    state.removePending(o);
+                }
             }
         }
     }
-
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 7efbafb64b..3fa57ee691 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -260,7 +260,9 @@ public void onError(Throwable e) {
         public void onNext(T v) {
             this.actual.onNext(v);
         }
-
+        Observer<? super T> getActual() {
+            return actual;
+        }
     }
 
 }
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index 739fbe2966..8f8df8dc86 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -285,4 +285,69 @@ public void onCompleted() {
             verify(o, never()).onError(any(Throwable.class));
         }
     }
+    @Test
+    public void testStartEmpty() {
+        BehaviorSubject<Integer> source = BehaviorSubject.create();
+        @SuppressWarnings("unchecked")
+        final Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+        
+        source.subscribe(o);
+        
+        inOrder.verify(o, never()).onNext(any());
+        inOrder.verify(o, never()).onCompleted();
+        
+        source.onNext(1);
+        
+        source.onCompleted();
+        
+        source.onNext(2);
+        
+        inOrder.verify(o).onNext(1);
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    @Test
+    public void testStartEmptyThenAddOne() {
+        BehaviorSubject<Integer> source = BehaviorSubject.create();
+        @SuppressWarnings("unchecked")
+        final Observer<Object> o = mock(Observer.class);
+        InOrder inOrder = inOrder(o);
+
+        source.onNext(1);
+
+        source.subscribe(o);
+
+        inOrder.verify(o).onNext(1);
+
+        source.onCompleted();
+
+        source.onNext(2);
+
+        inOrder.verify(o).onCompleted();
+        inOrder.verifyNoMoreInteractions();
+        
+        verify(o, never()).onError(any(Throwable.class));
+        
+    }
+    @Test
+    public void testStartEmptyCompleteWithOne() {
+        BehaviorSubject<Integer> source = BehaviorSubject.create();
+        @SuppressWarnings("unchecked")
+        final Observer<Object> o = mock(Observer.class);
+
+        source.onNext(1);
+        source.onCompleted();
+
+        source.onNext(2);
+
+        source.subscribe(o);
+
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+        verify(o, never()).onNext(any());
+    }
 }

From 265090cf3b1433a0ccaa19f5348189ceafa6a66c Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 9 May 2014 16:06:13 +0200
Subject: [PATCH 366/422] BehaviorSubject subscription timegap fix 2

---
 .../java/rx/subjects/BehaviorSubject.java     | 411 ++++++++++--------
 .../java/rx/subjects/BehaviorSubjectTest.java |  16 +
 2 files changed, 241 insertions(+), 186 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index d64bc93683..44d4777633 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -15,17 +15,15 @@
  */
 package rx.subjects;
 
+
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
-
 import rx.Notification;
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
+import rx.subscriptions.Subscriptions;
 
 /**
  * Subject that publishes the most recent and all subsequent events to each subscribed {@link Observer}.
@@ -68,6 +66,7 @@
  * 
  * @param <T>
  */
+@SuppressWarnings({ "unchecked", "rawtypes" })
 public final class BehaviorSubject<T> extends Subject<T, T> {
     /**
      * Create a {@link BehaviorSubject} without a default value.
@@ -89,236 +88,276 @@ public static <T> BehaviorSubject<T> create(T defaultValue) {
         return create(defaultValue, true);
     }
     private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault) {
-        final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
-        // set a default value so subscriptions will immediately receive this until a new notification is received
-        final State<T> state = new State<T>();
+        State<T> state = new State<T>();
         if (hasDefault) {
-            state.lastNotification.set(Notification.createOnNext(defaultValue));
+            state.set(Notification.createOnNext(defaultValue));
         }
-
-        final OnSubscribe<T> onSubscribeBase = subscriptionManager.getOnSubscribeFunc(
-                /**
-                 * This function executes at beginning of subscription.
-                 * 
-                 * This will always run, even if Subject is in terminal state.
-                 */
-                new Action1<SubjectObserver<? super T>>() {
-                    @Override
-                    public void call(SubjectObserver<? super T> 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.
-                         */
-                        state.addPending(o);
-                    }
-                },
-                /**
-                 * This function executes if the Subject is terminated before subscription occurs.
-                 */
-                new Action1<SubjectObserver<? super T>>() {
-                    @Override
-                    public void call(SubjectObserver<? super T> 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.
-                         */
-                        state.removePending(o);
-                    }
-                }, new Action1<SubjectObserver<? super T>>() {
-                    @Override
-                    public void call(SubjectObserver<? super T> o) {
-                        state.removePending(o);
-                    }
-                    
-                });
-        OnSubscribe<T> onSubscribe = new OnSubscribe<T>() {
-
-            @Override
-            public void call(Subscriber<? super T> t1) {
-                onSubscribeBase.call(t1);
-                state.removePendingSubscriber(t1);
-            }
-        };
-        return new BehaviorSubject<T>(onSubscribe, subscriptionManager, state);
+        return new BehaviorSubject<T>(new BehaviorOnSubscribe<T>(state), state); 
     }
 
     static final class State<T> {
-        final AtomicReference<Notification<T>> lastNotification;
-        /** Guarded by this. */
-        List<Object> pendingSubscriptions;
-        public State() {
-            this.lastNotification = new AtomicReference<Notification<T>>();
+        final AtomicReference<Notification<T>> latest = new AtomicReference<Notification<T>>();
+        final AtomicReference<BehaviorState> observers = new AtomicReference<BehaviorState>(BehaviorState.EMPTY);
+        void set(Notification<T> value) {
+            this.latest.set(value);
         }
-        public void addPending(SubjectObserver<? super T> subscriber) {
-            synchronized (this) {
-                if (pendingSubscriptions == null) {
-                    pendingSubscriptions = new ArrayList<Object>(4);
-                }
-                pendingSubscriptions.add(subscriber);
-                List<Notification<T>> list = new ArrayList<Notification<T>>(4);
-                list.add(lastNotification.get());
-                pendingSubscriptions.add(list);
-            }
+        Notification<T> get() {
+            return latest.get();
         }
-        public void bufferValue(Notification<T> value) {
-            synchronized (this) {
-                if (pendingSubscriptions == null) {
-                    return;
+        BehaviorObserver<T>[] observers() {
+            return observers.get().observers;
+        }
+        boolean add(BehaviorObserver<T> o) {
+            do {
+                BehaviorState oldState = observers.get();
+                if (oldState.terminated) {
+                    o.emitFirst(get());
+                    return false;
                 }
-                for (int i = 1; i < pendingSubscriptions.size(); i += 2) {
-                    @SuppressWarnings("unchecked")
-                    List<Notification<T>> list = (List<Notification<T>>)pendingSubscriptions.get(i);
-                    list.add(value);
+                BehaviorState newState = oldState.add(o);
+                if (observers.compareAndSet(oldState, newState)) {
+                    o.emitFirst(get());
+                    return true;
                 }
-            }
+            } while (true);
         }
-        public void removePending(SubjectObserver<? super T> subscriber) {
-            List<Notification<T>> toCatchUp = null;
-            synchronized (this) {
-                if (pendingSubscriptions == null) {
+        void remove(BehaviorObserver<T> o) {
+            do {
+                BehaviorState oldState = observers.get();
+                if (oldState.terminated) {
                     return;
                 }
-                int idx = pendingSubscriptions.indexOf(subscriber);
-                if (idx >= 0) {
-                    pendingSubscriptions.remove(idx);
-                    @SuppressWarnings("unchecked")
-                    List<Notification<T>> list = (List<Notification<T>>)pendingSubscriptions.remove(idx);
-                    toCatchUp = list;
-                    subscriber.caughtUp = true;
-                    if (pendingSubscriptions.isEmpty()) {
-                        pendingSubscriptions = null;
-                    }
-                }
-            }
-            if (toCatchUp != null) {
-                for (Notification<T> n : toCatchUp) {
-                    if (n != null) {
-                        n.accept(subscriber);
-                    }
+                BehaviorState newState = oldState.remove(o);
+                if (newState == oldState || observers.compareAndSet(oldState, newState)) {
+                    return;
                 }
-            }
+            } while (true);
         }
-        public void removePendingSubscriber(Subscriber<? super T> subscriber) {
-            List<Notification<T>> toCatchUp = null;
-            synchronized (this) {
-                if (pendingSubscriptions == null) {
-                    return;
+        BehaviorObserver<T>[] next(Notification<T> n) {
+            set(n);
+            return observers.get().observers;
+        }
+        BehaviorObserver<T>[] terminate(Notification<T> n) {
+            set(n);
+            do {
+                BehaviorState oldState = observers.get();
+                if (oldState.terminated) {
+                    return BehaviorState.NO_OBSERVERS;
                 }
-                for (int i = 0; i < pendingSubscriptions.size(); i += 2) {
-                    @SuppressWarnings("unchecked")
-                    SubjectObserver<? super T> so = (SubjectObserver<? super T>)pendingSubscriptions.get(i);
-                    if (so.getActual() == subscriber && !so.caughtUp) {
-                        @SuppressWarnings("unchecked")
-                        List<Notification<T>> list = (List<Notification<T>>)pendingSubscriptions.get(i + 1);
-                        toCatchUp = list;
-                        so.caughtUp = true;
-                        pendingSubscriptions.remove(i);
-                        pendingSubscriptions.remove(i);
-                        if (pendingSubscriptions.isEmpty()) {
-                            pendingSubscriptions = null;
-                        }
-                        break;
-                    }
+                if (observers.compareAndSet(oldState, BehaviorState.TERMINATED)) {
+                    return oldState.observers;
                 }
+            } while (true);
+        }
+    }
+    static final class BehaviorState {
+        final boolean terminated;
+        final BehaviorObserver[] observers;
+        static final BehaviorObserver[] NO_OBSERVERS = new BehaviorObserver[0];
+        static final BehaviorState TERMINATED = new BehaviorState(true, NO_OBSERVERS);
+        static final BehaviorState EMPTY = new BehaviorState(false, NO_OBSERVERS);
+
+        public BehaviorState(boolean terminated, BehaviorObserver[] observers) {
+            this.terminated = terminated;
+            this.observers = observers;
+        }
+        public BehaviorState add(BehaviorObserver o) {
+            int n = observers.length;
+            BehaviorObserver[] a = new BehaviorObserver[n + 1];
+            System.arraycopy(observers, 0, a, 0, n);
+            a[n] = o;
+            return new BehaviorState(terminated, a);
+        }
+        public BehaviorState remove(BehaviorObserver o) {
+            BehaviorObserver[] a = observers;
+            int n = a.length;
+            if (n == 1 && a[0] == o) {
+                return EMPTY;
+            } else
+            if (n == 0) {
+                return this;
             }
-            if (toCatchUp != null) {
-                for (Notification<T> n : toCatchUp) {
-                    if (n != null) {
-                        n.accept(subscriber);
+            BehaviorObserver[] b = new BehaviorObserver[n - 1];
+            int j = 0;
+            for (int i = 0; i < n; i++) {
+                BehaviorObserver ai = a[i];
+                if (ai != o) {
+                    if (j == n - 1) {
+                        return this;
                     }
+                    b[j++] = ai;
                 }
             }
+            if (j == 0) {
+                return EMPTY;
+            }
+            if (j < n - 1) {
+                BehaviorObserver[] c = new BehaviorObserver[j];
+                System.arraycopy(b, 0, c, 0, j);
+                b = c;
+            }
+            return new BehaviorState(terminated, b);
         }
-        public void replayAllPending() {
-            List<Object> localPending;
-            synchronized (this) {
-                localPending = pendingSubscriptions;
-                pendingSubscriptions = null;
+    }
+    
+    static final class BehaviorOnSubscribe<T> implements OnSubscribe<T> {
+        private final State<T> state;
+
+        public BehaviorOnSubscribe(State<T> state) {
+            this.state = state;
+        }
+
+        @Override
+        public void call(final Subscriber<? super T> child) {
+            BehaviorObserver<T> bo = new BehaviorObserver<T>(child);
+            addUnsubscriber(child, bo);
+            if (state.add(bo) && child.isUnsubscribed()) {
+                state.remove(bo);
             }
-            if (localPending != null) {
-                for (int i = 0; i < localPending.size(); i += 2) {
-                    @SuppressWarnings("unchecked")
-                    SubjectObserver<? super T> so = (SubjectObserver<? super T>)localPending.get(i);
-                    if (!so.caughtUp) {
-                        @SuppressWarnings("unchecked")
-                        List<Notification<T>> list = (List<Notification<T>>)localPending.get(i + 1);
-                        for (Notification<T> v : list) {
-                            if (v != null) {
-                                v.accept(so);
-                            }
-                        }
-                        so.caughtUp = true;
-                    }
+        }
+    
+        void addUnsubscriber(Subscriber<? super T> child, final BehaviorObserver<T> bo) {
+            child.add(Subscriptions.create(new Action0() {
+                @Override
+                public void call() {
+                    state.remove(bo);
                 }
-            }
+            }));
         }
     }
     
+    
     private final State<T> state;
-    private final SubjectSubscriptionManager<T> subscriptionManager;
 
-    protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, 
-            State<T> state) {
+    protected BehaviorSubject(OnSubscribe<T> onSubscribe, State<T> state) {
         super(onSubscribe);
-        this.subscriptionManager = subscriptionManager;
         this.state = state;
     }
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-
-            @Override
-            public void call() {
-                final Notification<T> ne = Notification.<T>createOnCompleted();
-                state.bufferValue(ne);
-                state.lastNotification.set(ne);
-            }
-        });
-        if (observers != null) {
-            state.replayAllPending();
-            for (Observer<? super T> o : observers) {
-                o.onCompleted();
+        Notification<T> last = state.get();
+        if (last == null || last.isOnNext()) {
+            Notification<T> n = Notification.<T>createOnCompleted();
+            for (BehaviorObserver<T> bo : state.terminate(n)) {
+                bo.emitNext(n);
             }
         }
     }
 
     @Override
-    public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-
-            @Override
-            public void call() {
-                final Notification<T> ne = Notification.<T>createOnError(e);
-                state.bufferValue(ne);
-                state.lastNotification.set(ne);
-            }
-        });
-        if (observers != null) {
-            state.replayAllPending();
-            for (Observer<? super T> o : observers) {
-                o.onError(e);
+    public void onError(Throwable e) {
+        Notification<T> last = state.get();
+        if (last == null || last.isOnNext()) {
+            Notification<T> n = Notification.<T>createOnError(e);
+            for (BehaviorObserver<T> bo : state.terminate(n)) {
+                bo.emitNext(n);
             }
         }
     }
 
     @Override
     public void onNext(T v) {
-        // do not overwrite a terminal notification
-        // so new subscribers can get them
-        Notification<T> last = state.lastNotification.get();
+        Notification<T> last = state.get();
         if (last == null || last.isOnNext()) {
             Notification<T> n = Notification.createOnNext(v);
-            state.bufferValue(n);
-            state.lastNotification.set(n);
-            
-            for (SubjectObserver<? super T> o : subscriptionManager.rawSnapshot()) {
-                if (o.caughtUp) {
-                    o.onNext(v);
-                } else {
-                    state.removePending(o);
+            for (BehaviorObserver<T> bo : state.next(n)) {
+                bo.emitNext(n);
+            }
+        }
+    }
+    
+    /* test support */ int subscriberCount() {
+        return state.observers.get().observers.length;
+    }
+    
+    private static final class BehaviorObserver<T> {
+        final Observer<? super T> actual;
+        /** Guarded by this. */
+        boolean first = true;
+        /** Guarded by this. */
+        boolean emitting;
+        /** Guarded by this. */
+        List<Notification<T>> queue;
+        /** Accessed only from serialized state. */
+        boolean done;
+        volatile boolean fastPath;
+        public BehaviorObserver(Observer<? super T> actual) {
+            this.actual = actual;
+        }
+        void emitNext(Notification<T> n) {
+            if (fastPath) {
+                accept(n);
+                return;
+            }
+            List<Notification<T>> localQueue;
+            synchronized (this) {
+                first = false;
+                if (emitting) {
+                    if (queue == null) {
+                        queue = new ArrayList<Notification<T>>();
+                    }
+                    queue.add(n);
+                    return;
+                }
+                emitting = true;
+                localQueue = queue;
+                queue = null;
+            }
+            fastPath = true;
+            emitLoop(localQueue, n);
+        }
+        void emitFirst(Notification<T> n) {
+            List<Notification<T>> localQueue;
+            synchronized (this) {
+                if (!first || emitting) {
+                    return;
+                }
+                first = false;
+                emitting = true;
+                localQueue = queue;
+                queue = null;
+            }
+            emitLoop(localQueue, n);
+        }
+        void emitLoop(List<Notification<T>> localQueue, Notification<T> current) {
+            boolean once = true;
+            boolean skipFinal = false;
+            try {
+                do {
+                    if (localQueue != null) {
+                        for (Notification<T> n : localQueue) {
+                            accept(n);
+                        }
+                    }
+                    if (once) {
+                        once = false;
+                        accept(current);
+                    }
+                    synchronized (this) {
+                        localQueue = queue;
+                        queue = null;
+                        if (localQueue == null) {
+                            emitting = false;
+                            skipFinal = true;
+                            break;
+                        }
+                    }
+                } while (true);
+            } finally {
+                if (!skipFinal) {
+                    synchronized (this) {
+                        emitting = false;
+                    }
+                }
+            }
+        }
+        void accept(Notification<T> n) {
+            if (n != null && !done) {
+                if (!n.isOnNext()) {
+                    done = true;
                 }
+                n.accept(actual);
             }
         }
     }
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index 8f8df8dc86..c1a1607236 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -15,6 +15,7 @@
  */
 package rx.subjects;
 
+import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
@@ -350,4 +351,19 @@ public void testStartEmptyCompleteWithOne() {
         verify(o, never()).onError(any(Throwable.class));
         verify(o, never()).onNext(any());
     }
+    
+    @Test
+    public void testTakeOneSubscriber() {
+        BehaviorSubject<Integer> source = BehaviorSubject.create(1);
+        @SuppressWarnings("unchecked")
+        final Observer<Object> o = mock(Observer.class);
+        
+        source.take(1).subscribe(o);
+        
+        verify(o).onNext(1);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+        
+        assertEquals(0, source.subscriberCount());
+    }
 }

From 5454879efa0c6f4effa9cbf20cc3d6f8a66427e4 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 9 May 2014 16:35:48 +0200
Subject: [PATCH 367/422] Going lite

---
 .../java/rx/subjects/BehaviorSubject.java     | 88 +++++++++----------
 1 file changed, 42 insertions(+), 46 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 44d4777633..3a997a7ce7 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -19,10 +19,10 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
-import rx.Notification;
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Action0;
+import rx.operators.NotificationLite;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -90,18 +90,18 @@ public static <T> BehaviorSubject<T> create(T defaultValue) {
     private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault) {
         State<T> state = new State<T>();
         if (hasDefault) {
-            state.set(Notification.createOnNext(defaultValue));
+            state.set(NotificationLite.instance().next(defaultValue));
         }
         return new BehaviorSubject<T>(new BehaviorOnSubscribe<T>(state), state); 
     }
 
     static final class State<T> {
-        final AtomicReference<Notification<T>> latest = new AtomicReference<Notification<T>>();
+        final AtomicReference<Object> latest = new AtomicReference<Object>();
         final AtomicReference<BehaviorState> observers = new AtomicReference<BehaviorState>(BehaviorState.EMPTY);
-        void set(Notification<T> value) {
+        void set(Object value) {
             this.latest.set(value);
         }
-        Notification<T> get() {
+        Object get() {
             return latest.get();
         }
         BehaviorObserver<T>[] observers() {
@@ -133,11 +133,11 @@ void remove(BehaviorObserver<T> o) {
                 }
             } while (true);
         }
-        BehaviorObserver<T>[] next(Notification<T> n) {
+        BehaviorObserver<T>[] next(Object n) {
             set(n);
             return observers.get().observers;
         }
-        BehaviorObserver<T>[] terminate(Notification<T> n) {
+        BehaviorObserver<T>[] terminate(Object n) {
             set(n);
             do {
                 BehaviorState oldState = observers.get();
@@ -149,6 +149,9 @@ BehaviorObserver<T>[] terminate(Notification<T> n) {
                 }
             } while (true);
         }
+        boolean isActive() {
+            return !observers.get().terminated;
+        }
     }
     static final class BehaviorState {
         final boolean terminated;
@@ -228,6 +231,7 @@ public void call() {
     
     
     private final State<T> state;
+    private final NotificationLite<T> nl = NotificationLite.instance();
 
     protected BehaviorSubject(OnSubscribe<T> onSubscribe, State<T> state) {
         super(onSubscribe);
@@ -236,9 +240,9 @@ protected BehaviorSubject(OnSubscribe<T> onSubscribe, State<T> state) {
 
     @Override
     public void onCompleted() {
-        Notification<T> last = state.get();
-        if (last == null || last.isOnNext()) {
-            Notification<T> n = Notification.<T>createOnCompleted();
+        Object last = state.get();
+        if (last == null || state.isActive()) {
+            Object n = nl.completed();
             for (BehaviorObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
             }
@@ -247,9 +251,9 @@ public void onCompleted() {
 
     @Override
     public void onError(Throwable e) {
-        Notification<T> last = state.get();
-        if (last == null || last.isOnNext()) {
-            Notification<T> n = Notification.<T>createOnError(e);
+        Object last = state.get();
+        if (last == null || state.isActive()) {
+            Object n = nl.error(e);
             for (BehaviorObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
             }
@@ -258,9 +262,9 @@ public void onError(Throwable e) {
 
     @Override
     public void onNext(T v) {
-        Notification<T> last = state.get();
-        if (last == null || last.isOnNext()) {
-            Notification<T> n = Notification.createOnNext(v);
+        Object last = state.get();
+        if (last == null || state.isActive()) {
+            Object n = nl.next(v);
             for (BehaviorObserver<T> bo : state.next(n)) {
                 bo.emitNext(n);
             }
@@ -273,60 +277,52 @@ public void onNext(T v) {
     
     private static final class BehaviorObserver<T> {
         final Observer<? super T> actual;
+        final NotificationLite<T> nl = NotificationLite.instance();
         /** Guarded by this. */
         boolean first = true;
         /** Guarded by this. */
         boolean emitting;
         /** Guarded by this. */
-        List<Notification<T>> queue;
+        List<Object> queue;
         /** Accessed only from serialized state. */
         boolean done;
-        volatile boolean fastPath;
+        /* volatile */boolean fastPath;
         public BehaviorObserver(Observer<? super T> actual) {
             this.actual = actual;
         }
-        void emitNext(Notification<T> n) {
-            if (fastPath) {
-                accept(n);
-                return;
-            }
-            List<Notification<T>> localQueue;
-            synchronized (this) {
-                first = false;
-                if (emitting) {
-                    if (queue == null) {
-                        queue = new ArrayList<Notification<T>>();
+        void emitNext(Object n) {
+            if (!fastPath) {
+                synchronized (this) {
+                    first = false;
+                    if (emitting) {
+                        if (queue == null) {
+                            queue = new ArrayList<Object>();
+                        }
+                        queue.add(n);
+                        return;
                     }
-                    queue.add(n);
-                    return;
                 }
-                emitting = true;
-                localQueue = queue;
-                queue = null;
+                fastPath = true;
             }
-            fastPath = true;
-            emitLoop(localQueue, n);
+            nl.accept(actual, n);
         }
-        void emitFirst(Notification<T> n) {
-            List<Notification<T>> localQueue;
+        void emitFirst(Object n) {
             synchronized (this) {
                 if (!first || emitting) {
                     return;
                 }
                 first = false;
                 emitting = true;
-                localQueue = queue;
-                queue = null;
             }
-            emitLoop(localQueue, n);
+            emitLoop(null, n);
         }
-        void emitLoop(List<Notification<T>> localQueue, Notification<T> current) {
+        void emitLoop(List<Object> localQueue, Object current) {
             boolean once = true;
             boolean skipFinal = false;
             try {
                 do {
                     if (localQueue != null) {
-                        for (Notification<T> n : localQueue) {
+                        for (Object n : localQueue) {
                             accept(n);
                         }
                     }
@@ -352,12 +348,12 @@ void emitLoop(List<Notification<T>> localQueue, Notification<T> current) {
                 }
             }
         }
-        void accept(Notification<T> n) {
+        void accept(Object n) {
             if (n != null && !done) {
-                if (!n.isOnNext()) {
+                if (nl.isCompleted(n) || nl.isError(n)) {
                     done = true;
                 }
-                n.accept(actual);
+                nl.accept(actual, n);
             }
         }
     }

From 26cd9dd8ed3597e4791dc921b3aa4715fbbcfb84 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Fri, 9 May 2014 16:58:32 +0200
Subject: [PATCH 368/422] Some performance improvements

---
 .../main/java/rx/subjects/BehaviorSubject.java | 18 ++++++------------
 .../java/rx/subjects/BehaviorSubjectTest.java  |  3 ++-
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 3a997a7ce7..ae20d129f2 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -98,6 +98,7 @@ private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault)
     static final class State<T> {
         final AtomicReference<Object> latest = new AtomicReference<Object>();
         final AtomicReference<BehaviorState> observers = new AtomicReference<BehaviorState>(BehaviorState.EMPTY);
+        boolean active = true;
         void set(Object value) {
             this.latest.set(value);
         }
@@ -139,6 +140,7 @@ BehaviorObserver<T>[] next(Object n) {
         }
         BehaviorObserver<T>[] terminate(Object n) {
             set(n);
+            active = false;
             do {
                 BehaviorState oldState = observers.get();
                 if (oldState.terminated) {
@@ -149,9 +151,6 @@ BehaviorObserver<T>[] terminate(Object n) {
                 }
             } while (true);
         }
-        boolean isActive() {
-            return !observers.get().terminated;
-        }
     }
     static final class BehaviorState {
         final boolean terminated;
@@ -241,7 +240,7 @@ protected BehaviorSubject(OnSubscribe<T> onSubscribe, State<T> state) {
     @Override
     public void onCompleted() {
         Object last = state.get();
-        if (last == null || state.isActive()) {
+        if (last == null || state.active) {
             Object n = nl.completed();
             for (BehaviorObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
@@ -252,7 +251,7 @@ public void onCompleted() {
     @Override
     public void onError(Throwable e) {
         Object last = state.get();
-        if (last == null || state.isActive()) {
+        if (last == null || state.active) {
             Object n = nl.error(e);
             for (BehaviorObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
@@ -263,7 +262,7 @@ public void onError(Throwable e) {
     @Override
     public void onNext(T v) {
         Object last = state.get();
-        if (last == null || state.isActive()) {
+        if (last == null || state.active) {
             Object n = nl.next(v);
             for (BehaviorObserver<T> bo : state.next(n)) {
                 bo.emitNext(n);
@@ -284,8 +283,6 @@ private static final class BehaviorObserver<T> {
         boolean emitting;
         /** Guarded by this. */
         List<Object> queue;
-        /** Accessed only from serialized state. */
-        boolean done;
         /* volatile */boolean fastPath;
         public BehaviorObserver(Observer<? super T> actual) {
             this.actual = actual;
@@ -349,10 +346,7 @@ void emitLoop(List<Object> localQueue, Object current) {
             }
         }
         void accept(Object n) {
-            if (n != null && !done) {
-                if (nl.isCompleted(n) || nl.isError(n)) {
-                    done = true;
-                }
+            if (n != null) {
                 nl.accept(actual, n);
             }
         }
diff --git a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
index c1a1607236..58197c5f97 100644
--- a/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/BehaviorSubjectTest.java
@@ -304,11 +304,12 @@ public void testStartEmpty() {
         
         source.onNext(2);
         
+        verify(o, never()).onError(any(Throwable.class));
+
         inOrder.verify(o).onNext(1);
         inOrder.verify(o).onCompleted();
         inOrder.verifyNoMoreInteractions();
         
-        verify(o, never()).onError(any(Throwable.class));
         
     }
     @Test

From d27b8c7791b6d76474b8d9cda42a7e1ecc7f03f6 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Fri, 9 May 2014 20:45:20 +0200
Subject: [PATCH 369/422] PublishSubject to match BehaviorSubject

---
 .../java/rx/subjects/BehaviorSubject.java     |  2 +-
 .../main/java/rx/subjects/PublishSubject.java | 90 +++++--------------
 2 files changed, 24 insertions(+), 68 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index ae20d129f2..9647c4ceeb 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -274,7 +274,7 @@ public void onNext(T v) {
         return state.observers.get().observers.length;
     }
     
-    private static final class BehaviorObserver<T> {
+    static final class BehaviorObserver<T> {
         final Observer<? super T> actual;
         final NotificationLite<T> nl = NotificationLite.instance();
         /** Guarded by this. */
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 998385a741..53918e7899 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -15,14 +15,10 @@
  */
 package rx.subjects;
 
-import java.util.Collection;
-import java.util.concurrent.atomic.AtomicReference;
-
-import rx.Notification;
 import rx.Observer;
-import rx.functions.Action0;
-import rx.functions.Action1;
-import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
+import rx.operators.NotificationLite;
+import rx.subjects.BehaviorSubject.BehaviorOnSubscribe;
+import rx.subjects.BehaviorSubject.State;
 
 /**
  * Subject that, once and {@link Observer} has subscribed, publishes all subsequent events to the subscriber.
@@ -50,85 +46,45 @@
 public final class PublishSubject<T> extends Subject<T, T> {
 
     public static <T> PublishSubject<T> create() {
-        final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
-        // set a default value so subscriptions will immediately receive this until a new notification is received
-        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>();
-
-        OnSubscribe<T> onSubscribe = subscriptionManager.getOnSubscribeFunc(
-                /**
-                 * This function executes at beginning of subscription.
-                 * 
-                 * This will always run, even if Subject is in terminal state.
-                 */
-                new Action1<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> 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<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> 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);
-                    }
-                }, null);
-
-        return new PublishSubject<T>(onSubscribe, subscriptionManager, lastNotification);
+        State<T> state = new State<T>();
+        return new PublishSubject<T>(new BehaviorOnSubscribe<T>(state), state);
     }
 
-    private final SubjectSubscriptionManager<T> subscriptionManager;
-    final AtomicReference<Notification<T>> lastNotification;
-
-    protected PublishSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, AtomicReference<Notification<T>> lastNotification) {
+    final State<T> state;
+    private final NotificationLite<T> nl = NotificationLite.instance();
+    
+    protected PublishSubject(OnSubscribe<T> onSubscribe, State<T> state) {
         super(onSubscribe);
-        this.subscriptionManager = subscriptionManager;
-        this.lastNotification = lastNotification;
+        this.state = state;
     }
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-            @Override
-            public void call() {
-                lastNotification.set(Notification.<T> createOnCompleted());
-            }
-        });
-        if (observers != null) {
-            for (Observer<? super T> o : observers) {
-                o.onCompleted();
+        Object last = state.get();
+        if (last == null || state.active) {
+            Object n = nl.completed();
+            for (BehaviorSubject.BehaviorObserver<T> bo : state.terminate(n)) {
+                bo.emitNext(n);
             }
         }
+
     }
 
     @Override
     public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-
-            @Override
-            public void call() {
-                lastNotification.set(Notification.<T> createOnError(e));
-            }
-        });
-        if (observers != null) {
-            for (Observer<? super T> o : observers) {
-                o.onError(e);
+        Object last = state.get();
+        if (last == null || state.active) {
+            Object n = nl.error(e);
+            for (BehaviorSubject.BehaviorObserver<T> bo : state.terminate(n)) {
+                bo.emitNext(n);
             }
         }
     }
 
     @Override
     public void onNext(T v) {
-        for (Observer<? super T> o : subscriptionManager.rawSnapshot()) {
-            o.onNext(v);
+        for (BehaviorSubject.BehaviorObserver<T> bo : state.observers()) {
+            bo.emitNext(nl.next(v));
         }
     }
 }
\ No newline at end of file

From 1b88781653cde78650f34eabe1f07e53560b0880 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Sat, 10 May 2014 00:30:31 +0200
Subject: [PATCH 370/422] Unified the Subject management.

---
 .../main/java/rx/subjects/AsyncSubject.java   |  97 ++--
 .../java/rx/subjects/BehaviorSubject.java     | 238 +--------
 .../main/java/rx/subjects/PublishSubject.java |  35 +-
 .../main/java/rx/subjects/ReplaySubject.java  | 111 ++--
 .../subjects/SubjectSubscriptionManager.java  | 504 ++++++++++--------
 .../main/java/rx/subjects/TestSubject.java    |  87 +--
 6 files changed, 420 insertions(+), 652 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index f95ab6e216..a1a65d7c5b 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -15,13 +15,9 @@
  */
 package rx.subjects;
 
-import java.util.Collection;
-import java.util.concurrent.atomic.AtomicReference;
-
-import rx.Notification;
 import rx.Observer;
-import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.operators.NotificationLite;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
 /**
@@ -56,88 +52,59 @@
 public final class AsyncSubject<T> extends Subject<T, T> {
 
     public static <T> AsyncSubject<T> create() {
-        final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
-        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>(Notification.<T>createOnCompleted());
-
-        OnSubscribe<T> onSubscribe = subscriptionManager.getOnSubscribeFunc(
-                /**
-                 * This function executes at beginning of subscription.
-                 * 
-                 * This will always run, even if Subject is in terminal state.
-                 */
-                new Action1<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> o) {
-                        // nothing to do if not terminated
-                    }
-                },
-                /**
-                 * This function executes if the Subject is terminated.
-                 */
-                new Action1<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> 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);
-                    }
-                }, null);
-
-        return new AsyncSubject<T>(onSubscribe, subscriptionManager, lastNotification);
+        final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>();
+        state.onTerminated = new Action1<SubjectObserver<T>>() {
+            @Override
+            public void call(SubjectObserver<T> o) {
+                Object v = state.get();
+                o.accept(v);
+                o.completeSingle(v);
+            }
+        };
+        return new AsyncSubject<T>(state, state);
     }
 
-    protected static <T> void emitValueToObserver(Notification<T> n, Observer<? super T> o) {
-        n.accept(o);
-        if (n.isOnNext()) {
-            o.onCompleted();
-        }
-    }
+    final SubjectSubscriptionManager<T> state;
+    volatile Object lastValue;
+    private final NotificationLite<T> nl = NotificationLite.instance();
 
-    private final SubjectSubscriptionManager<T> subscriptionManager;
-    final AtomicReference<Notification<T>> lastNotification;
 
-    protected AsyncSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, AtomicReference<Notification<T>> lastNotification) {
+    protected AsyncSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
         super(onSubscribe);
-        this.subscriptionManager = subscriptionManager;
-        this.lastNotification = lastNotification;
+        this.state = state;
     }
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-
-            @Override
-            public void call() {
+        if (state.active) {
+            Object last = lastValue;
+            if (last == null) {
+                last = nl.completed();
             }
-        });
-        if (observers != null) {
-            for (Observer<? super T> o : observers) {
-                emitValueToObserver(lastNotification.get(), o);
+            for (SubjectObserver<T> bo : state.terminate(last)) {
+                if (last == nl.completed()) {
+                    bo.onCompleted();
+                } else {
+                    bo.onNext(nl.getValue(last));
+                    bo.onCompleted();
+                }
             }
         }
     }
 
     @Override
     public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-            @Override
-            public void call() {
-                lastNotification.set(Notification.<T> createOnError(e));
-            }
-        });
-        if (observers != null) {
-            for (Observer<? super T> o : observers) {
-                emitValueToObserver(lastNotification.get(), o);
+        if (state.active) {
+            Object n = nl.error(e);
+            for (SubjectObserver<T> bo : state.terminate(n)) {
+                bo.onError(e);
             }
         }
-
     }
 
     @Override
     public void onNext(T v) {
-        lastNotification.set(Notification.createOnNext(v));
+        lastValue = nl.next(v);
     }
 
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 9647c4ceeb..78efdc0edf 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -16,13 +16,12 @@
 package rx.subjects;
 
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicReference;
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Action0;
+import rx.functions.Action1;
 import rx.operators.NotificationLite;
+import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 import rx.subscriptions.Subscriptions;
 
 /**
@@ -88,151 +87,26 @@ public static <T> BehaviorSubject<T> create(T defaultValue) {
         return create(defaultValue, true);
     }
     private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault) {
-        State<T> state = new State<T>();
+        final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>();
         if (hasDefault) {
             state.set(NotificationLite.instance().next(defaultValue));
         }
-        return new BehaviorSubject<T>(new BehaviorOnSubscribe<T>(state), state); 
-    }
-
-    static final class State<T> {
-        final AtomicReference<Object> latest = new AtomicReference<Object>();
-        final AtomicReference<BehaviorState> observers = new AtomicReference<BehaviorState>(BehaviorState.EMPTY);
-        boolean active = true;
-        void set(Object value) {
-            this.latest.set(value);
-        }
-        Object get() {
-            return latest.get();
-        }
-        BehaviorObserver<T>[] observers() {
-            return observers.get().observers;
-        }
-        boolean add(BehaviorObserver<T> o) {
-            do {
-                BehaviorState oldState = observers.get();
-                if (oldState.terminated) {
-                    o.emitFirst(get());
-                    return false;
-                }
-                BehaviorState newState = oldState.add(o);
-                if (observers.compareAndSet(oldState, newState)) {
-                    o.emitFirst(get());
-                    return true;
-                }
-            } while (true);
-        }
-        void remove(BehaviorObserver<T> o) {
-            do {
-                BehaviorState oldState = observers.get();
-                if (oldState.terminated) {
-                    return;
-                }
-                BehaviorState newState = oldState.remove(o);
-                if (newState == oldState || observers.compareAndSet(oldState, newState)) {
-                    return;
-                }
-            } while (true);
-        }
-        BehaviorObserver<T>[] next(Object n) {
-            set(n);
-            return observers.get().observers;
-        }
-        BehaviorObserver<T>[] terminate(Object n) {
-            set(n);
-            active = false;
-            do {
-                BehaviorState oldState = observers.get();
-                if (oldState.terminated) {
-                    return BehaviorState.NO_OBSERVERS;
-                }
-                if (observers.compareAndSet(oldState, BehaviorState.TERMINATED)) {
-                    return oldState.observers;
-                }
-            } while (true);
-        }
-    }
-    static final class BehaviorState {
-        final boolean terminated;
-        final BehaviorObserver[] observers;
-        static final BehaviorObserver[] NO_OBSERVERS = new BehaviorObserver[0];
-        static final BehaviorState TERMINATED = new BehaviorState(true, NO_OBSERVERS);
-        static final BehaviorState EMPTY = new BehaviorState(false, NO_OBSERVERS);
+        state.onAdded = new Action1<SubjectObserver<T>>() {
 
-        public BehaviorState(boolean terminated, BehaviorObserver[] observers) {
-            this.terminated = terminated;
-            this.observers = observers;
-        }
-        public BehaviorState add(BehaviorObserver o) {
-            int n = observers.length;
-            BehaviorObserver[] a = new BehaviorObserver[n + 1];
-            System.arraycopy(observers, 0, a, 0, n);
-            a[n] = o;
-            return new BehaviorState(terminated, a);
-        }
-        public BehaviorState remove(BehaviorObserver o) {
-            BehaviorObserver[] a = observers;
-            int n = a.length;
-            if (n == 1 && a[0] == o) {
-                return EMPTY;
-            } else
-            if (n == 0) {
-                return this;
-            }
-            BehaviorObserver[] b = new BehaviorObserver[n - 1];
-            int j = 0;
-            for (int i = 0; i < n; i++) {
-                BehaviorObserver ai = a[i];
-                if (ai != o) {
-                    if (j == n - 1) {
-                        return this;
-                    }
-                    b[j++] = ai;
-                }
-            }
-            if (j == 0) {
-                return EMPTY;
-            }
-            if (j < n - 1) {
-                BehaviorObserver[] c = new BehaviorObserver[j];
-                System.arraycopy(b, 0, c, 0, j);
-                b = c;
+            @Override
+            public void call(SubjectObserver<T> o) {
+                o.emitFirst(state.get());
             }
-            return new BehaviorState(terminated, b);
-        }
+            
+        };
+        state.onTerminated = state.onAdded;
+        return new BehaviorSubject<T>(state, state); 
     }
-    
-    static final class BehaviorOnSubscribe<T> implements OnSubscribe<T> {
-        private final State<T> state;
-
-        public BehaviorOnSubscribe(State<T> state) {
-            this.state = state;
-        }
 
-        @Override
-        public void call(final Subscriber<? super T> child) {
-            BehaviorObserver<T> bo = new BehaviorObserver<T>(child);
-            addUnsubscriber(child, bo);
-            if (state.add(bo) && child.isUnsubscribed()) {
-                state.remove(bo);
-            }
-        }
-    
-        void addUnsubscriber(Subscriber<? super T> child, final BehaviorObserver<T> bo) {
-            child.add(Subscriptions.create(new Action0() {
-                @Override
-                public void call() {
-                    state.remove(bo);
-                }
-            }));
-        }
-    }
-    
-    
-    private final State<T> state;
+    private final SubjectSubscriptionManager<T> state;
     private final NotificationLite<T> nl = NotificationLite.instance();
 
-    protected BehaviorSubject(OnSubscribe<T> onSubscribe, State<T> state) {
+    protected BehaviorSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
         super(onSubscribe);
         this.state = state;
     }
@@ -242,7 +116,7 @@ public void onCompleted() {
         Object last = state.get();
         if (last == null || state.active) {
             Object n = nl.completed();
-            for (BehaviorObserver<T> bo : state.terminate(n)) {
+            for (SubjectObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
             }
         }
@@ -253,7 +127,7 @@ public void onError(Throwable e) {
         Object last = state.get();
         if (last == null || state.active) {
             Object n = nl.error(e);
-            for (BehaviorObserver<T> bo : state.terminate(n)) {
+            for (SubjectObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
             }
         }
@@ -264,91 +138,13 @@ public void onNext(T v) {
         Object last = state.get();
         if (last == null || state.active) {
             Object n = nl.next(v);
-            for (BehaviorObserver<T> bo : state.next(n)) {
+            for (SubjectObserver<T> bo : state.next(n)) {
                 bo.emitNext(n);
             }
         }
     }
     
     /* test support */ int subscriberCount() {
-        return state.observers.get().observers.length;
-    }
-    
-    static final class BehaviorObserver<T> {
-        final Observer<? super T> actual;
-        final NotificationLite<T> nl = NotificationLite.instance();
-        /** Guarded by this. */
-        boolean first = true;
-        /** Guarded by this. */
-        boolean emitting;
-        /** Guarded by this. */
-        List<Object> queue;
-        /* volatile */boolean fastPath;
-        public BehaviorObserver(Observer<? super T> actual) {
-            this.actual = actual;
-        }
-        void emitNext(Object n) {
-            if (!fastPath) {
-                synchronized (this) {
-                    first = false;
-                    if (emitting) {
-                        if (queue == null) {
-                            queue = new ArrayList<Object>();
-                        }
-                        queue.add(n);
-                        return;
-                    }
-                }
-                fastPath = true;
-            }
-            nl.accept(actual, n);
-        }
-        void emitFirst(Object n) {
-            synchronized (this) {
-                if (!first || emitting) {
-                    return;
-                }
-                first = false;
-                emitting = true;
-            }
-            emitLoop(null, n);
-        }
-        void emitLoop(List<Object> localQueue, Object current) {
-            boolean once = true;
-            boolean skipFinal = false;
-            try {
-                do {
-                    if (localQueue != null) {
-                        for (Object n : localQueue) {
-                            accept(n);
-                        }
-                    }
-                    if (once) {
-                        once = false;
-                        accept(current);
-                    }
-                    synchronized (this) {
-                        localQueue = queue;
-                        queue = null;
-                        if (localQueue == null) {
-                            emitting = false;
-                            skipFinal = true;
-                            break;
-                        }
-                    }
-                } while (true);
-            } finally {
-                if (!skipFinal) {
-                    synchronized (this) {
-                        emitting = false;
-                    }
-                }
-            }
-        }
-        void accept(Object n) {
-            if (n != null) {
-                nl.accept(actual, n);
-            }
-        }
+        return state.observers().length;
     }
 }
diff --git a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
index 53918e7899..82e76172f6 100644
--- a/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/PublishSubject.java
@@ -16,9 +16,9 @@
 package rx.subjects;
 
 import rx.Observer;
+import rx.functions.Action1;
 import rx.operators.NotificationLite;
-import rx.subjects.BehaviorSubject.BehaviorOnSubscribe;
-import rx.subjects.BehaviorSubject.State;
+import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
 /**
  * Subject that, once and {@link Observer} has subscribed, publishes all subsequent events to the subscriber.
@@ -46,24 +46,32 @@
 public final class PublishSubject<T> extends Subject<T, T> {
 
     public static <T> PublishSubject<T> create() {
-        State<T> state = new State<T>();
-        return new PublishSubject<T>(new BehaviorOnSubscribe<T>(state), state);
+        final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>();
+        state.onAdded = new Action1<SubjectObserver<T>>() {
+
+            @Override
+            public void call(SubjectObserver<T> o) {
+                o.emitFirst(state.get());
+            }
+            
+        };
+        state.onTerminated = state.onAdded;
+        return new PublishSubject<T>(state, state);
     }
 
-    final State<T> state;
+    final SubjectSubscriptionManager<T> state;
     private final NotificationLite<T> nl = NotificationLite.instance();
     
-    protected PublishSubject(OnSubscribe<T> onSubscribe, State<T> state) {
+    protected PublishSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state) {
         super(onSubscribe);
         this.state = state;
     }
 
     @Override
     public void onCompleted() {
-        Object last = state.get();
-        if (last == null || state.active) {
+        if (state.active) {
             Object n = nl.completed();
-            for (BehaviorSubject.BehaviorObserver<T> bo : state.terminate(n)) {
+            for (SubjectObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
             }
         }
@@ -72,10 +80,9 @@ public void onCompleted() {
 
     @Override
     public void onError(final Throwable e) {
-        Object last = state.get();
-        if (last == null || state.active) {
+        if (state.active) {
             Object n = nl.error(e);
-            for (BehaviorSubject.BehaviorObserver<T> bo : state.terminate(n)) {
+            for (SubjectObserver<T> bo : state.terminate(n)) {
                 bo.emitNext(n);
             }
         }
@@ -83,8 +90,8 @@ public void onError(final Throwable e) {
 
     @Override
     public void onNext(T v) {
-        for (BehaviorSubject.BehaviorObserver<T> bo : state.observers()) {
-            bo.emitNext(nl.next(v));
+        for (SubjectObserver<T> bo : state.observers()) {
+            bo.onNext(v);
         }
     }
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 3277219351..8bfb77be5d 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -16,12 +16,10 @@
 package rx.subjects;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import rx.Observer;
-import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.operators.NotificationLite;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
@@ -57,46 +55,33 @@ public static <T> ReplaySubject<T> create() {
     public static <T> ReplaySubject<T> create(int initialCapacity) {
         final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
         final ReplayState<T> state = new ReplayState<T>(initialCapacity);
+        subscriptionManager.onStart = new Action1<SubjectObserver<T>>() {
+            @Override
+            public void call(SubjectObserver<T> o) {
+                // replay history for this observer using the subscribing thread
+                int lastIndex = replayObserverFromIndex(state.history, 0, o);
 
-        OnSubscribe<T> 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<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> o) {
-                        // replay history for this observer using the subscribing thread
-                        int lastIndex = replayObserverFromIndex(state.history, 0, o);
-
-                        // now that it is caught up add to observers
-                        state.replayState.put(o, lastIndex);
-                    }
-                },
-                /**
-                 * This function executes if the Subject is terminated.
-                 */
-                new Action1<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> o) {
-                        Integer idx = state.replayState.remove(o);
-                        // we will finish replaying if there is anything left
-                        replayObserverFromIndex(state.history, idx, o);
-                    }
-                },
-                new Action1<SubjectObserver<? super T>>() {
-                    @Override
-                    public void call(SubjectObserver<? super T> o) {
-                        state.replayState.remove(o);
-                    }
-                });
-
-        return new ReplaySubject<T>(onSubscribe, subscriptionManager, state);
+                // now that it is caught up add to observers
+                state.replayState.put(o, lastIndex);
+            }
+        };
+        subscriptionManager.onTerminated = new Action1<SubjectObserver<T>>() {
+            @Override
+            public void call(SubjectObserver<T> o) {
+                Integer idx = state.replayState.remove(o);
+                if (idx == null) {
+                    idx = 0;
+                }
+                replayObserverFromIndex(state.history, idx, o);
+            }
+        };
+        subscriptionManager.onUnsubscribed = new Action1<SubjectObserver<T>>() {
+            @Override
+            public void call(SubjectObserver<T> o) {
+                state.replayState.remove(o);
+            }
+        };
+        return new ReplaySubject<T>(subscriptionManager, subscriptionManager, state);
     }
 
     private static class ReplayState<T> {
@@ -122,15 +107,10 @@ protected ReplaySubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T
 
     @Override
     public void onCompleted() {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
 
-            @Override
-            public void call() {
-                state.history.complete();
-            }
-        });
-        if (observers != null) {
-            for (SubjectObserver<? super T> o : observers) {
+        if (subscriptionManager.active) {
+            state.history.complete();
+            for (SubjectObserver<T> o : subscriptionManager.terminate(NotificationLite.instance().completed())) {
                 if (caughtUp(o)) {
                     o.onCompleted();
                 }
@@ -140,15 +120,9 @@ public void call() {
 
     @Override
     public void onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-
-            @Override
-            public void call() {
-                state.history.complete(e);
-            }
-        });
-        if (observers != null) {
-            for (SubjectObserver<? super T> o : observers) {
+        if (subscriptionManager.active) {
+            state.history.complete(e);
+            for (SubjectObserver<T> o : subscriptionManager.terminate(NotificationLite.instance().completed())) {
                 if (caughtUp(o)) {
                     o.onError(e);
                 }
@@ -162,7 +136,7 @@ public void onNext(T v) {
             return;
         }
         state.history.next(v);
-        for (SubjectObserver<? super T> o : subscriptionManager.rawSnapshot()) {
+        for (SubjectObserver<? super T> o : subscriptionManager.observers()) {
             if (caughtUp(o)) {
                 o.onNext(v);
             }
@@ -189,21 +163,20 @@ private boolean caughtUp(SubjectObserver<? super T> o) {
 
     private void replayObserver(SubjectObserver<? super T> observer) {
         Integer lastEmittedLink = state.replayState.get(observer);
-        if (lastEmittedLink != null) {
-            int l = replayObserverFromIndex(state.history, lastEmittedLink, observer);
-            state.replayState.put(observer, l);
-        } else {
-            throw new IllegalStateException("failed to find lastEmittedLink for: " + observer);
+        if (lastEmittedLink == null) {
+            lastEmittedLink = 0;
         }
+        int l = replayObserverFromIndex(state.history, lastEmittedLink, observer);
+        state.replayState.put(observer, l);
     }
 
-    private static <T> int replayObserverFromIndex(History<T> history, Integer l, SubjectObserver<? super T> observer) {
-        while (l < history.index.get()) {
-            history.accept(observer, l);
-            l++;
+    static <T> int replayObserverFromIndex(History<T> history, int idx, SubjectObserver<? super T> observer) {
+        while (idx < history.index.get()) {
+            history.accept(observer, idx);
+            idx++;
         }
 
-        return l;
+        return idx;
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index 3fa57ee691..d3af5a17e7 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -1,268 +1,332 @@
-/**
- * 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.subjects;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.concurrent.CountDownLatch;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
-
 import rx.Observable.OnSubscribe;
+
 import rx.Observer;
 import rx.Subscriber;
 import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.functions.Actions;
+import rx.operators.NotificationLite;
 import rx.subscriptions.Subscriptions;
 
-/* package */class SubjectSubscriptionManager<T> {
-
-    private AtomicReference<State<T>> state = new AtomicReference<State<T>>(new State<T>());
-
+/**
+ * Represents the typical state and OnSubscribe logic for a Subject implementation.
+ * @param <T> the source and return value type
+ */
+@SuppressWarnings({"unchecked", "rawtypes"})
+/* package */final class SubjectSubscriptionManager<T> implements OnSubscribe<T> {
+    /** Contains the unsubscription flag and the array of active subscribers. */
+    private final AtomicReference<State<T>> state = new AtomicReference<State<T>>(State.EMPTY);
+    /** Stores the latest value or the terminal value for some Subjects. */
+    final AtomicReference<Object> latest = new AtomicReference<Object>();
+    /** Indicates that the subject is active (cheaper than checking the state).*/
+    boolean active = true;
+    /** Action called when a new subscriber subscribes but before it is added to the state. */
+    Action1<SubjectObserver<T>> onStart = Actions.empty();
+    /** Action called after the subscriber has been added to the state. */
+    Action1<SubjectObserver<T>> onAdded = Actions.empty();
+    /** Action called when the subscriber wants to subscribe to a terminal state. */
+    Action1<SubjectObserver<T>> onTerminated = Actions.empty();
+    /** Called when the subscruber explicitly unsubscribes. */
+    Action1<SubjectObserver<T>> onUnsubscribed = Actions.empty();
+    @Override
+    public void call(final Subscriber<? super T> child) {
+        SubjectObserver<T> bo = new SubjectObserver<T>(child);
+        addUnsubscriber(child, bo);
+        onStart.call(bo);
+        if (add(bo) && child.isUnsubscribed()) {
+            remove(bo);
+            onUnsubscribed.call(bo);
+        }
+    }
+    /** Registers the unsubscribe action for the given subscriber. */
+    void addUnsubscriber(Subscriber<? super T> child, final SubjectObserver<T> bo) {
+        child.add(Subscriptions.create(new Action0() {
+            @Override
+            public void call() {
+                remove(bo);
+                onUnsubscribed.call(bo);
+            }
+        }));
+    }    
+    /** Set the latest NotificationLite value. */
+    void set(Object value) {
+        this.latest.set(value);
+    }
+    /** @return Retrieve the latest NotificationLite value */
+    Object get() {
+        return latest.get();
+    }
+    /** @return the array of active subscribers, don't write into the array! */
+    SubjectObserver<T>[] observers() {
+        return state.get().observers;
+    }
     /**
-     * 
-     * @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.
-     * @param onUnsubscribe
-     *            called after the child subscription is removed from the state
-     * @return
+     * Try to atomically add a SubjectObserver to the active state.
+     * @param o the SubjectObserver to add
+     * @return false if the subject is already in its terminal state
      */
-    public OnSubscribe<T> getOnSubscribeFunc(final Action1<SubjectObserver<? super T>> onSubscribe,
-            final Action1<SubjectObserver<? super T>> onTerminated,
-            final Action1<SubjectObserver<? super T>> onUnsubscribe) {
-        return new OnSubscribe<T>() {
-            @Override
-            public void call(Subscriber<? super T> actualOperator) {
-                final SubjectObserver<T> observer = new SubjectObserver<T>(actualOperator);
-                // invoke onSubscribe logic 
-                if (onSubscribe != null) {
-                    onSubscribe.call(observer);
-                }
-
-                State<T> current;
-                State<T> newState = null;
-                boolean addedObserver = false;
-                do {
-                    current = state.get();
-                    if (current.terminated) {
-                        // we are terminated so don't need to do anything
-                        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) {
-                            Thread.currentThread().interrupt();
-                            throw new RuntimeException("Interrupted waiting for termination.", e);
-                        }
-                        break;
-                    } else {
-                        addedObserver = true;
-                        // add to parent if the Subject itself is unsubscribed
-                        actualOperator.add(Subscriptions.create(new Action0() {
-
-                            @Override
-                            public void call() {
-                                State<T> current;
-                                State<T> newState;
-                                do {
-                                    current = state.get();
-                                    // on unsubscribe remove it from the map of outbound observers to notify
-                                    newState = current.removeObserver(observer);
-                                } while (!state.compareAndSet(current, newState));
-                                if (onUnsubscribe != null) {
-                                    onUnsubscribe.call(observer);
-                                }
-                            }
-                        }));
-                        if (actualOperator.isUnsubscribed()) {
-                            // we've been unsubscribed while working so return and do nothing
-                            return;
-                        }
-                        // on subscribe add it to the map of outbound observers to notify
-                        newState = current.addObserver(observer);
-                    }
-                } while (!state.compareAndSet(current, newState));
-
-                /**
-                 * Whatever happened above, if we are terminated we run `onTerminated`
-                 */
-                if (newState.terminated && !addedObserver) {
-                    onTerminated.call(observer);
-                }
+    boolean add(SubjectObserver<T> o) {
+        do {
+            State oldState = state.get();
+            if (oldState.terminated) {
+                onTerminated.call(o);
+                return false;
             }
-
-        };
+            State newState = oldState.add(o);
+            if (state.compareAndSet(oldState, newState)) {
+                onAdded.call(o);
+                return true;
+            }
+        } while (true);
     }
-
-    @SuppressWarnings({ "unchecked", "rawtypes" })
-    protected Collection<SubjectObserver<? super T>> terminate(Action0 onTerminate) {
-        State<T> current;
-        State<T> newState = null;
+    /**
+     * Atomically remove the specified SubjectObserver from the active observers.
+     * @param o the SubjectObserver to remove
+     */
+    void remove(SubjectObserver<T> o) {
         do {
-            current = state.get();
-            if (current.terminated) {
-                // already terminated so do nothing
-                return null;
-            } else {
-                newState = current.terminate();
+            State oldState = state.get();
+            if (oldState.terminated) {
+                return;
             }
-        } while (!state.compareAndSet(current, newState));
-
-        Collection<SubjectObserver<? super T>> observerCollection = (Collection) Arrays.asList(newState.observers);
-        /*
-         * 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 terminated)
-         */
-        try {
-            // had to circumvent type check, we know what the array contains
-            onTerminate.call();
-        } finally {
-            // mark that termination is completed
-            newState.terminationLatch.countDown();
-        }
-        return observerCollection;
+            State newState = oldState.remove(o);
+            if (newState == oldState || state.compareAndSet(oldState, newState)) {
+                return;
+            }
+        } while (true);
     }
-
     /**
-     * Returns the array of observers directly.
-     * <em>Don't modify the array!</em>
-     * 
-     * @return the array of current observers
+     * Set a new latest NotificationLite value and return the active observers.
+     * @param n the new latest value
+     * @return the array of SubjectObservers, don't write into the array!
      */
-    @SuppressWarnings("unchecked")
-    public SubjectObserver<Object>[] rawSnapshot() {
+    SubjectObserver<T>[] next(Object n) {
+        set(n);
         return state.get().observers;
     }
+    /**
+     * Atomically set the terminal NotificationLite value (which could be any of the 3),
+     * clear the active observers and return the last active observers.
+     * @param n the terminal value
+     * @return the last active SubjectObservers
+     */
+    SubjectObserver<T>[] terminate(Object n) {
+        set(n);
+        active = false;
+        do {
+            State<T> oldState = state.get();
+            if (oldState.terminated) {
+                return State.NO_OBSERVERS;
+            }
+            if (state.compareAndSet(oldState, State.TERMINATED)) {
+                return oldState.observers;
+            }
+        } while (true);
+    }
 
-    @SuppressWarnings("rawtypes")
-    protected static class State<T> {
+    /** State-machine representing the termination state and active SubjectObservers. */
+    protected static final class State<T> {
         final boolean terminated;
-        final CountDownLatch terminationLatch;
         final SubjectObserver[] observers;
-        // to avoid lots of empty arrays
-        final SubjectObserver[] EMPTY_O = new SubjectObserver[0];
-
-        private State(boolean isTerminated, CountDownLatch terminationLatch, SubjectObserver[] observers) {
-            this.terminationLatch = terminationLatch;
-            this.terminated = isTerminated;
+        static final SubjectObserver[] NO_OBSERVERS = new SubjectObserver[0];
+        static final State TERMINATED = new State(true, NO_OBSERVERS);
+        static final State EMPTY = new State(false, NO_OBSERVERS);
+        
+        public State(boolean terminated, SubjectObserver[] observers) {
+            this.terminated = terminated;
             this.observers = observers;
         }
-
-        State() {
-            this.terminated = false;
-            this.terminationLatch = null;
-            this.observers = EMPTY_O;
-        }
-
-        public State<T> terminate() {
-            if (terminated) {
-                throw new IllegalStateException("Already terminated.");
-            }
-            return new State<T>(true, new CountDownLatch(1), observers);
-        }
-
-        public State<T> addObserver(SubjectObserver<? super T> observer) {
-            int n = this.observers.length;
-
-            SubjectObserver[] newobservers = Arrays.copyOf(this.observers, n + 1);
-
-            newobservers[n] = observer;
-
-            return createNewWith(newobservers);
-        }
-
-        private State<T> createNewWith(SubjectObserver[] newobservers) {
-            return new State<T>(terminated, terminationLatch, newobservers);
+        public State add(SubjectObserver o) {
+            SubjectObserver[] a = observers;
+            int n = a.length;
+            SubjectObserver[] b = new SubjectObserver[n + 1];
+            System.arraycopy(observers, 0, b, 0, n);
+            b[n] = o;
+            return new State<T>(terminated, b);
         }
-
-        public State<T> removeObserver(SubjectObserver<? super T> o) {
-            // we are empty, nothing to remove
-            if (this.observers.length == 0) {
-                return this;
-            }
-
-            int n = this.observers.length - 1;
-            int copied = 0;
-            SubjectObserver[] newobservers = new SubjectObserver[n];
-
-            for (int i = 0; i < this.observers.length; i++) {
-                SubjectObserver s0 = this.observers[i];
-                if (!s0.equals(o)) {
-                    if (copied == n) {
-                        // if s was not found till the end of the iteration
-                        // we return ourselves since no modification should
-                        // have happened
+        public State remove(SubjectObserver o) {
+            SubjectObserver[] a = observers;
+            int n = a.length;
+            if (n == 1 && a[0] == o) {
+                return EMPTY;
+            } else
+                if (n == 0) {
+                    return this;
+                }
+            SubjectObserver[] b = new SubjectObserver[n - 1];
+            int j = 0;
+            for (int i = 0; i < n; i++) {
+                SubjectObserver ai = a[i];
+                if (ai != o) {
+                    if (j == n - 1) {
                         return this;
                     }
-                    newobservers[copied] = s0;
-                    copied++;
+                    b[j++] = ai;
                 }
             }
-
-            if (copied == 0) {
-                return createNewWith(EMPTY_O);
+            if (j == 0) {
+                return EMPTY;
             }
-            // if somehow copied less than expected, truncate the arrays
-            // if s is unique, this should never happen
-            if (copied < n) {
-                SubjectObserver[] newobservers2 = new SubjectObserver[copied];
-                System.arraycopy(newobservers, 0, newobservers2, 0, copied);
-
-                return createNewWith(newobservers2);
+            if (j < n - 1) {
+                SubjectObserver[] c = new SubjectObserver[j];
+                System.arraycopy(b, 0, c, 0, j);
+                b = c;
             }
-            return createNewWith(newobservers);
+            return new State<T>(terminated, b);
         }
     }
-
-    protected static class SubjectObserver<T> implements Observer<T> {
-
-        private final Observer<? super T> actual;
-        protected volatile boolean caughtUp = false;
-        boolean once = true;
-        SubjectObserver(Observer<? super T> actual) {
+    
+    /**
+     * Observer wrapping the actual Subscriber and providing various
+     * emission facilities.
+     * @param <T> the consumed value type of the actual Observer
+     */
+    protected static final class SubjectObserver<T> implements Observer<T> {
+        /** The actual Observer. */
+        final Observer<? super T> actual;
+        /** The NotificationLite to avoid allocating objects for each OnNext value. */
+        final NotificationLite<T> nl = NotificationLite.instance();
+        /** Was the emitFirst run? Guarded by this. */
+        boolean first = true;
+        /** Guarded by this. */
+        boolean emitting;
+        /** Guarded by this. */
+        List<Object> queue;
+        /* volatile */boolean fastPath;
+        protected volatile boolean caughtUp;
+        public SubjectObserver(Observer<? super T> actual) {
             this.actual = actual;
         }
-
         @Override
-        public void onCompleted() {
-            if (once) {
-                once = false;
-                this.actual.onCompleted();
-            }
+        public void onNext(T t) {
+            actual.onNext(t);
         }
-
         @Override
         public void onError(Throwable e) {
-            if (once) {
-                once = false;
-                this.actual.onError(e);
-            }
+            actual.onError(e);
         }
-
         @Override
-        public void onNext(T v) {
-            this.actual.onNext(v);
+        public void onCompleted() {
+            actual.onCompleted();
         }
-        Observer<? super T> getActual() {
+        /**
+         * Emits the given NotificationLite value and
+         * prevents the emitFirst to run if not already run.
+         * @param n the NotificationLite value
+         */
+        protected void emitNext(Object n) {
+            if (!fastPath) {
+                synchronized (this) {
+                    first = false;
+                    if (emitting) {
+                        if (queue == null) {
+                            queue = new ArrayList<Object>();
+                        }
+                        queue.add(n);
+                        return;
+                    }
+                }
+                fastPath = true;
+            }
+            nl.accept(actual, n);
+        }
+        /**
+         * Tries to emit a NotificationLite value as the first
+         * value and drains the queue as long as possible.
+         * @param n the NotificationLite value
+         */
+        protected void emitFirst(Object n) {
+            synchronized (this) {
+                if (!first || emitting) {
+                    return;
+                }
+                first = false;
+                emitting = n != null;
+            }
+            if (n != null) {
+                emitLoop(null, n);
+            }
+        }
+        /**
+         * Emits the contents of the queue as long as there are values.
+         * @param localQueue the initial queue contents
+         * @param current the current content to emit
+         */
+        protected void emitLoop(List<Object> localQueue, Object current) {
+            boolean once = true;
+            boolean skipFinal = false;
+            try {
+                do {
+                    if (localQueue != null) {
+                        for (Object n : localQueue) {
+                            accept(n);
+                        }
+                    }
+                    if (once) {
+                        once = false;
+                        accept(current);
+                    }
+                    synchronized (this) {
+                        localQueue = queue;
+                        queue = null;
+                        if (localQueue == null) {
+                            emitting = false;
+                            skipFinal = true;
+                            break;
+                        }
+                    }
+                } while (true);
+            } finally {
+                if (!skipFinal) {
+                    synchronized (this) {
+                        emitting = false;
+                    }
+                }
+            }
+        }
+        /**
+         * Dispatches a NotificationLite value to the actual Observer.
+         * @param n the value to dispatch
+         */
+        protected void accept(Object n) {
+            if (n != null) {
+                nl.accept(actual, n);
+            }
+        }
+        
+        /**
+         * Emit an OnCompleted event if the value object is 
+         * an OnNext NotificationLite object or null.
+         * @param value
+         */
+        protected void completeSingle(Object value) {
+            if (value == null || (!nl.isCompleted(value) && !nl.isError(value))) {
+                actual.onCompleted();
+            }
+        }
+        /** @return the actual Observer. */
+        protected Observer<? super T> getActual() {
             return actual;
         }
     }
-
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/TestSubject.java b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
index 7b9fb69e32..8113705c04 100644
--- a/rxjava-core/src/main/java/rx/subjects/TestSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/TestSubject.java
@@ -15,15 +15,13 @@
  */
 package rx.subjects;
 
-import java.util.Collection;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
 
-import rx.Notification;
 import rx.Observer;
 import rx.Scheduler;
 import rx.functions.Action0;
 import rx.functions.Action1;
+import rx.operators.NotificationLite;
 import rx.schedulers.TestScheduler;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
@@ -53,49 +51,27 @@
 public final class TestSubject<T> extends Subject<T, T> {
 
     public static <T> TestSubject<T> create(TestScheduler scheduler) {
-        final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
-        // set a default value so subscriptions will immediately receive this until a new notification is received
-        final AtomicReference<Notification<T>> lastNotification = new AtomicReference<Notification<T>>();
-
-        OnSubscribe<T> onSubscribe = subscriptionManager.getOnSubscribeFunc(
-                /**
-                 * This function executes at beginning of subscription.
-                 * 
-                 * This will always run, even if Subject is in terminal state.
-                 */
-                new Action1<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> 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<SubjectObserver<? super T>>() {
-
-                    @Override
-                    public void call(SubjectObserver<? super T> 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);
-                    }
-                }, null);
-
-        return new TestSubject<T>(onSubscribe, subscriptionManager, lastNotification, scheduler);
+        final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>();
+
+        state.onAdded = new Action1<SubjectObserver<T>>() {
+
+            @Override
+            public void call(SubjectObserver<T> o) {
+                o.emitFirst(state.get());
+            }
+            
+        };
+        state.onTerminated = state.onAdded;
+
+        return new TestSubject<T>(state, state, scheduler);
     }
 
-    private final SubjectSubscriptionManager<T> subscriptionManager;
-    private final AtomicReference<Notification<T>> lastNotification;
+    private final SubjectSubscriptionManager<T> state;
     private final Scheduler.Worker innerScheduler;
 
-    protected TestSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, AtomicReference<Notification<T>> lastNotification, TestScheduler scheduler) {
+    protected TestSubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> state, TestScheduler scheduler) {
         super(onSubscribe);
-        this.subscriptionManager = subscriptionManager;
-        this.lastNotification = lastNotification;
+        this.state = state;
         this.innerScheduler = scheduler.createWorker();
     }
 
@@ -105,16 +81,9 @@ public void onCompleted() {
     }
 
     private void _onCompleted() {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-
-            @Override
-            public void call() {
-                lastNotification.set(Notification.<T> createOnCompleted());
-            }
-        });
-        if (observers != null) {
-            for (Observer<? super T> o : observers) {
-                o.onCompleted();
+        if (state.active) {
+            for (SubjectObserver<T> bo : state.terminate(NotificationLite.instance().completed())) {
+                bo.onCompleted();
             }
         }
     }
@@ -136,19 +105,11 @@ public void onError(final Throwable e) {
     }
 
     private void _onError(final Throwable e) {
-        Collection<SubjectObserver<? super T>> observers = subscriptionManager.terminate(new Action0() {
-
-            @Override
-            public void call() {
-                lastNotification.set(Notification.<T> createOnError(e));
-            }
-        });
-        if (observers != null) {
-            for (Observer<? super T> o : observers) {
-                o.onError(e);
+        if (state.active) {
+            for (SubjectObserver<T> bo : state.terminate(NotificationLite.instance().error(e))) {
+                bo.onError(e);
             }
         }
-
     }
 
     public void onError(final Throwable e, long timeInMilliseconds) {
@@ -168,7 +129,7 @@ public void onNext(T v) {
     }
 
     private void _onNext(T v) {
-        for (Observer<? super T> o : subscriptionManager.rawSnapshot()) {
+        for (Observer<? super T> o : state.observers()) {
             o.onNext(v);
         }
     }

From 50b618e426075ff3267788ccfd1c78c039234bab Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Sat, 10 May 2014 11:56:50 -0700
Subject: [PATCH 371/422] Add note to javadocs about ConnectableObservables
 requiring connect() call (#1180)

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 752f5684f5..dc9fe0e55c 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4299,7 +4299,9 @@ public final <TIntermediate, TResult> Observable<TResult> multicast(
 
     /**
      * Returns a {@link ConnectableObservable} that upon connection causes the source Observable to push results
-     * into the specified subject.
+     * into the specified subject. A Connectable Observable resembles an ordinary Observable, except that it
+     * does not begin emitting items when it is subscribed to, but only when its <code>connect()</code> method
+     * is called.
      * 
      * @param subject
      *            the {@link Subject} for the {@link ConnectableObservable} to push source items into
@@ -4506,8 +4508,9 @@ public final <R> Observable<R> parallel(final Func1<Observable<T>, Observable<R>
     }
 
     /**
-     * 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.png">
      * 
@@ -4569,7 +4572,9 @@ public final Subject<T, T> call() {
     }
 
     /**
-     * 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.
+     * Returns a {@link ConnectableObservable} that emits {@code initialValue} followed by the items emitted by
+     * the source Observable. A Connectable Observable resembles an ordinary Observable, except that it does not
+     * begin emitting items when it is subscribed to, but only when its <code>connect()</code> method is called.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.i.png">
      * 
@@ -4584,6 +4589,8 @@ public final ConnectableObservable<T> publish(T initialValue) {
 
     /**
      * Returns a {@link ConnectableObservable} that emits only the last item emitted by the source Observable.
+     * A Connectable Observable resembles an ordinary Observable, except that it does not begin emitting items
+     * when it is subscribed to, but only when its <code>connect()</code> method is called. 
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishLast.png">
      * 
@@ -4745,7 +4752,9 @@ public final Observable<T> 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}.
+     * that will replay all of its items and notifications to any future {@link Observer}. A Connectable
+     * Observable resembles an ordinary Observable, except that it does not begin emitting items when it is
+     * subscribed to, but only when its <code>connect()</code> method is called.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.png">
      * 
@@ -4998,7 +5007,9 @@ public final Subject<T, T> 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.
+     * replays at most {@code bufferSize} items emitted by that Observable. A Connectable Observable resembles
+     * an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only
+     * when its <code>connect()</code> method is called.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.n.png">
      * 
@@ -5015,7 +5026,9 @@ public final ConnectableObservable<T> replay(int bufferSize) {
 
     /**
      * 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.
+     * replays at most {@code bufferSize} items that were emitted during a specified time window. A Connectable
+     * Observable resembles an ordinary Observable, except that it does not begin emitting items when it is
+     * subscribed to, but only when its <code>connect()</code> method is called. 
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nt.png">
      * 
@@ -5036,7 +5049,9 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
 
     /**
      * 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.
+     * that replays a maximum of {@code bufferSize} items that are emitted within a specified time window. A
+     * Connectable Observable resembles an ordinary Observable, except that it does not begin emitting items
+     * when it is subscribed to, but only when its <code>connect()</code> method is called.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.nts.png">
      * 
@@ -5064,7 +5079,9 @@ public final ConnectableObservable<T> 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.
+     * replays at most {@code bufferSize} items emitted by that Observable. A Connectable Observable resembles
+     * an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only
+     * when its <code>connect()</code> method is called. 
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ns.png">
      * 
@@ -5085,7 +5102,9 @@ public final ConnectableObservable<T> 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.
+     * replays all items emitted by that Observable within a specified time window. A Connectable Observable
+     * resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to,
+     * but only when its <code>connect()</code> method is called. 
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.t.png">
      * 
@@ -5104,7 +5123,9 @@ public final ConnectableObservable<T> 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.
+     * replays all items emitted by that Observable within a specified time window. A Connectable Observable
+     * resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to,
+     * but only when its <code>connect()</code> method is called. 
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.ts.png">
      * 
@@ -5125,7 +5146,9 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit, 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}.
+     * will replay all of its items and notifications to any future {@link Observer} on the given
+     * {@link Scheduler}. A Connectable Observable resembles an ordinary Observable, except that it does not
+     * begin emitting items when it is subscribed to, but only when its <code>connect()</code> method is called.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/replay.s.png">
      * 

From 8cf821abe664b2b0ef29c1a70c3355bec1a7b712 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Fri, 9 May 2014 17:18:13 +0800
Subject: [PATCH 372/422] Fix issue #1173

---
 .../main/scala/rx/lang/scala/Subscriber.scala |  2 ++
 .../scala/rx/lang/scala/SubscriberTests.scala | 32 +++++++++++++++++++
 2 files changed, 34 insertions(+)
 create mode 100644 language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala

diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
index f19abebde1..38934742c9 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
@@ -34,6 +34,8 @@ object Subscriber extends ObserverFactoryMethods[Subscriber] {
 
   private[scala] def apply[T](subscriber: rx.Subscriber[T]): Subscriber[T] = new Subscriber[T] {
     override val asJavaSubscriber = subscriber
+    override val asJavaObserver: rx.Observer[_ >: T] = asJavaSubscriber
+    override val asJavaSubscription: rx.Subscription = asJavaSubscriber
 
     override def onNext(value: T): Unit = asJavaSubscriber.onNext(value)
     override def onError(error: Throwable): Unit = asJavaSubscriber.onError(error)
diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala
new file mode 100644
index 0000000000..f5af3dafca
--- /dev/null
+++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala
@@ -0,0 +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
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in 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.Test
+import org.junit.Assert.assertNotNull
+import org.scalatest.junit.JUnitSuite
+
+class SubscriberTests extends JUnitSuite {
+
+  @Test def testIssue1173() {
+    // https://github.com/Netflix/RxJava/issues/1173
+    val subscriber = Subscriber((n: Int) => println(n))
+    assertNotNull(subscriber.asJavaObserver)
+    assertNotNull(subscriber.asJavaSubscription)
+    assertNotNull(subscriber.asJavaSubscriber)
+  }
+
+}

From a20bed894a0162c628bf77ee1e42d0eb32a85fe9 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sat, 10 May 2014 15:54:30 +0800
Subject: [PATCH 373/422] Fix the bug that the inner Subscriber can not be
 unsubscribed and elimilate scaladoc warnings

---
 .../scala/rx/lang/scala/Notification.scala    |  2 +-
 .../main/scala/rx/lang/scala/Observable.scala | 68 ++++++++++++++++---
 .../subscriptions/CompositeSubscription.scala |  6 +-
 .../scala/rx/lang/scala/SubscriberTests.scala | 13 ++++
 4 files changed, 76 insertions(+), 13 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 84f1642dbc..c9e8cd4822 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
@@ -137,7 +137,7 @@ object Notification {
      * @param notification
      *                     The [[rx.lang.scala.Notification]] to be deconstructed
      * @return
-     *         The [[java.lang.Throwable]] value contained in this notification.
+     *         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)
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 9885797dd4..a3924d3e56 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
@@ -48,6 +48,28 @@ import collection.JavaConversions._
  *         the observer
  * @define subscribeObserverParamScheduler 
  *         the [[rx.lang.scala.Scheduler]] on which Observers subscribe to the Observable
+ *
+ * @define subscribeSubscriberMain
+ * Call this method to subscribe an [[Subscriber]] for receiving items and notifications from the [[Observable]].
+ *
+ * A typical implementation of `subscribe` does the following:
+ *
+ * It stores a reference to the Observer in a collection object, such as a `List[T]` object.
+ *
+ * It returns a reference to the [[rx.lang.scala.Subscription]] interface. This enables [[Subscriber]]s to
+ * unsubscribe, that is, to stop receiving items and notifications before the Observable stops
+ * sending them, which also invokes the Subscriber's [[rx.lang.scala.Observer.onCompleted onCompleted]] method.
+ *
+ * An [[Observable]] instance is responsible for accepting all subscriptions
+ * and notifying all [[Subscriber]]s. Unless the documentation for a particular
+ * [[Observable]] implementation indicates otherwise, [[Subscriber]]s should make no
+ * assumptions about the order in which multiple [[Subscriber]]s will receive their notifications.
+ *
+ * @define subscribeSubscriberParamObserver
+ *         the [[Subscriber]]
+ * @define subscribeSubscriberParamScheduler
+ *         the [[rx.lang.scala.Scheduler]] on which [[Subscriber]]s subscribe to the Observable
+ *
  * @define subscribeAllReturn 
  *         a [[rx.lang.scala.Subscription]] reference whose `unsubscribe` method can be called to  stop receiving items
  *         before the Observable has finished sending them
@@ -125,6 +147,39 @@ trait Observable[+T]
    */
   def apply(observer: Observer[T]): Subscription = subscribe(observer)
 
+  /**
+   * $subscribeSubscriberMain
+   *
+   * @param subscriber $subscribeSubscriberParamObserver
+   * @param scheduler $subscribeSubscriberParamScheduler
+   * @return $subscribeAllReturn
+   */
+  def subscribe(subscriber: Subscriber[T], scheduler: Scheduler): Subscription = {
+    // Add the casting to avoid compile error "ambiguous reference to overloaded definition"
+    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
+    thisJava.subscribe(subscriber.asJavaSubscriber, scheduler)
+  }
+
+  /**
+   * $subscribeSubscriberMain
+   *
+   * @param subscriber $subscribeSubscriberParamObserver
+   * @return $subscribeAllReturn
+   */
+  def subscribe(subscriber: Subscriber[T]): Subscription = {
+    // Add the casting to avoid compile error "ambiguous reference to overloaded definition"
+    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
+    thisJava.subscribe(subscriber.asJavaSubscriber)
+  }
+
+  /**
+   * $subscribeSubscriberMain
+   *
+   * @param subscriber $subscribeSubscriberParamObserver
+   * @return $subscribeAllReturn
+   */
+  def apply(subscriber: Subscriber[T]): Subscription = subscribe(subscriber)
+
   /**
    * $subscribeCallbacksMainNoNotifications
    *
@@ -2405,8 +2460,7 @@ trait Observable[+T]
 
   /**
    * Perform work in parallel by sharding an `Observable[T]` on a 
-   * [[rx.lang.scala.concurrency.Schedulers.threadPoolForComputation computation]]
-   * [[rx.lang.scala.Scheduler]] and return an `Observable[R]` with the output.
+   * [[rx.lang.scala.schedulers.ComputationScheduler]] and return an `Observable[R]` with the output.
    *
    * @param f
    *            a function that applies Observable operators to `Observable[T]` in parallel and returns an `Observable[R]`
@@ -2636,12 +2690,10 @@ trait Observable[+T]
    *         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
+   *             Observable, or index is less than 0
    * @see `Observable.elementAt`
-   * @deprecated("Use `elementAt`", "0.18.0")
    */
+  @deprecated("Use `elementAt`", "0.18.0")
   def apply(index: Int): Observable[T] = elementAt(index)
 
   /**
@@ -2656,9 +2708,7 @@ trait Observable[+T]
    *         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
+   *             Observable, or index is less than 0
    */
   def elementAt(index: Int): Observable[T] = {
     toScalaObservable[T](asJavaObservable.elementAt(index))
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 abe2e721c4..dcd0ca5c39 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
@@ -50,9 +50,9 @@ class CompositeSubscription private[scala] (override val asJavaSubscription: rx.
 
   /**
    * Adds a subscription to the group,
-   * or unsubscribes immediately is the [[rx.subscriptions.CompositeSubscription]] is unsubscribed.
+   * or unsubscribes immediately is the [[rx.lang.scala.subscriptions.CompositeSubscription]] is unsubscribed.
    * @param subscription the subscription to be added.
-   * @return the [[rx.subscriptions.CompositeSubscription]] itself.
+   * @return the [[rx.lang.scala.subscriptions.CompositeSubscription]] itself.
    */
   def +=(subscription: Subscription): this.type = {
     asJavaSubscription.add(subscription.asJavaSubscription)
@@ -62,7 +62,7 @@ class CompositeSubscription private[scala] (override val asJavaSubscription: rx.
   /**
    * Removes and unsubscribes a subscription to the group,
    * @param subscription the subscription be removed.
-   * @return the [[rx.subscriptions.CompositeSubscription]] itself.
+   * @return the [[rx.lang.scala.subscriptions.CompositeSubscription]] itself.
    */
   def -=(subscription: Subscription): this.type = {
     asJavaSubscription.remove(subscription.asJavaSubscription)
diff --git a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala
index f5af3dafca..d1c03227fe 100644
--- a/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala
+++ b/language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/SubscriberTests.scala
@@ -17,6 +17,7 @@ package rx.lang.scala
 
 import org.junit.Test
 import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
 import org.scalatest.junit.JUnitSuite
 
 class SubscriberTests extends JUnitSuite {
@@ -29,4 +30,16 @@ class SubscriberTests extends JUnitSuite {
     assertNotNull(subscriber.asJavaSubscriber)
   }
 
+  @Test def testUnsubscribeForSubscriber() {
+    var innerSubscriber: Subscriber[Int] = null
+    val o = Observable[Int](subscriber => {
+      Observable[Int](subscriber => {
+        innerSubscriber = subscriber
+      }).subscribe(subscriber)
+    })
+    o.subscribe().unsubscribe()
+    // If we unsubscribe outside, the inner Subscriber should also be unsubscribed
+    assertTrue(innerSubscriber.isUnsubscribed)
+  }
+
 }

From 423395b5ef737b3a3e118e7106cf6537763e58be Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 11 May 2014 23:58:17 +0800
Subject: [PATCH 374/422] Update CompletenessTest.scala

---
 .../main/scala/rx/lang/scala/Observable.scala |  2 +-
 .../rx/lang/scala/CompletenessTest.scala      | 37 +++++++++----------
 2 files changed, 18 insertions(+), 21 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 a3924d3e56..1fb22b90a4 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
@@ -342,7 +342,7 @@ trait Observable[+T]
    *
    * A well-behaved Observable does not interleave its invocations of the [[rx.lang.scala.Observer.onNext onNext]], [[rx.lang.scala.Observer.onCompleted onCompleted]], and [[rx.lang.scala.Observer.onError onError]] methods of
    * its [[rx.lang.scala.Observer]]s; it invokes `onCompleted` or `onError` only once; and it never invokes `onNext` after invoking either `onCompleted` or `onError`.
-   * `synchronize` enforces this, and the Observable it returns invokes `onNext` and `onCompleted` or `onError` synchronously.
+   * [[Observable.serialize serialize]] enforces this, and the Observable it returns invokes `onNext` and `onCompleted` or `onError` synchronously.
    *
    * @return an Observable that is a chronologically well-behaved version of the source
    *         Observable, and that synchronously notifies its [[rx.lang.scala.Observer]]s
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 6d249289b0..a870652fa3 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
@@ -71,17 +71,15 @@ class CompletenessTest extends JUnitSuite {
       "all(Func1[_ >: T, Boolean])" -> "forall(T => Boolean)",
       "buffer(Long, Long, TimeUnit)" -> "buffer(Duration, Duration)",
       "buffer(Long, Long, TimeUnit, Scheduler)" -> "buffer(Duration, Duration, Scheduler)",
-      "contains(T)" -> "contains(Any)",
+      "contains(Any)" -> "contains(U)",
       "count()" -> "length",
       "dematerialize()" -> "dematerialize(<:<[Observable[T], Observable[Notification[U]]])",
-      "elementAt(Int)" -> "[use `.drop(index).first`]",
-      "elementAtOrDefault(Int, T)" -> "[use `.drop(index).firstOrElse(default)`]",
+      "elementAtOrDefault(Int, T)" -> "elementAtOrDefault(Int, U)",
       "first(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate,
       "firstOrDefault(T)" -> "firstOrElse(=> U)",
-      "firstOrDefault(Func1[_ >: T, Boolean], T)" -> "[use `.filter(condition).firstOrElse(default)`]",
+      "firstOrDefault(T, Func1[_ >: T, Boolean])" -> "[use `.filter(condition).firstOrElse(default)`]",
       "groupBy(Func1[_ >: T, _ <: K], Func1[_ >: T, _ <: R])" -> "[use `groupBy` and `map`]",
       "lift(Operator[_ <: R, _ >: T])" -> "lift(Subscriber[R] => Subscriber[T])",
-      "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])",
@@ -95,6 +93,7 @@ class CompletenessTest extends JUnitSuite {
       "publish(Func1[_ >: Observable[T], _ <: Observable[R]], T)" -> "publish(Observable[U] => Observable[R], U)",
       "reduce(Func2[T, T, T])" -> "reduce((U, U) => U)",
       "reduce(R, Func2[R, _ >: T, R])" -> "foldLeft(R)((R, T) => R)",
+      "repeat()" -> "repeat()",
       "retry()" -> "retry()",
       "scan(Func2[T, T, T])" -> unnecessary,
       "scan(R, Func2[R, _ >: T, R])" -> "scan(R)((R, T) => R)",
@@ -113,8 +112,8 @@ class CompletenessTest extends JUnitSuite {
       "skipLast(Int)" -> "dropRight(Int)",
       "skipLast(Long, TimeUnit)" -> "dropRight(Duration)",
       "skipLast(Long, TimeUnit, Scheduler)" -> "dropRight(Duration, Scheduler)",
-      "takeFirst()" -> "first",
-      "takeFirst(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate,
+      "subscribe()" -> "subscribe()",
+      "takeFirst(Func1[_ >: T, Boolean])" -> "[use `filter(condition).take(1)`]",
       "takeLast(Int)" -> "takeRight(Int)",
       "takeWhileWithIndex(Func2[_ >: T, _ >: Integer, Boolean])" -> "[use `.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1)`]",
       "timeout(Func0[_ <: Observable[U]], Func1[_ >: T, _ <: Observable[V]], Observable[_ <: T])" -> "timeout(() => Observable[U], T => Observable[V], Observable[O])",
@@ -126,7 +125,6 @@ class CompletenessTest extends JUnitSuite {
       "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)",
 
@@ -139,28 +137,22 @@ class CompletenessTest extends JUnitSuite {
       "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(Array[T])" -> "[use apply(T*)]",
+      "from(Iterable[_ <: T])" -> "from(Iterable[T])",
       "from(Future[_ <: T])" -> fromFuture,
       "from(Future[_ <: T], Long, TimeUnit)" -> fromFuture,
       "from(Future[_ <: T], Scheduler)" -> fromFuture,
-      "just(T)" -> "apply(T*)",
+      "just(T)" -> "[use apply(T*)]",
+      "just(T, Scheduler)" -> "[use apply(T*).subscribeOn(scheduler)]",
       "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)",
-      "repeat()" -> "repeat()",
-      "retry()" -> "retry()",
-      "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`]",
@@ -174,7 +166,7 @@ class CompletenessTest extends JUnitSuite {
       "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*)"
+      "from(" + _ + ")" -> "[use apply(T*)]"
   ).toMap ++ (3 to 9).map(i => {
     // zip3-9:
     val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("")
@@ -216,6 +208,8 @@ class CompletenessTest extends JUnitSuite {
     // 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"))
+    // `access$000` is public. How to distinguish it from others without hard-code?
+    .filter(! _.contains("access$000"))
   }
 
   // also applicable for Java types
@@ -373,7 +367,10 @@ class CompletenessTest extends JUnitSuite {
     def escape(s: String) = s.replaceAllLiterally("[", "&lt;").replaceAllLiterally("]", "&gt;")
 
     println("""
-## Comparison of Scala Observable and Java Observable
+---
+layout: comparison
+title: Comparison of Scala Observable and Java Observable
+---
 
 Note:
 *    This table contains both static methods and instance methods.

From c948a266fd7ec9fe154a2c1bd9d858d20a426f84 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 12 May 2014 11:48:26 +0800
Subject: [PATCH 375/422] Fix issue #1187

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 48 ++++++++++++++
 .../main/scala/rx/lang/scala/Scheduler.scala  | 64 +++++++++++++++----
 2 files changed, 100 insertions(+), 12 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 3ba3c90ff6..75ae8a5917 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
@@ -16,6 +16,8 @@
 package rx.lang.scala.examples
 
 import java.io.IOException
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
 
 import scala.concurrent.duration.Duration
 import scala.concurrent.duration.DurationInt
@@ -790,4 +792,50 @@ class RxScalaDemo extends JUnitSuite {
     assertEquals(List(1, 2, 3, 4), o.toBlockingObservable.toList)
   }
 
+  @Test def schedulerExample1(): Unit = {
+    val latch = new CountDownLatch(1)
+    val worker = IOScheduler().createWorker
+    worker.schedule {
+      println("Hello from Scheduler")
+      latch.countDown()
+    }
+    latch.await(5, TimeUnit.SECONDS)
+  }
+
+  @Test def schedulerExample2(): Unit = {
+    val latch = new CountDownLatch(1)
+    val worker = IOScheduler().createWorker
+    worker.schedule(
+      {
+        println("Hello from Scheduler after 1 second")
+        latch.countDown()
+      }, 1 seconds)
+    latch.await(5, TimeUnit.SECONDS)
+  }
+
+  @Test def schedulerExample3(): Unit = {
+    val worker = IOScheduler().createWorker
+    var no = 1
+    val subscription = worker.schedulePeriodically(
+      {
+        println(s"Hello(${no}) from Scheduler")
+        no += 1
+      }, initialDelay = 1 seconds, period = 100 millis)
+    TimeUnit.SECONDS.sleep(2)
+    subscription.unsubscribe()
+  }
+
+  @Test def schedulerExample4(): Unit = {
+    val worker = IOScheduler().createWorker
+    var no = 1
+    def hello: Unit = {
+      println(s"Hello(${no}) from Scheduler")
+      no += 1
+      worker.schedule(hello, 100 millis)
+    }
+    val subscription = worker.schedule(hello, 1 seconds)
+    TimeUnit.SECONDS.sleep(2)
+    subscription.unsubscribe()
+  }
+
 }
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 6d5a24474f..8d4d0b9902 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
@@ -31,7 +31,7 @@ trait Scheduler {
   /**
    * 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.
+   * This defaults to `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.
    */
@@ -42,6 +42,15 @@ trait Scheduler {
    */
   def now: Long = this.asJavaScheduler.now()
 
+  /**
+   * Retrieve or create a new [[rx.lang.scala.Worker]] that represents serial execution of actions.
+   * <p>
+   * When work is completed it should be unsubscribed using [[rx.lang.scala.Worker unsubscribe]].
+   * <p>
+   * Work on a [[rx.lang.scala.Worker]] is guaranteed to be sequential.
+   *
+   * @return Inner representing a serial queue of actions to be executed
+   */
   def createWorker: Worker = this.asJavaScheduler.createWorker()
 
 }
@@ -54,24 +63,55 @@ trait Worker extends Subscription {
   private [scala] val asJavaWorker: rx.Scheduler.Worker
 
   /**
-   * Schedules a cancelable action to be executed in delayTime.
+   * Schedules an Action for execution at some point in the future.
+   *
+   * @param action the Action to schedule
+   * @param delay time to wait before executing the action
+   * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
    */
-  def schedule(action: Unit => Unit, delayTime: Duration): Subscription =
+  def schedule(action: => Unit, delay: Duration): Subscription = {
     this.asJavaWorker.schedule(
       new Action0 {
-        override def call(): Unit = action()
+        override def call(): Unit = action
       },
-      delayTime.length,
-      delayTime.unit)
+      delay.length,
+      delay.unit)
+  }
+
+  /**
+   * Schedules an Action for execution.
+   *
+   * @param action the Action to schedule
+   * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
+   */
+  def schedule(action: => Unit): Subscription = {
+    this.asJavaWorker.schedule(
+      new Action0 {
+        override def call(): Unit = action
+      }
+    )
+  }
 
   /**
-   * Schedules a cancelable action to be executed immediately.
+   * 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 the action (unschedule it if not executed)
    */
-  def schedule(action: Unit => Unit): Subscription = this.asJavaWorker.schedule(
-    new Action0 {
-      override def call(): Unit = action()
-    }
-  )
+  def schedulePeriodically(action: => Unit, initialDelay: Duration, period: Duration): Subscription = {
+    this.asJavaWorker.schedulePeriodically(
+      new Action0 {
+        override def call(): Unit = action
+      },
+      initialDelay.toNanos,
+      period.toNanos,
+      duration.NANOSECONDS
+    )
+  }
 
   /**
    * @return the scheduler's notion of current absolute time in milliseconds.

From 9b9e5d00f7278cb18aea90dad17743b190647001 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 12 May 2014 12:14:24 +0800
Subject: [PATCH 376/422] Update the signature of "schedule" methods

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 22 +++++++++----------
 .../main/scala/rx/lang/scala/Scheduler.scala  |  4 ++--
 2 files changed, 12 insertions(+), 14 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 75ae8a5917..4d01383296 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
@@ -805,22 +805,20 @@ class RxScalaDemo extends JUnitSuite {
   @Test def schedulerExample2(): Unit = {
     val latch = new CountDownLatch(1)
     val worker = IOScheduler().createWorker
-    worker.schedule(
-      {
-        println("Hello from Scheduler after 1 second")
-        latch.countDown()
-      }, 1 seconds)
+    worker.schedule(1 seconds) {
+      println("Hello from Scheduler after 1 second")
+      latch.countDown()
+    }
     latch.await(5, TimeUnit.SECONDS)
   }
 
   @Test def schedulerExample3(): Unit = {
     val worker = IOScheduler().createWorker
     var no = 1
-    val subscription = worker.schedulePeriodically(
-      {
-        println(s"Hello(${no}) from Scheduler")
-        no += 1
-      }, initialDelay = 1 seconds, period = 100 millis)
+    val subscription = worker.schedulePeriodically(initialDelay = 1 seconds, period = 100 millis) {
+      println(s"Hello(${no}) from Scheduler")
+      no += 1
+    }
     TimeUnit.SECONDS.sleep(2)
     subscription.unsubscribe()
   }
@@ -831,9 +829,9 @@ class RxScalaDemo extends JUnitSuite {
     def hello: Unit = {
       println(s"Hello(${no}) from Scheduler")
       no += 1
-      worker.schedule(hello, 100 millis)
+      worker.schedule(100 millis)(hello)
     }
-    val subscription = worker.schedule(hello, 1 seconds)
+    val subscription = worker.schedule(1 seconds)(hello)
     TimeUnit.SECONDS.sleep(2)
     subscription.unsubscribe()
   }
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 8d4d0b9902..7e4daf0f4b 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
@@ -69,7 +69,7 @@ trait Worker extends Subscription {
    * @param delay time to wait before executing the action
    * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
    */
-  def schedule(action: => Unit, delay: Duration): Subscription = {
+  def schedule(delay: Duration)(action: => Unit): Subscription = {
     this.asJavaWorker.schedule(
       new Action0 {
         override def call(): Unit = action
@@ -102,7 +102,7 @@ trait Worker extends Subscription {
    * @param period the time interval to wait each time in between executing the action
    * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
    */
-  def schedulePeriodically(action: => Unit, initialDelay: Duration, period: Duration): Subscription = {
+  def schedulePeriodically(initialDelay: Duration, period: Duration)(action: => Unit): Subscription = {
     this.asJavaWorker.schedulePeriodically(
       new Action0 {
         override def call(): Unit = action

From d06e42083f6510b0e45566ecee9d2f0e8a9fc1e8 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Mon, 12 May 2014 10:28:53 +0200
Subject: [PATCH 377/422] Fix attempt #1

---
 .../test/java/rx/operators/OperatorPivotTest.java   | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
index 6293974272..c2432d7787 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorPivotTest.java
@@ -16,6 +16,7 @@
 
 package rx.operators;
 
+import java.util.Random;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -239,12 +240,16 @@ public void testConcurrencyAndSerialization() throws InterruptedException {
             @Override
             public Observable<String> call(final GroupedObservable<Boolean, GroupedObservable<String, Integer>> outerGroup) {
                 return outerGroup.flatMap(new Func1<GroupedObservable<String, Integer>, Observable<String>>() {
-
                     @Override
                     public Observable<String> call(final GroupedObservable<String, Integer> innerGroup) {
                         final AtomicInteger threadsPerGroup = new AtomicInteger();
                         return innerGroup.take(100).map(new Func1<Integer, String>() {
-
+                            final ThreadLocal<Random> tlr = new ThreadLocal<Random>() {
+                                @Override
+                                protected Random initialValue() {
+                                    return new Random();
+                                }
+                            };
                             @Override
                             public String call(Integer i) {
                                 int outerThreadCount = outerThreads.incrementAndGet();
@@ -256,7 +261,11 @@ public String call(Integer i) {
                                     throw new RuntimeException("more than 1 thread for this group [" + innerGroup.getKey() + "]: " + innerThreadCount + " (before)");
                                 }
                                 try {
+                                    // give the other threads a shot.
+                                    Thread.sleep(tlr.get().nextInt(10) + 1);
                                     return (outerGroup.getKey() ? "Even" : "Odd ") + " => from source: " + innerGroup.getKey() + " Value: " + i;
+                                } catch (InterruptedException ex) {
+                                    throw new RuntimeException("Interrupted [" + innerGroup.getKey() + "]: " + i);
                                 } finally {
                                     int outerThreadCountAfter = outerThreads.decrementAndGet();
                                     setMaxConcurrency(maxOuterConcurrency, outerThreadCountAfter);

From 7607f8fb08c28de59f9b5c803af530df6c73c35c Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 12 May 2014 22:17:12 +0800
Subject: [PATCH 378/422] Add sequenceEqual to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  |  9 ++++++
 .../main/scala/rx/lang/scala/Observable.scala | 32 +++++++++++++++++++
 2 files changed, 41 insertions(+)

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 3ba3c90ff6..7cbbf9796d 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
@@ -790,4 +790,13 @@ class RxScalaDemo extends JUnitSuite {
     assertEquals(List(1, 2, 3, 4), o.toBlockingObservable.toList)
   }
 
+  @Test def sequenceEqualExampe(): Unit = {
+    val o1 = List(1, 2, 3).toObservable
+    val o2 = List(1, 2, 3).toObservable
+    val o3 = List(1, 2).toObservable
+    val o4 = List(1.0, 2.0, 3.0).toObservable
+    assertTrue(o1.sequenceEqual(o2).toBlockingObservable.single)
+    assertFalse(o1.sequenceEqual(o3).toBlockingObservable.single)
+    assertTrue(o1.sequenceEqual(o4).toBlockingObservable.single)
+  }
 }
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 9885797dd4..0a7bce29a5 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
@@ -2746,6 +2746,38 @@ trait Observable[+T]
     toScalaObservable[util.Map[K, V]](o).map(m => mapFactory() ++ m.toMap)
   }
 
+  /**
+   * Returns an Observable that emits a Boolean value that indicates whether `this` and `that` Observable sequences are the
+   * same by comparing the items emitted by each Observable pairwise.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sequenceEqual.png">
+   *
+   * Note: this method uses `==` to compare elements. It's a bit different from RxJava which uses `Object.equals`.
+   *
+   * @param that the Observable to compare
+   * @return an Observable that emits a `Boolean` value that indicates whether the two sequences are the same
+   */
+  def sequenceEqual[U >: T](that: Observable[U]): Observable[Boolean] = {
+    sequenceEqual(that, (_1: U, _2: U) => _1 == _2)
+  }
+
+  /**
+   * Returns an Observable that emits a Boolean value that indicates whether `this` and `that` Observable sequences are the
+   * same by comparing the items emitted by each Observable pairwise based on the results of a specified `equality` function.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/sequenceEqual.png">
+   *
+   * @param that the Observable to compare
+   * @param equality a function used to compare items emitted by each Observable
+   * @return an Observable that emits a `Boolean` value that indicates whether the two sequences are the same based on the `equality` function.
+   */
+  def sequenceEqual[U >: T](that: Observable[U], equality: (U, U) => Boolean): Observable[Boolean] = {
+    val thisJava: rx.Observable[_ <: U] = this.asJavaObservable
+    val thatJava: rx.Observable[_ <: U] = that.asJavaObservable
+    val equalityJava: Func2[_ >: U, _ >: U, java.lang.Boolean] = equality
+    toScalaObservable[java.lang.Boolean](rx.Observable.sequenceEqual[U](thisJava, thatJava, equalityJava)).map(_.booleanValue)
+  }
+
   /**
    * 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.

From 8ebb9621289596bb8c4ebbec06c078e3d55cd13c Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 12 May 2014 22:28:08 +0800
Subject: [PATCH 379/422] Add take variants to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  |  8 ++++++
 .../main/scala/rx/lang/scala/Observable.scala | 27 +++++++++++++++++++
 2 files changed, 35 insertions(+)

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 7cbbf9796d..3a1f30ee79 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
@@ -799,4 +799,12 @@ class RxScalaDemo extends JUnitSuite {
     assertFalse(o1.sequenceEqual(o3).toBlockingObservable.single)
     assertTrue(o1.sequenceEqual(o4).toBlockingObservable.single)
   }
+
+  @Test def takeExample(): Unit = {
+    val o = (1 to 20).toObservable
+      .zip(Observable.interval(300 millis))
+      .map(_._1)
+      .take(2 seconds)
+    println(o.toBlockingObservable.toList)
+  }
 }
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 0a7bce29a5..7a2059ae51 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
@@ -1457,6 +1457,33 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.take(n))
   }
 
+  /**
+   * Returns an Observable that emits those items emitted by source Observable before a specified time runs out.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.t.png">
+   *
+   * @param time the length of the time window
+   * @return an Observable that emits those items emitted by the source Observable before the time runs out
+   */
+  def take(time: Duration): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.take(time.length, time.unit))
+  }
+
+  /**
+   * Returns an Observable that emits those items emitted by source Observable before a specified time (on
+   * specified Scheduler) runs out
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.ts.png">
+   *
+   * @param time the length of the time window
+   * @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
+   */
+  def take(time: Duration, scheduler: Scheduler) {
+    toScalaObservable[T](asJavaObservable.take(time.length, time.unit, scheduler.asJavaScheduler))
+  }
+
   /**
    * Returns an Observable that emits items emitted by the source Observable so long as a
    * specified condition is true.

From 31ceb0910ea6a9d291ea771eecd0839a00d75f8f Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 12 May 2014 22:46:36 +0800
Subject: [PATCH 380/422] Add takeRight(takeLast) variants to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 21 ++++++
 .../main/scala/rx/lang/scala/Observable.scala | 66 +++++++++++++++++++
 2 files changed, 87 insertions(+)

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 3a1f30ee79..4397fae7b5 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
@@ -807,4 +807,25 @@ class RxScalaDemo extends JUnitSuite {
       .take(2 seconds)
     println(o.toBlockingObservable.toList)
   }
+
+  @Test def takeRightExample(): Unit = {
+    val o = (1 to 6).toObservable.takeRight(3)
+    assertEquals(List(4, 5, 6), o.toBlockingObservable.toList)
+  }
+
+  @Test def takeRightExample2(): Unit = {
+    val o = (1 to 10).toObservable
+      .zip(Observable.interval(100 millis))
+      .map(_._1)
+      .takeRight(300 millis)
+    println(o.toBlockingObservable.toList)
+  }
+
+  @Test def takeRightExample3(): Unit = {
+    val o = (1 to 10).toObservable
+      .zip(Observable.interval(100 millis))
+      .map(_._1)
+      .takeRight(2, 300 millis)
+    println(o.toBlockingObservable.toList)
+  }
 }
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 7a2059ae51..6e822f6bd1 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
@@ -1516,6 +1516,72 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.takeLast(count))
   }
 
+  /**
+   * Return an Observable that emits the items from the source Observable that were emitted in a specified
+   * window of `time` before the Observable completed.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.t.png">
+   *
+   * @param time the length of the time window
+   * @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 `time`
+   */
+  def takeRight(time: Duration): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.takeLast(time.length, time.unit))
+  }
+
+  /**
+   * 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.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.ts.png">
+   *
+   * @param time the length of the time window
+   * @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 `time`, where the timing information is
+   *         provided by `scheduler`
+   */
+  def takeRight(time: Duration, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.takeLast(time.length, time.unit, scheduler.asJavaScheduler))
+  }
+
+  /**
+   * 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.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.tn.png">
+   *
+   * @param count the maximum number of items to emit
+   * @param time the length of the time window
+   * @return an Observable that emits at most `count` items from the source Observable that were emitted
+   *         in a specified window of time before the Observable completed
+   * @throws IllegalArgumentException if `count` is less than zero
+   */
+  def takeRight(count: Int, time: Duration): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.takeLast(count, time.length, time.unit))
+  }
+
+  /**
+   * 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.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/takeLast.tns.png">
+   *
+   * @param count the maximum number of items to emit
+   * @param time the length of the time window
+   * @param scheduler the Scheduler that provides the timestamps for the observed items
+   * @return an Observable that emits at most `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 `scheduler`
+   * @throws IllegalArgumentException if `count` is less than zero
+   */
+  def takeRight(count: Int, time: Duration, scheduler: Scheduler): Observable[T] = {
+    toScalaObservable[T](asJavaObservable.takeLast(count, time.length, time.unit, scheduler.asJavaScheduler))
+  }
+
   /**
    * Returns an Observable that emits the items from the source Observable only until the
    * `other` Observable emits an item.

From 9e6e8906323f3ca0ee1c906b827b96d4333aa038 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 12 May 2014 23:01:58 +0800
Subject: [PATCH 381/422] Add timeInterval to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  |  8 +++++
 .../main/scala/rx/lang/scala/Observable.scala | 29 +++++++++++++++++++
 2 files changed, 37 insertions(+)

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 4397fae7b5..4bcc1d4a38 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
@@ -828,4 +828,12 @@ class RxScalaDemo extends JUnitSuite {
       .takeRight(2, 300 millis)
     println(o.toBlockingObservable.toList)
   }
+
+  @Test def timeIntervalExample(): Unit = {
+    val o = (1 to 10).toObservable
+      .zip(Observable.interval(100 millis))
+      .map(_._1)
+      .timeInterval
+    println(o.toBlockingObservable.toList)
+  }
 }
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 6e822f6bd1..ef71bb5492 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
@@ -2871,6 +2871,35 @@ trait Observable[+T]
     toScalaObservable[java.lang.Boolean](rx.Observable.sequenceEqual[U](thisJava, thatJava, equalityJava)).map(_.booleanValue)
   }
 
+  /**
+   * Returns an Observable that emits records of the time interval between consecutive items emitted by the
+   * source Obsegrvable.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeInterval.png">
+   *
+   * @return an Observable that emits time interval information items
+   */
+  def timeInterval: Observable[(Duration, T)] = {
+    import scala.concurrent.duration.DurationLong
+    toScalaObservable(asJavaObservable.timeInterval())
+      .map(inv => (inv.getIntervalInMilliseconds millis, inv.getValue))
+  }
+
+  /**
+   * 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.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/timeInterval.s.png">
+   *
+   * @param scheduler the [[Scheduler]] used to compute time intervals
+   * @return an Observable that emits time interval information items
+   */
+  def timeInterval(scheduler: Scheduler): Observable[(Duration, T)] = {
+    import scala.concurrent.duration.DurationLong
+    toScalaObservable(asJavaObservable.timeInterval(scheduler.asJavaScheduler))
+      .map(inv => (inv.getIntervalInMilliseconds millis, inv.getValue))
+  }
+
   /**
    * 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.

From 261dc38a83931b03e073f74559a3b0b1afa41d67 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Mon, 12 May 2014 18:16:24 +0200
Subject: [PATCH 382/422] Negative schedule time now indicates immediate
 execution.

---
 .../src/main/java/rx/schedulers/SwingScheduler.java             | 2 +-
 .../src/test/java/rx/schedulers/SwingSchedulerTest.java         | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

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 c63655a3a4..5786425cf3 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
@@ -64,7 +64,7 @@ public boolean isUnsubscribed() {
 
         @Override
         public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
-            long delay = unit.toMillis(delayTime);
+            long delay = Math.max(0, unit.toMillis(delayTime));
             assertThatTheDelayIsValidForTheSwingTimer(delay);
             final BooleanSubscription s = BooleanSubscription.create();
             class ExecuteOnceAction implements ActionListener {
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 40b6a475d3..5938c336b9 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
@@ -51,10 +51,8 @@ public void testInvalidDelayValues() {
         final Worker inner = scheduler.createWorker();
         final Action0 action = mock(Action0.class);
 
-        exception.expect(IllegalArgumentException.class);
         inner.schedulePeriodically(action, -1L, 100L, TimeUnit.SECONDS);
 
-        exception.expect(IllegalArgumentException.class);
         inner.schedulePeriodically(action, 100L, -1L, TimeUnit.SECONDS);
 
         exception.expect(IllegalArgumentException.class);

From a26b21d0485c32b870846b018a60fc9cbc1c792e Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 13 May 2014 10:02:01 +0800
Subject: [PATCH 383/422] Fix issue #1196 and some docs issues

---
 .../src/main/scala/rx/lang/scala/Scheduler.scala          | 2 +-
 .../rx/lang/scala/schedulers/ComputationScheduler.scala   | 6 +++---
 .../main/scala/rx/lang/scala/schedulers/IOScheduler.scala | 8 ++++----
 .../rx/lang/scala/schedulers/NewThreadScheduler.scala     | 2 +-
 .../rx/lang/scala/schedulers/TrampolineScheduler.scala    | 2 +-
 5 files changed, 10 insertions(+), 10 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 7e4daf0f4b..eee12bfc0a 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
@@ -35,7 +35,7 @@ trait Scheduler {
    *
    * @return the scheduler's available degree of parallelism.
    */
-  def degreeOfParallelism: Int =  asJavaScheduler.degreeOfParallelism
+  def parallelism: Int =  asJavaScheduler.parallelism()
 
   /**
    * @return the scheduler's notion of current absolute time in milliseconds.
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 608d390c64..80621db933 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
@@ -5,13 +5,13 @@ import rx.lang.scala.Scheduler
 
 object ComputationScheduler {
   /**
-   * {@link Scheduler} intended for computational work.
+   * [[rx.lang.scala.Scheduler]] intended for computational work.
    * <p>
    * This can be used for event-loops, processing callbacks and other computational work.
    * <p>
-   * Do not perform IO-bound work on this scheduler. Use {@link IOScheduler()} instead.
+   * Do not perform IO-bound work on this scheduler. Use [[rx.lang.scala.schedulers.IOScheduler]] instead.
    *
-   * @return { @link Scheduler} for computation-bound work.
+   * @return [[rx.lang.scala.Scheduler]] for computation-bound work.
    */
   def apply(): ComputationScheduler = {
     new ComputationScheduler(rx.schedulers.Schedulers.computation())
diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/IOScheduler.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/IOScheduler.scala
index b7453016cf..339d82fd6a 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/IOScheduler.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/schedulers/IOScheduler.scala
@@ -19,15 +19,15 @@ import rx.lang.scala.Scheduler
 
 object IOScheduler {
   /**
-   * {@link Scheduler} intended for IO-bound work.
+   * [[rx.lang.scala.Scheduler]] intended for IO-bound work.
    * <p>
-   * The implementation is backed by an {@link Executor} thread-pool that will grow as needed.
+   * The implementation is backed by an `Executor` thread-pool that will grow as needed.
    * <p>
    * This can be used for asynchronously performing blocking IO.
    * <p>
-   * 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.ComputationScheduler]] instead.
    *
-   * @return { @link ExecutorScheduler} for IO-bound work.
+   * @return [[rx.lang.scala.Scheduler]] for IO-bound work
    */
   def apply(): IOScheduler = {
     new IOScheduler(rx.schedulers.Schedulers.io)
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 e24450f89a..09b0f30c08 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
@@ -20,7 +20,7 @@ import rx.lang.scala.Scheduler
 object NewThreadScheduler {
 
   /**
-   * Returns a [[rx.lang.scala.Scheduler]] that creates a new {@link Thread} for each unit of work.
+   * Returns a [[rx.lang.scala.Scheduler]] that creates a new `java.lang.Thread` for each unit of work.
    */
   def apply(): NewThreadScheduler =  {
     new NewThreadScheduler(rx.schedulers.Schedulers.newThread())
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
index 0ff50c1770..e2cdc49e7d 100644
--- 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
@@ -4,7 +4,7 @@ import rx.lang.scala.Scheduler
 
 object TrampolineScheduler {
   /**
-   * {@link Scheduler} that queues work on the current thread to be executed after the current work completes.
+   * [[rx.lang.scala.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())

From 8dad2ec63c0815491bfff9244f02769ee1da8fe1 Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 13 May 2014 08:25:32 +0200
Subject: [PATCH 384/422] Comment explaining non-positive delay values

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

diff --git a/rxjava-core/src/main/java/rx/Scheduler.java b/rxjava-core/src/main/java/rx/Scheduler.java
index e8352672ce..95fd31d85e 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -71,11 +71,12 @@ public abstract static class Worker implements Subscription {
 
         /**
          * Schedules an Action for execution at some point in the future.
-         * 
+         * <p>Note to implementors: non-positive {@code delayTime} should be regarded as
+         * undelayed schedule, i.e., as if the {@link #schedule(rx.functions.Action0)} was called.
          * @param action
          *            the Action to schedule
          * @param delayTime
-         *            time to wait before executing the action
+         *            time to wait before executing the action, non-positive values indicate an undelayed schedule
          * @param unit
          *            the time unit the delay time is given in
          * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)
@@ -86,13 +87,17 @@ public abstract static class Worker implements Subscription {
          * 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.
+         * <p>Note to implementors: non-positive {@code initialTime} and {@code period} should be regarded as
+         * undelayed scheduling of the first and any subsequent executions.
          * 
          * @param action
          *            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, 
+         *            non-positive values indicate an undelayed schedule
          * @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,
+         *            non-positive values indicate no delay between repeated schedules
          * @param unit
          *            the time unit the interval above is given in
          * @return a subscription to be able to unsubscribe the action (unschedule it if not executed)

From 0f191205830b9176c81ca66cd8d2a9518b096c4e Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 13 May 2014 22:27:42 +0800
Subject: [PATCH 385/422] Update more mappings to CompletenessTest

---
 .../scala/rx/lang/scala/CompletenessTest.scala    | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 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 a870652fa3..4de06f175a 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
@@ -79,6 +79,7 @@ class CompletenessTest extends JUnitSuite {
       "firstOrDefault(T)" -> "firstOrElse(=> U)",
       "firstOrDefault(T, Func1[_ >: T, Boolean])" -> "[use `.filter(condition).firstOrElse(default)`]",
       "groupBy(Func1[_ >: T, _ <: K], Func1[_ >: T, _ <: R])" -> "[use `groupBy` and `map`]",
+      "groupByUntil(Func1[_ >: T, _ <: TKey], Func1[_ >: GroupedObservable[TKey, T], _ <: Observable[_ <: TDuration]])" -> "groupByUntil(T => K, (K, Observable[T]) => Observable[Any])",
       "lift(Operator[_ <: R, _ >: T])" -> "lift(Subscriber[R] => Subscriber[T])",
       "mapWithIndex(Func2[_ >: T, Integer, _ <: R])" -> "[combine `zipWithIndex` with `map` or with a for comprehension]",
       "onErrorResumeNext(Func1[Throwable, _ <: Observable[_ <: T]])" -> "onErrorResumeNext(Throwable => Observable[U])",
@@ -133,22 +134,24 @@ class CompletenessTest extends JUnitSuite {
       "averageDoubles(Observable[Double])" -> averageProblem,
       "averageFloats(Observable[Float])" -> averageProblem,
       "averageLongs(Observable[Long])" -> averageProblem,
-      "create(OnSubscribeFunc[T])" -> "apply(Observer[T] => Subscription)",
+      "create(OnSubscribeFunc[T])" -> "create(Observer[T] => Subscription)",
+      "create(OnSubscribe[T])" -> "apply(Subscriber[T] => Unit)",
       "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])",
-      "from(Array[T])" -> "[use apply(T*)]",
+      "from(Array[T])" -> "[use `items(T*)`]",
       "from(Iterable[_ <: T])" -> "from(Iterable[T])",
       "from(Future[_ <: T])" -> fromFuture,
       "from(Future[_ <: T], Long, TimeUnit)" -> fromFuture,
       "from(Future[_ <: T], Scheduler)" -> fromFuture,
-      "just(T)" -> "[use apply(T*)]",
-      "just(T, Scheduler)" -> "[use apply(T*).subscribeOn(scheduler)]",
+      "just(T)" -> "[use `items(T*)`]",
+      "just(T, Scheduler)" -> "[use `items(T*).subscribeOn(scheduler)`]",
       "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)",
+      "range(Int, Int)" -> "[use `(... until ...).toObservable`]",
+      "range(Int, Int, Scheduler)" -> "[use `from((... until ...), scheduler)`]",
       "sum(Observable[Integer])" -> "sum(Numeric[U])",
       "sumDoubles(Observable[Double])" -> "sum(Numeric[U])",
       "sumFloats(Observable[Float])" -> "sum(Numeric[U])",
@@ -166,7 +169,7 @@ class CompletenessTest extends JUnitSuite {
       "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(" + _ + ")" -> "[use apply(T*)]"
+      "from(" + _ + ")" -> "[use `items(T*)`]"
   ).toMap ++ (3 to 9).map(i => {
     // zip3-9:
     val obsArgs = (1 to i).map(j => s"Observable[_ <: T$j], ").mkString("")

From ec2f6d6c2f8ad81725604516c0b4985a67f5181e Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 13 May 2014 23:29:00 +0800
Subject: [PATCH 386/422] Add delay variants to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 15 ++++++
 .../main/scala/rx/lang/scala/Observable.scala | 51 +++++++++++++++++++
 2 files changed, 66 insertions(+)

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 4bcc1d4a38..74c4e27b26 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
@@ -642,6 +642,21 @@ class RxScalaDemo extends JUnitSuite {
     println(result)
   }
 
+  @Test def delayExample3(): Unit = {
+    val o = List(100, 500, 200).toObservable.delay(
+      (i: Int) => Observable.items(i).delay(i millis)
+    )
+    o.toBlockingObservable.foreach(println(_))
+  }
+
+  @Test def delayExample4(): Unit = {
+    val o = List(100, 500, 200).toObservable.delay(
+      () => Observable.interval(500 millis).take(1),
+      (i: Int) => Observable.items(i).delay(i millis)
+    )
+    o.toBlockingObservable.foreach(println(_))
+  }
+
   @Test def delaySubscriptionExample(): Unit = {
     val o = List(100L, 200L, 300L).toObservable.delaySubscription(2 seconds)
     val result = o.toBlockingObservable.toList
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 ef71bb5492..f19a966f48 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
@@ -2690,6 +2690,57 @@ trait Observable[+T]
     toScalaObservable[T](asJavaObservable.delay(delay.length, delay.unit, scheduler))
   }
 
+  /**
+   * Returns an Observable that delays the emissions of the source Observable via another Observable on a
+   * per-item basis.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.o.png">
+   * <p>
+   * Note: the resulting Observable will immediately propagate any `onError` notification
+   * from the source Observable.
+   *
+   * @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 `itemDelay` emits an item
+   * @return an Observable that delays the emissions of the source Observable via another Observable on a per-item basis
+   */
+  def delay(itemDelay: T => Observable[Any]): Observable[T] = {
+    val itemDelayJava = new Func1[T, rx.Observable[Any]] {
+      override def call(t: T): rx.Observable[Any] =
+        itemDelay(t).asJavaObservable.asInstanceOf[rx.Observable[Any]]
+    }
+    toScalaObservable[T](asJavaObservable.delay[Any](itemDelayJava))
+  }
+
+  /**
+   * Returns an Observable that delays the subscription to and emissions from the souce Observable via another
+   * Observable on a per-item basis.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/delay.oo.png">
+   * <p>
+   * Note: the resulting Observable will immediately propagate any `onError` notification
+   * from the source Observable.
+   *
+   * @param subscriptionDelay 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 `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
+   */
+  def delay(subscriptionDelay: () => Observable[Any], itemDelay: T => Observable[Any]): Observable[T] = {
+    val subscriptionDelayJava = new Func0[rx.Observable[Any]] {
+      override def call(): rx.Observable[Any] =
+        subscriptionDelay().asJavaObservable.asInstanceOf[rx.Observable[Any]]
+    }
+    val itemDelayJava = new Func1[T, rx.Observable[Any]] {
+      override def call(t: T): rx.Observable[Any] =
+        itemDelay(t).asJavaObservable.asInstanceOf[rx.Observable[Any]]
+    }
+    toScalaObservable[T](asJavaObservable.delay[Any, Any](subscriptionDelayJava, itemDelayJava))
+  }
+
   /**
    * Return an Observable that delays the subscription to the source Observable by a given amount of time.
    *

From 44efb27764a839e1b5f14e11e9e7573cbf912157 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 14 May 2014 22:07:23 +0800
Subject: [PATCH 387/422] Update range comments

---
 .../src/test/scala/rx/lang/scala/CompletenessTest.scala       | 4 ++--
 1 file changed, 2 insertions(+), 2 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 4de06f175a..6d59db0151 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
@@ -150,8 +150,8 @@ class CompletenessTest extends JUnitSuite {
       "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)" -> "[use `(... until ...).toObservable`]",
-      "range(Int, Int, Scheduler)" -> "[use `from((... until ...), scheduler)`]",
+      "range(Int, Int)" -> "[use `(start until (start + count)).toObservable` instead of `range(start, count)`]",
+      "range(Int, Int, Scheduler)" -> "[use `(start until (start + count)).toObservable.subscribeOn(scheduler)` instead of `range(start, count, scheduler)`]`]",
       "sum(Observable[Integer])" -> "sum(Numeric[U])",
       "sumDoubles(Observable[Double])" -> "sum(Numeric[U])",
       "sumFloats(Observable[Float])" -> "sum(Numeric[U])",

From 354c959c8f0853cffd346ef833b53781baf76e75 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 14 May 2014 22:55:42 +0800
Subject: [PATCH 388/422] Add using to RxScala

---
 .../main/scala/rx/lang/scala/Observable.scala | 22 +++++++++++++++++++
 1 file changed, 22 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 f19a966f48..efeb0cb161 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
@@ -3335,6 +3335,28 @@ object Observable {
     toScalaObservable[java.lang.Long](rx.Observable.timer(initialDelay.toNanos, period.toNanos, duration.NANOSECONDS, scheduler)).map(_.longValue())
   }
 
+  /**
+   * Constructs an Observable that creates a dependent resource object.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/using.png">
+   *
+   * @param resourceFactory the factory function to create 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
+   */
+  def using[T, Resource <: Subscription](resourceFactory: () => Resource, observableFactory: Resource => Observable[T]): Observable[T] = {
+    class ResourceSubscription(val resource: Resource) extends rx.Subscription {
+      def unsubscribe = resource.unsubscribe
+
+      def isUnsubscribed: Boolean = resource.isUnsubscribed
+    }
+
+    toScalaObservable(rx.Observable.using[T, ResourceSubscription](
+      () => new ResourceSubscription(resourceFactory()),
+      (s: ResourceSubscription) => observableFactory(s.resource).asJavaObservable
+    ))
+  }
+
 }
 
 

From f4640ec2971448a1e361391b8f6ead74ca2c8cfd Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 14 May 2014 23:17:13 +0800
Subject: [PATCH 389/422] Add buffer variants to RxScala

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  |  6 +++
 .../main/scala/rx/lang/scala/Observable.scala | 37 +++++++++++++++++++
 2 files changed, 43 insertions(+)

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 74c4e27b26..dec92cd8db 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
@@ -142,6 +142,12 @@ class RxScalaDemo extends JUnitSuite {
     o.buffer(5).subscribe((l: Seq[Int]) => println(l.mkString("[", ", ", "]")))
   }
 
+  @Test def bufferExample() {
+    val o = Observable.from(1 to 18).zip(Observable.interval(100 millis)).map(_._1)
+    val boundary = Observable.interval(500 millis)
+    o.buffer(boundary).toBlockingObservable.foreach((l: Seq[Int]) => println(l.mkString("[", ", ", "]")))
+  }
+
   @Test def windowExample() {
     (for ((o, i) <- Observable.from(1 to 18).window(5).zipWithIndex; n <- o)
       yield s"Observable#$i emits $n"
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 efeb0cb161..6e91377c97 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
@@ -565,6 +565,43 @@ trait Observable[+T]
     Observable.jObsOfListToScObsOfSeq(oJava.asInstanceOf[rx.Observable[_ <: java.util.List[T]]])
   }
 
+  /**
+   * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the
+   * specified boundary Observable emits an item.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer8.png">
+   * <p>
+   * Completion of either the source or the boundary Observable causes the returned Observable to emit the
+   * latest buffer and complete.
+   *
+   * @param boundary the boundary Observable
+   * @return an Observable that emits buffered items from the source Observable when the boundary Observable
+   *         emits an item
+   */
+  def buffer(boundary: Observable[Any]): Observable[Seq[T]] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[T]]
+    toScalaObservable(thisJava.buffer(boundary.asJavaObservable)).map(_.asScala)
+  }
+
+  /**
+   * Returns an Observable that emits non-overlapping buffered items from the source Observable each time the
+   * specified boundary Observable emits an item.
+   * <p>
+   * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/buffer8.png">
+   * <p>
+   * Completion of either the source or the boundary Observable causes the returned Observable to emit the
+   * latest buffer and complete.
+   *
+   * @param 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
+   */
+  def buffer(boundary: Observable[Any], initialCapacity: Int): Observable[Seq[T]] = {
+    val thisJava = this.asJavaObservable.asInstanceOf[rx.Observable[T]]
+    toScalaObservable(thisJava.buffer(boundary.asJavaObservable, initialCapacity)).map(_.asScala)
+  }
+
   /**
    * Creates an Observable which produces windows of collected values. This Observable produces connected
    * non-overlapping windows. The current window is emitted and replaced with a new window when the

From d9c086f4cb859dc3995378608dd933fe518290d9 Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Wed, 14 May 2014 11:41:09 -0700
Subject: [PATCH 390/422] Adding marble diagrams to StringObservable operator
 javadocs

---
 .../java/rx/observables/StringObservable.java | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

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 d99df380c7..ce154043c5 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
@@ -40,6 +40,8 @@ public class StringObservable {
     /**
      * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
      * {@code byte[]}s
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.from.png">
      * 
      * @param i
      *            Source {@link InputStream}
@@ -52,6 +54,8 @@ public static Observable<byte[]> from(final InputStream i) {
     /**
      * Reads from the bytes from a source {@link InputStream} and outputs {@link Observable} of
      * {@code byte[]}s
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.from.png">
      * 
      * @param i
      *            Source {@link InputStream}
@@ -86,6 +90,8 @@ public void call(Subscriber<? super byte[]> o) {
     /**
      * Reads from the characters from a source {@link Reader} and outputs {@link Observable} of
      * {@link String}s
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.from.png">
      * 
      * @param i
      *            Source {@link Reader}
@@ -98,6 +104,8 @@ public static Observable<String> from(final Reader i) {
     /**
      * Reads from the characters from a source {@link Reader} and outputs {@link Observable} of
      * {@link String}s
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.from.png">
      * 
      * @param i
      *            Source {@link Reader}
@@ -132,6 +140,8 @@ public void call(Subscriber<? super String> o) {
     /**
      * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.decode.png">
      * 
      * @param src
      * @param charsetName
@@ -144,6 +154,8 @@ public static Observable<String> decode(Observable<byte[]> 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.decode.png">
      * 
      * @param src
      * @param charset
@@ -157,6 +169,8 @@ public static Observable<String> decode(Observable<byte[]> src, Charset charset)
      * Decodes a stream the multibyte chunks into a stream of strings that works on infinite streams
      * 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.decode.png">
      * 
      * @param src
      * @param charsetDecoder
@@ -246,6 +260,8 @@ public boolean process(byte[] next, ByteBuffer last, boolean endOfInput) {
 
     /**
      * Encodes a possible infinite stream of strings into a Observable of byte arrays.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.encode.png">
      * 
      * @param src
      * @param charsetName
@@ -257,6 +273,8 @@ public static Observable<byte[]> encode(Observable<String> src, String charsetNa
 
     /**
      * Encodes a possible infinite stream of strings into a Observable of byte arrays.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.encode.png">
      * 
      * @param src
      * @param charset
@@ -269,6 +287,8 @@ public static Observable<byte[]> encode(Observable<String> src, Charset charset)
     /**
      * Encodes a possible infinite stream of strings into a Observable of byte arrays.
      * This method allows for more control over how malformed and unmappable characters are handled.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.encode.png">
      * 
      * @param src
      * @param charsetEncoder
@@ -293,6 +313,8 @@ 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.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.stringConcat.png">
      * 
      * @param src
      * @return the Observable returing all strings concatenated as a single string
@@ -315,6 +337,8 @@ public String call(String a, String b) {
      * </pre>
      * 
      * See {@link Pattern}
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.split.png">
      * 
      * @param src
      * @param regex
@@ -384,6 +408,8 @@ private void output(String part) {
      * Concatenates the sequence of values by adding a separator
      * between them and emitting the result once the source completes.
      * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.join.png">
+     * <p>
      * The conversion from the value type to String is performed via
      * {@link java.lang.String#valueOf(java.lang.Object)} calls.
      * <p>
@@ -487,6 +513,8 @@ public String toString() {
 
     /**
      * Splits the {@link Observable} of Strings by lines and numbers them (zero based index)
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/St.byLine.png">
      * 
      * @param source
      * @return the Observable conaining the split lines of the source

From 7104db29e7d2de3c195040eb119becde75fa757d Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Thu, 15 May 2014 12:55:42 -0700
Subject: [PATCH 391/422] EDGE-1369 document runAsync/StoppableObservable

---
 .../src/main/java/rx/util/async/Async.java    | 676 ++++++++----------
 .../rx/util/async/StoppableObservable.java    |   5 +-
 2 files changed, 282 insertions(+), 399 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 ce6962837a..940e769b02 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
@@ -60,8 +60,8 @@
 import rx.util.async.operators.OperatorStartFuture;
 
 /**
- * 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 {
     
@@ -70,20 +70,17 @@ private Async() {
     }
     
     /**
-     * Invokes the specified function asynchronously and returns an Observable
-     * that emits the result.
+     * Invokes the specified function asynchronously and returns an Observable that emits the result.
      * <p>
-     * 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 and once, not whenever an observer subscribes to the resulting
+     * Observable. Multiple subscriptions to this Observable observe the same return value.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/start.png">
      *
      * @param <T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#start">RxJava Wiki: start()</a>
+     * @return an Observable that emits the function's result value, or notifies observers of an exception
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-start">RxJava Wiki: start()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229036.aspx">MSDN: Observable.Start</a>
      */
     public static <T> Observable<T> start(Func0<T> func) {
@@ -91,21 +88,19 @@ public static <T> Observable<T> start(Func0<T> func) {
     }
     
     /**
-     * Invokes the specified function asynchronously on the specified scheduler
-     * and returns an Observable that emits the result.
+     * Invokes the specified function asynchronously on the specified Scheduler and returns an Observable that
+     * emits the result.
      * <p>
-     * 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 and once, not whenever an observer subscribes to the resulting
+     * Observable. Multiple subscriptions to this Observable observe the same return value.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/start.s.png">
      *
      * @param <T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#start">RxJava Wiki: start()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-start">RxJava Wiki: start()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211721.aspx">MSDN: Observable.Start</a>
      */
     public static <T> Observable<T> start(Func0<T> func, Scheduler scheduler) {
@@ -113,15 +108,13 @@ public static <T> Observable<T> start(Func0<T> func, Scheduler scheduler) {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229868.aspx">MSDN: Observable.ToAsync</a>
      */
     public static Func0<Observable<Void>> toAsync(Action0 action) {
@@ -129,16 +122,14 @@ public static Func0<Observable<Void>> toAsync(Action0 action) {
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
      * @param <R> the result value type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229182.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <R> Func0<Observable<R>> toAsync(Func0<? extends R> func) {
@@ -146,16 +137,14 @@ public static <R> Func0<Observable<R>> toAsync(Func0<? extends R> func) {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
      * @param <T1> first parameter type of the action
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229657.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1> Func1<T1, Observable<Void>> toAsync(Action1<? super T1> action) {
@@ -163,17 +152,15 @@ public static <T1> Func1<T1, Observable<Void>> toAsync(Action1<? super T1> actio
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
      * @param <T1> first parameter type of the action
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229755.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, R> Func1<T1, Observable<R>> toAsync(Func1<? super T1, ? extends R> func) {
@@ -181,17 +168,15 @@ public static <T1, R> Func1<T1, Observable<R>> toAsync(Func1<? super T1, ? exten
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
      * @param <T1> the first parameter type
      * @param <T2> the second parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211875.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2> Func2<T1, T2, Observable<Void>> toAsync(Action2<? super T1, ? super T2> action) {
@@ -199,8 +184,7 @@ public static <T1, T2> Func2<T1, T2, Observable<Void>> toAsync(Action2<? super T
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -208,9 +192,8 @@ public static <T1, T2> Func2<T1, T2, Observable<Void>> toAsync(Action2<? super T
      * @param <T2> the second parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229851.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, R> Func2<T1, T2, Observable<R>> toAsync(Func2<? super T1, ? super T2, ? extends R> func) {
@@ -218,8 +201,7 @@ public static <T1, T2, R> Func2<T1, T2, Observable<R>> toAsync(Func2<? super T1,
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
@@ -227,9 +209,8 @@ public static <T1, T2, R> Func2<T1, T2, Observable<R>> toAsync(Func2<? super T1,
      * @param <T2> the second parameter type
      * @param <T3> the third parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229336.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3> Func3<T1, T2, T3, Observable<Void>> toAsync(Action3<? super T1, ? super T2, ? super T3> action) {
@@ -237,8 +218,7 @@ public static <T1, T2, T3> Func3<T1, T2, T3, Observable<Void>> toAsync(Action3<?
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -247,9 +227,8 @@ public static <T1, T2, T3> Func3<T1, T2, T3, Observable<Void>> toAsync(Action3<?
      * @param <T3> the third parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229450.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, R> Func3<T1, T2, T3, Observable<R>> toAsync(Func3<? super T1, ? super T2, ? super T3, ? extends R> func) {
@@ -257,8 +236,7 @@ public static <T1, T2, T3, R> Func3<T1, T2, T3, Observable<R>> toAsync(Func3<? s
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
@@ -267,9 +245,8 @@ public static <T1, T2, T3, R> Func3<T1, T2, T3, Observable<R>> toAsync(Func3<? s
      * @param <T3> the third parameter type
      * @param <T4> the fourth parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229769.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Observable<Void>> toAsync(Action4<? super T1, ? super T2, ? super T3, ? super T4> action) {
@@ -277,8 +254,7 @@ public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Observable<Void>> toAsync(A
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -288,9 +264,8 @@ public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Observable<Void>> toAsync(A
      * @param <T4> the fourth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229911.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, Observable<R>> toAsync(Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> func) {
@@ -298,8 +273,7 @@ public static <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, Observable<R>> toAsync(F
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
@@ -309,9 +283,8 @@ public static <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, Observable<R>> toAsync(F
      * @param <T4> the fourth parameter type
      * @param <T5> the fifth parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229577.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Observable<Void>> toAsync(Action5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5> action) {
@@ -319,8 +292,7 @@ public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Observable<Void>> t
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -331,9 +303,8 @@ public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Observable<Void>> t
      * @param <T5> the fifth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229571.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, Observable<R>> toAsync(Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> func) {
@@ -341,8 +312,7 @@ public static <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, Observable<R>> t
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
@@ -353,9 +323,8 @@ public static <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, Observable<R>> t
      * @param <T5> the fifth parameter type
      * @param <T6> the sixth parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211773.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Observable<Void>> toAsync(Action6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6> action) {
@@ -363,8 +332,7 @@ public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Observable<
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -376,9 +344,8 @@ public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Observable<
      * @param <T6> the sixth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229716.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, Observable<R>> toAsync(Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> func) {
@@ -386,8 +353,7 @@ public static <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, Observab
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
@@ -399,9 +365,8 @@ public static <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, Observab
      * @param <T6> the sixth parameter type
      * @param <T7> the seventh parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211812.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Observable<Void>> toAsync(Action7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7> action) {
@@ -409,8 +374,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Obs
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -423,9 +387,8 @@ public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Obs
      * @param <T7> the seventh parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229773.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7, Observable<R>> toAsync(Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> func) {
@@ -433,8 +396,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7,
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
@@ -447,9 +409,8 @@ public static <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7,
      * @param <T7> the seventh parameter type
      * @param <T8> the eighth parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh228993.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7, T8, Observable<Void>> toAsync(Action8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8> action) {
@@ -457,8 +418,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7,
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -472,9 +432,8 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7,
      * @param <T8> the eighth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229910.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6, T7, T8, Observable<R>> toAsync(Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> func) {
@@ -482,8 +441,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6,
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
@@ -497,9 +455,8 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6,
      * @param <T8> the eighth parameter type
      * @param <T9> the ninth parameter type
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211702.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, Observable<Void>> toAsync(Action9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9> action) {
@@ -507,8 +464,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6,
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
@@ -523,9 +479,8 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6,
      * @param <T9> the ninth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212074.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, Observable<R>> toAsync(Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> func) {
@@ -533,47 +488,41 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func9<T1, T2, T3, T4, T5,
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.an.png">
      *
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      */
     public static FuncN<Observable<Void>> toAsync(ActionN action) {
         return toAsync(action, Schedulers.computation());
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.png">
      *
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      */
     public static <R> FuncN<Observable<R>> toAsync(FuncN<? extends R> func) {
         return toAsync(func, Schedulers.computation());
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229439.aspx">MSDN: Observable.ToAsync</a>
      */
     public static Func0<Observable<Void>> toAsync(final Action0 action, final Scheduler scheduler) {
@@ -581,17 +530,15 @@ public static Func0<Observable<Void>> toAsync(final Action0 action, final Schedu
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211792.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <R> Func0<Observable<R>> toAsync(final Func0<? extends R> func, final Scheduler scheduler) {
@@ -622,17 +569,15 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
      * @param <T1> the first parameter type
-     * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @param action the Action to convert
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229822.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1> Func1<T1, Observable<Void>> toAsync(final Action1<? super T1> action, final Scheduler scheduler) {
@@ -640,18 +585,16 @@ public static <T1> Func1<T1, Observable<Void>> toAsync(final Action1<? super T1>
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
      * @param <T1> the first parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229731.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, R> Func1<T1, Observable<R>> toAsync(final Func1<? super T1, ? extends R> func, final Scheduler scheduler) {
@@ -682,18 +625,16 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
      * @param <T1> the first parameter type
      * @param <T2> the second parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229722.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2> Func2<T1, T2, Observable<Void>> toAsync(final Action2<? super T1, ? super T2> action, final Scheduler scheduler) {
@@ -701,8 +642,7 @@ public static <T1, T2> Func2<T1, T2, Observable<Void>> toAsync(final Action2<? s
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -710,10 +650,9 @@ public static <T1, T2> Func2<T1, T2, Observable<Void>> toAsync(final Action2<? s
      * @param <T2> the second parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229327.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, R> Func2<T1, T2, Observable<R>> toAsync(final Func2<? super T1, ? super T2, ? extends R> func, final Scheduler scheduler) {
@@ -744,8 +683,7 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
@@ -753,10 +691,9 @@ public void call() {
      * @param <T2> the second parameter type
      * @param <T3> the third parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211787.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3> Func3<T1, T2, T3, Observable<Void>> toAsync(final Action3<? super T1, ? super T2, ? super T3> action, final Scheduler scheduler) {
@@ -764,8 +701,7 @@ public static <T1, T2, T3> Func3<T1, T2, T3, Observable<Void>> toAsync(final Act
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -774,10 +710,9 @@ public static <T1, T2, T3> Func3<T1, T2, T3, Observable<Void>> toAsync(final Act
      * @param <T3> the third parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229287.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, R> Func3<T1, T2, T3, Observable<R>> toAsync(final Func3<? super T1, ? super T2, ? super T3, ? extends R> func, final Scheduler scheduler) {
@@ -808,8 +743,7 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
@@ -818,10 +752,9 @@ public void call() {
      * @param <T3> the third parameter type
      * @param <T4> the fourth parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229370.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Observable<Void>> toAsync(final Action4<? super T1, ? super T2, ? super T3, ? super T4> action, final Scheduler scheduler) {
@@ -829,8 +762,7 @@ public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Observable<Void>> toAsync(f
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -840,10 +772,9 @@ public static <T1, T2, T3, T4> Func4<T1, T2, T3, T4, Observable<Void>> toAsync(f
      * @param <T4> the fourth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229560.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, R> Func4<T1, T2, T3, T4, Observable<R>> toAsync(final Func4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> func, final Scheduler scheduler) {
@@ -874,8 +805,7 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
@@ -885,10 +815,9 @@ public void call() {
      * @param <T4> the fourth parameter type
      * @param <T5> the fifth parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212149.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Observable<Void>> toAsync(final Action5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5> action, final Scheduler scheduler) {
@@ -896,8 +825,7 @@ public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Observable<Void>> t
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -908,10 +836,9 @@ public static <T1, T2, T3, T4, T5> Func5<T1, T2, T3, T4, T5, Observable<Void>> t
      * @param <T5> the fifth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229606.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, R> Func5<T1, T2, T3, T4, T5, Observable<R>> toAsync(final Func5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> func, final Scheduler scheduler) {
@@ -942,8 +869,7 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
@@ -954,10 +880,9 @@ public void call() {
      * @param <T5> the fifth parameter type
      * @param <T6> the sixth parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212138.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Observable<Void>> toAsync(final Action6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6> action, final Scheduler scheduler) {
@@ -965,8 +890,7 @@ public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Observable<
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -978,10 +902,9 @@ public static <T1, T2, T3, T4, T5, T6> Func6<T1, T2, T3, T4, T5, T6, Observable<
      * @param <T6> the sixth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229630.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, R> Func6<T1, T2, T3, T4, T5, T6, Observable<R>> toAsync(final Func6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> func, final Scheduler scheduler) {
@@ -1012,8 +935,7 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
@@ -1025,10 +947,9 @@ public void call() {
      * @param <T6> the sixth parameter type
      * @param <T7> the seventh parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229808.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Observable<Void>> toAsync(final Action7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7> action, final Scheduler scheduler) {
@@ -1036,8 +957,7 @@ public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Obs
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -1050,10 +970,9 @@ public static <T1, T2, T3, T4, T5, T6, T7> Func7<T1, T2, T3, T4, T5, T6, T7, Obs
      * @param <T7> the seventh parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229794.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, R> Func7<T1, T2, T3, T4, T5, T6, T7, Observable<R>> toAsync(final Func7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> func, final Scheduler scheduler) {
@@ -1084,8 +1003,7 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
@@ -1098,10 +1016,9 @@ public void call() {
      * @param <T7> the seventh parameter type
      * @param <T8> the eighth parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229361.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7, T8, Observable<Void>> toAsync(final Action8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8> action, final Scheduler scheduler) {
@@ -1109,8 +1026,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7,
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -1124,10 +1040,9 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8> Func8<T1, T2, T3, T4, T5, T6, T7,
      * @param <T8> the eighth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh228956.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8, R> Func8<T1, T2, T3, T4, T5, T6, T7, T8, Observable<R>> toAsync(final Func8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> func, final Scheduler scheduler) {
@@ -1158,8 +1073,7 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
@@ -1173,10 +1087,9 @@ public void call() {
      * @param <T8> the eighth parameter type
      * @param <T9> the ninth parameter type
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229662.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, Observable<Void>> toAsync(final Action9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9> action, final Scheduler scheduler) {
@@ -1184,8 +1097,7 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6,
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
@@ -1200,10 +1112,9 @@ public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Func9<T1, T2, T3, T4, T5, T6,
      * @param <T9> the ninth parameter type
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229008.aspx">MSDN: Observable.ToAsync</a>
      */
     public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, Observable<R>> toAsync(final Func9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> func, final Scheduler scheduler) {
@@ -1234,33 +1145,29 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.ans.png">
      *
      * @param action the action to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      */
     public static FuncN<Observable<Void>> 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.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/toAsync.s.png">
      *
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: toAsync()</a>
      */
     public static <R> FuncN<Observable<R>> toAsync(final FuncN<? extends R> func, final Scheduler scheduler) {
         return new FuncN<Observable<R>>() {
@@ -1290,43 +1197,38 @@ public void call() {
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/asyncAction.n.png">
      * <p>
      * Alias for toAsync(ActionN) intended for dynamic languages.
      *
      * @param action the action to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncAction()</a>
+     * @return a function that returns an Observable that executes the {@code action} and emits {@code null}
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncAction()</a>
      */
     public static FuncN<Observable<Void>> asyncAction(final ActionN action) {
         return toAsync(action);
     }
     
     /**
-     * Convert a synchronous action call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous action call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/asyncAction.ns.png">
      * <p>
      * 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 that returns an Observable that executes the
-     *         {@code action} and emits {@code null}
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncAction()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncAction()</a>
      */
     public static FuncN<Observable<Void>> asyncAction(final ActionN action, final Scheduler scheduler) {
         return toAsync(action, scheduler);
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/asyncFunc.png">
      * <p>
@@ -1334,39 +1236,34 @@ public static FuncN<Observable<Void>> asyncAction(final ActionN action, final Sc
      *
      * @param <R> the result type
      * @param func the function to convert
-     * @return a function that returns an Observable that executes the
-     *         {@code func} and emits its returned value
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncFunc()</a>
+     * @return a function that returns an Observable that executes the {@code func} and emits its returned value
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncFunc()</a>
      */
     public static <R> FuncN<Observable<R>> asyncFunc(final FuncN<? extends R> func) {
         return toAsync(func);
     }
     
     /**
-     * Convert a synchronous function call into an asynchronous function call
-     * through an Observable.
+     * Convert a synchronous function call into an asynchronous function call through an Observable.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/asyncFunc.s.png">
      * <p>
-     * Alias for toAsync(FuncN, Scheduler) intended for dynamic languages.
+     * Alias for {@code toAsync(FuncN, Scheduler)} intended for dynamic languages.
      *
      * @param <R> the result type
      * @param func the function to convert
-     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncFunc()</a>
+     * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-toasync-or-asyncaction-or-asyncfunc">RxJava Wiki: asyncFunc()</a>
      */
     public static <R> FuncN<Observable<R>> asyncFunc(final FuncN<? extends R> func, final Scheduler scheduler) {
         return toAsync(func, scheduler);
     }
     
     /**
-     * Invokes the asynchronous function immediately, surfacing the result
-     * through an Observable.
+     * Invokes the asynchronous function immediately, surfacing the result through an Observable.
      * <p>
-     * <em>Important note</em> subscribing to the resulting Observable blocks
-     * until the future completes.
+     * <em>Important note</em> subscribing to the resulting Observable blocks until the future completes.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startFuture.png">
      *
@@ -1374,24 +1271,23 @@ public static <R> FuncN<Observable<R>> asyncFunc(final FuncN<? extends R> func,
      * @param functionAsync the asynchronous function to run
      * @return an Observable that surfaces the result of the future
      * @see #startFuture(rx.functions.Func0, rx.Scheduler)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#startfuture">RxJava Wiki: startFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-startfuture">RxJava Wiki: startFuture()</a>
      */
     public static <T> Observable<T> startFuture(Func0<? extends Future<? extends T>> functionAsync) {
         return OperatorStartFuture.startFuture(functionAsync);
     }
     
     /**
-     * Invokes the asynchronous function immediately, surfacing the result
-     * through an Observable and waits on the specified scheduler.
+     * Invokes the asynchronous function immediately, surfacing the result through an Observable and waits on
+     * the specified Scheduler.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/startFuture.s.png">
      *
      * @param <T> the result type
      * @param functionAsync the asynchronous function to run
-     * @param scheduler the scheduler where the completion of the Future is
-     *                  awaited
+     * @param scheduler the Scheduler where the completion of the Future is awaited
      * @return an Observable that surfaces the result of the future
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#startfuture">RxJava Wiki: startFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-startfuture">RxJava Wiki: startFuture()</a>
      */
     public static <T> Observable<T> startFuture(Func0<? extends Future<? extends T>> functionAsync,
         Scheduler scheduler) {
@@ -1399,40 +1295,34 @@ public static <T> Observable<T> startFuture(Func0<? extends Future<? extends T>>
     }
     
     /**
-     * Returns an Observable 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.
      * <p>
-     * <em>Important note</em> subscribing to the resulting Observable blocks
-     * until the future completes.
+     * <em>Important note</em> subscribing to the resulting Observable blocks until the future completes.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/deferFuture.png">
      *
      * @param <T> the result type
-     * @param observableFactoryAsync the asynchronous function to start for each
-     *                               observer
-     * @return the Observable emitting items produced by the asynchronous
-     *         observer produced by the factory
+     * @param observableFactoryAsync the asynchronous function to start for each observer
+     * @return the Observable emitting items produced by the asynchronous observer produced by the factory
      * @see #deferFuture(rx.functions.Func0, rx.Scheduler)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#deferfuture">RxJava Wiki: deferFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-deferfuture">RxJava Wiki: deferFuture()</a>
      */
     public static <T> Observable<T> deferFuture(Func0<? extends Future<? extends Observable<? extends T>>> observableFactoryAsync) {
         return OperatorDeferFuture.deferFuture(observableFactoryAsync);
     }
     
     /**
-     * Returns an Observable 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/deferFuture.s.png">
      *
      * @param <T> 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 emitting items produced by the asynchronous
-     *         observer produced by the factory
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#deferfuture">RxJava Wiki: deferFuture()</a>
+     * @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 emitting items produced by the asynchronous observer produced by the factory
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-deferfuture">RxJava Wiki: deferFuture()</a>
      */
     public static <T> Observable<T> deferFuture(
         Func0<? extends Future<? extends Observable<? extends T>>> observableFactoryAsync,
@@ -1441,11 +1331,11 @@ public static <T> Observable<T> deferFuture(
     }
     
     /**
-     * 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.
      * <p>
-     * <em>Important note:</em> The returned task blocks indefinitely unless
-     * the run() method is called or the task is scheduled on an Executor.
+     * <em>Important note:</em> The returned task blocks indefinitely unless the {@code run()} method is called
+     * or the task is scheduled on an Executor.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/forEachFuture.png">
      *
@@ -1454,7 +1344,7 @@ public static <T> Observable<T> deferFuture(
      * @param onNext the action to call with each emitted element
      * @return the Future representing the entire for-each operation
      * @see #forEachFuture(rx.Observable, rx.functions.Action1, rx.Scheduler)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
         Observable<? extends T> source,
@@ -1464,11 +1354,11 @@ public static <T> FutureTask<Void> 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.
      * <p>
-     * <em>Important note:</em> The returned task blocks indefinitely unless
-     * the run() method is called or the task is scheduled on an Executor.
+     * <em>Important note:</em> The returned task blocks indefinitely unless the {@code run()} method is called
+     * or the task is scheduled on an Executor.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/forEachFuture.png">
      *
@@ -1478,7 +1368,7 @@ public static <T> FutureTask<Void> forEachFuture(
      * @param onError the action to call when an exception is emitted
      * @return the Future representing the entire for-each operation
      * @see #forEachFuture(rx.Observable, rx.functions.Action1, rx.functions.Action1, rx.Scheduler)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
         Observable<? extends T> source,
@@ -1489,11 +1379,11 @@ public static <T> FutureTask<Void> 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.
      * <p>
-     * <em>Important note:</em> The returned task blocks indefinitely unless
-     * the run() method is called or the task is scheduled on an Executor.
+     * <em>Important note:</em> The returned task blocks indefinitely unless the {@code run()} method is called
+     * or the task is scheduled on an Executor.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/forEachFuture.png">
      *
@@ -1504,7 +1394,7 @@ public static <T> FutureTask<Void> forEachFuture(
      * @param onCompleted the action to call when the source completes
      * @return the Future representing the entire for-each operation
      * @see #forEachFuture(rx.Observable, rx.functions.Action1, rx.functions.Action1, rx.functions.Action0, rx.Scheduler)
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
         Observable<? extends T> source,
@@ -1516,19 +1406,17 @@ public static <T> FutureTask<Void> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/forEachFuture.s.png">
      *
      * @param <T> the source value type
      * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
             Observable<? extends T> source,
@@ -1542,9 +1430,8 @@ public static <T> FutureTask<Void> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/forEachFuture.s.png">
      *
@@ -1552,10 +1439,9 @@ public static <T> FutureTask<Void> forEachFuture(
      * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
             Observable<? extends T> source,
@@ -1570,9 +1456,8 @@ public static <T> FutureTask<Void> 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/forEachFuture.s.png">
      *
@@ -1581,10 +1466,9 @@ public static <T> FutureTask<Void> forEachFuture(
      * @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
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#foreachfuture">RxJava Wiki: forEachFuture()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-foreachfuture">RxJava Wiki: forEachFuture()</a>
      */
     public static <T> FutureTask<Void> forEachFuture(
             Observable<? extends T> source,
@@ -1599,8 +1483,7 @@ public static <T> FutureTask<Void> forEachFuture(
     }
     
     /**
-     * Return an Observable that 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromAction.png">
      * <p>
@@ -1609,17 +1492,16 @@ public static <T> FutureTask<Void> forEachFuture(
      * @param <R> the return type
      * @param action the action to invoke on each subscription
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromaction">RxJava Wiki: fromAction()</a>
+     * @return an Observable that calls the given action and emits the given result when an Observer subscribes
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-fromaction">RxJava Wiki: fromAction()</a>
      */
     public static <R> Observable<R> fromAction(Action0 action, R result) {
         return fromAction(action, result, Schedulers.computation());
     }
     
     /**
-     * Return an Observable that 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromCallable.png">
      * <p>
@@ -1627,18 +1509,18 @@ public static <R> Observable<R> fromAction(Action0 action, R result) {
      * 
      * @param <R> the return type
      * @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
+     * @return an Observable that calls the given Callable and emits its result or Exception when an Observer
+     *         subscribes
      * @see #start(rx.functions.Func0) 
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromcallable">RxJava Wiki: fromCallable()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-fromcallable">RxJava Wiki: fromCallable()</a>
      */
     public static <R> Observable<R> fromCallable(Callable<? extends R> callable) {
         return fromCallable(callable, Schedulers.computation());
     }
     
     /**
-     * Return an Observable that 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromRunnable.png">
      * <p>
@@ -1647,96 +1529,96 @@ public static <R> Observable<R> fromCallable(Callable<? extends R> callable) {
      * @param <R> the return type
      * @param run the runnable to invoke on each subscription
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromrunnable">RxJava Wiki: fromRunnable()</a>
+     * @return an Observable that calls the given Runnable and emits the given result when an Observer
+     *         subscribes
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-fromrunnable">RxJava Wiki: fromRunnable()</a>
      */
     public static <R> Observable<R> fromRunnable(final Runnable run, final R result) {
         return fromRunnable(run, result, Schedulers.computation());
     }
     
     /**
-     * Return an Observable that 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromAction.s.png">
      * 
      * @param <R> 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 that calls the given action and emits the given
-     *         result when an Observer subscribes
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromaction">RxJava Wiki: fromAction()</a>
+     * @return an Observable that calls the given action and emits the given result when an Observer subscribes
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-fromaction">RxJava Wiki: fromAction()</a>
      */
     public static <R> Observable<R> fromAction(Action0 action, R result, Scheduler scheduler) {
         return Observable.create(OperatorFromFunctionals.fromAction(action, result)).subscribeOn(scheduler);
     }
     
     /**
-     * Return an Observable that 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromCallable.s.png">
      * 
      * @param <R> 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 that 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.functions.Func0) 
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromcallable">RxJava Wiki: fromCallable()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-fromcallable">RxJava Wiki: fromCallable()</a>
      */
     public static <R> Observable<R> fromCallable(Callable<? extends R> callable, Scheduler scheduler) {
         return Observable.create(OperatorFromFunctionals.fromCallable(callable)).subscribeOn(scheduler);
     }
     
     /**
-     * Return an Observable that 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.
      * <p>
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/fromRunnable.s.png">
      * 
      * @param <R> 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 that calls the given Runnable and emits the given
-     *         result when an Observer subscribes
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#fromrunnable">RxJava Wiki: fromRunnable()</a>
+     * @return an Observable that calls the given Runnable and emits the given result when an Observer
+     *         subscribes
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-fromrunnable">RxJava Wiki: fromRunnable()</a>
      */
     public static <R> Observable<R> fromRunnable(final Runnable run, final R result, Scheduler scheduler) {
         return Observable.create(OperatorFromFunctionals.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.
+     * 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 <T> 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
+     * @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 it check for cancellation condition
+     * @return an Observable that provides a Subscription interface to cancel the action
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-runasync">RxJava Wiki: runAsync()</a>
      */
     public static <T> StoppableObservable<T> runAsync(Scheduler scheduler, 
             final Action2<? super Observer<? super T>, ? super Subscription> action) {
         return runAsync(scheduler, PublishSubject.<T>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.
+     * 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 <T> the output value of the action
      * @param <U> the output type of the observable sequence
-     * @param scheduler the scheduler where the action is executed
+     * @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
+     * @param action the action to execute, receives an Observer where the events can be pumped and a
+     *               Subscription which lets it check for cancellation condition
+     * @return an Observable that provides a Subscription interface to cancel the action
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-runasync">RxJava Wiki: runAsync()</a>
      */
     public static <T, U> StoppableObservable<U> runAsync(Scheduler scheduler,
             final Subject<T, U> subject, 
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
index ebd9538ed5..bbafbe9ce7 100644
--- 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
@@ -19,8 +19,9 @@
 import rx.Subscription;
 
 /**
- * An Observable which provides a Subscription interface to signal a stop
- * condition to an asynchronous task.
+ * An Observable that provides a Subscription interface to signal a stop condition to an asynchronous task.
+ *
+ * @see <a href="https://github.com/Netflix/RxJava/wiki/Async-Operators#wiki-runasync">RxJava Wiki: runAsync()</a>
  */
 public class StoppableObservable<T> extends Observable<T> implements Subscription {
     private final Subscription token;

From 8faa8cbadaa93f0204d77f5d5c62c81be79e6640 Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Thu, 15 May 2014 13:33:05 -0700
Subject: [PATCH 392/422] Might help with questions like in the email thread
 "javadoc for api-sdk in Eclipse: how to?"

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index dc9fe0e55c..3589745629 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -144,6 +144,7 @@ public static interface OnSubscribeFunc<T> extends Function {
      * @param lift
      * @return an Observable that emits values that are the result of applying the bind function to the values
      *         of the current Observable
+     * @since 0.17
      */
     public final <R> Observable<R> lift(final Operator<? extends R, ? super T> lift) {
         return new Observable<R>(new OnSubscribe<R>() {
@@ -2154,6 +2155,7 @@ public final static <T> Observable<T> mergeDelayError(Observable<? extends T> t1
      * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/nest.png">
      * 
      * @return an Observable that emits a single item: the source Observable
+     * @since 0.17
      */
     public final Observable<Observable<T>> nest() {
         return just(this);
@@ -2247,6 +2249,7 @@ public final static <T> Observable<Observable<T>> parallelMerge(Observable<Obser
      * 
      * @param groups
      * @return an Observable containing a stream of nested GroupedObservables with swapped inner-outer keys.
+     * @since 0.17
      */
     public static final <K1, K2, T> Observable<GroupedObservable<K2, GroupedObservable<K1, T>>> pivot(Observable<GroupedObservable<K1, GroupedObservable<K2, T>>> groups) {
         return groups.lift(new OperatorPivot<K1, K2, T>());
@@ -3699,6 +3702,7 @@ public final void onNext(T args) {
      * @return the source Observable with the side-effecting behavior applied
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#wiki-doonterminate">RxJava Wiki: doOnTerminate()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229804.aspx">MSDN: Observable.Do</a>
+     * @since 0.17
      */
     public final Observable<T> doOnTerminate(final Action0 onTerminate) {
         Observer<T> observer = new Observer<T>() {
@@ -4439,6 +4443,7 @@ public final Observable<T> onErrorReturn(Func1<Throwable, ? extends T> resumeFun
      *            of the error
      * @return the original Observable, with appropriately modified behavior
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Error-Handling-Operators#onerrorflatmap">RxJava Wiki: onErrorFlatMap()</a>
+     * @since 0.17
      */
     public final Observable<T> onErrorFlatMap(final Func1<OnErrorThrowable, ? extends Observable<? extends T>> resumeFunction) {
         return lift(new OperatorOnErrorFlatMap<T>(resumeFunction));
@@ -4724,6 +4729,7 @@ public final Observable<T> repeat(Scheduler scheduler) {
      *             if {@code count} is less than zero
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+     * @since 0.17
      */
     public final Observable<T> repeat(long count) {
         if (count < 0) {
@@ -4745,6 +4751,7 @@ public final Observable<T> repeat(long count) {
      * @return an Observable that repeats the sequence of items emitted by the source Observable at most {@code count} times on a particular Scheduler
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-repeat">RxJava Wiki: repeat()</a>
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229428.aspx">MSDN: Observable.Repeat</a>
+     * @since 0.17
      */
     public final Observable<T> repeat(long count, Scheduler scheduler) {
         return nest().lift(new OperatorRepeat<T>(count, scheduler));
@@ -5310,6 +5317,9 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
         return lift(new OperatorScan<R, T>(initialValue, accumulator));
     }
 
+    /*
+     * @since 0.17
+     */
     public final Observable<T> serialize() {
         return lift(new OperatorSerialize<T>());
     }
@@ -6127,6 +6137,7 @@ public void onNext(T t) {
      * 
      * @param subscriber
      * @return Subscription which is the Subscriber passed in
+     * @since 0.17
      */
     public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {
         try {
@@ -7237,6 +7248,7 @@ public final Observable<List<T>> toSortedList(Func2<? super T, ? super T, Intege
      * @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}
+     * @since 0.17
      */
     public final Observable<T> unsubscribeOn(Scheduler scheduler) {
         return lift(new OperatorUnsubscribeOn<T>(scheduler));

From cdad283915cc7ef760ed57dc4b9d4bef455dded4 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Thu, 15 May 2014 21:02:46 -0700
Subject: [PATCH 393/422] Comment out javafx until build is fixed

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

diff --git a/settings.gradle b/settings.gradle
index 48c277fbf6..35d90374f8 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -6,7 +6,7 @@ include 'rxjava-core', \
 'language-adaptors:rxjava-scala', \
 'language-adaptors:rxjava-kotlin', \
 'rxjava-contrib:rxjava-swing', \
-'rxjava-contrib:rxjava-javafx', \
+//'rxjava-contrib:rxjava-javafx', \
 'rxjava-contrib:rxjava-android', \
 'rxjava-contrib:rxjava-android-samples-build-wrapper', \
 'rxjava-contrib:rxjava-apache-http', \

From 0896f70792a28cb83931800df8c830a2b3144a7a Mon Sep 17 00:00:00 2001
From: Matthias Kaeppler <m.kaeppler@gmail.com>
Date: Sat, 17 May 2014 11:35:10 +0200
Subject: [PATCH 394/422] =?UTF-8?q?use=20LinkedList=20to=20buffer=20the=20?=
 =?UTF-8?q?sequence=E2=80=99s=20items?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

LinkedList has guaranteed constant insertion time when appending to the end of the list, whereas ArrayList takes O(1) amortized, since a reallocation might be necessary to insert further items. Since no capacity was specified for the buffer, on Hotspot this would cause the array to reallocate after the first 10 insertions, on Android after the first insertion (since Android’s ArrayList uses a default capacity of zero.)

Since the buffer is copied to an ArrayList before emission, subscriber performance when working with the list should remain unaffected.

Refs #1141
---
 .../main/java/rx/operators/OperatorToObservableList.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java b/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java
index 3466c87ca5..edab32e40d 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorToObservableList.java
@@ -15,12 +15,13 @@
  */
 package rx.operators;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import rx.Observable.Operator;
 import rx.Subscriber;
 
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
 /**
  * Returns an Observable that emits a single item, a list composed of all the items emitted by the
  * source Observable.
@@ -41,7 +42,7 @@ public final class OperatorToObservableList<T> implements Operator<List<T>, T> {
     public Subscriber<? super T> call(final Subscriber<? super List<T>> o) {
         return new Subscriber<T>(o) {
 
-            final List<T> list = new ArrayList<T>();
+            final List<T> list = new LinkedList<T>();
 
             @Override
             public void onCompleted() {

From f85219adfbee2b8002d00d0f0bd990b384db4402 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 18 May 2014 16:35:52 +0800
Subject: [PATCH 395/422] Update CompletenessTest.scala for new operators

---
 .../rx/lang/scala/CompletenessTest.scala      | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 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 6d249289b0..444b5e3dd0 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
@@ -45,6 +45,7 @@ class CompletenessTest extends JUnitSuite {
   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?]"
+  val commentForTakeLastBuffer = "[use `takeRight(...).toSeq`]"
 
   /**
    * Maps each method from the Java Observable to its corresponding method in the Scala Observable
@@ -71,8 +72,14 @@ class CompletenessTest extends JUnitSuite {
       "all(Func1[_ >: T, Boolean])" -> "forall(T => Boolean)",
       "buffer(Long, Long, TimeUnit)" -> "buffer(Duration, Duration)",
       "buffer(Long, Long, TimeUnit, Scheduler)" -> "buffer(Duration, Duration, Scheduler)",
+      "buffer(Func0[_ <: Observable[_ <: TClosing]])" -> "buffer(() => Observable[Any])",
+      "buffer(Observable[B])" -> "buffer(Observable[Any])",
+      "buffer(Observable[B], Int)" -> "buffer(Observable[Any], Int)",
+      "buffer(Observable[_ <: TOpening], Func1[_ >: TOpening, _ <: Observable[_ <: TClosing]])" -> "buffer(Observable[Opening], Opening => Observable[Any])",
       "contains(T)" -> "contains(Any)",
       "count()" -> "length",
+      "delay(Func0[_ <: Observable[U]], Func1[_ >: T, _ <: Observable[V]])" -> "delay(() => Observable[Any], T => Observable[Any])",
+      "delay(Func1[_ >: T, _ <: Observable[U]])" -> "delay(T => Observable[Any])",
       "dematerialize()" -> "dematerialize(<:<[Observable[T], Observable[Notification[U]]])",
       "elementAt(Int)" -> "[use `.drop(index).first`]",
       "elementAtOrDefault(Int, T)" -> "[use `.drop(index).firstOrElse(default)`]",
@@ -116,6 +123,15 @@ class CompletenessTest extends JUnitSuite {
       "takeFirst()" -> "first",
       "takeFirst(Func1[_ >: T, Boolean])" -> commentForFirstWithPredicate,
       "takeLast(Int)" -> "takeRight(Int)",
+      "takeLast(Long, TimeUnit)" -> "takeRight(Duration)",
+      "takeLast(Long, TimeUnit, Scheduler)" -> "takeRight(Duration, Scheduler)",
+      "takeLast(Int, Long, TimeUnit)" -> "takeRight(Int, Duration)",
+      "takeLast(Int, Long, TimeUnit, Scheduler)" -> "takeRight(Int, Duration, Scheduler)",
+      "takeLastBuffer(Int)" -> commentForTakeLastBuffer,
+      "takeLastBuffer(Int, Long, TimeUnit)" -> commentForTakeLastBuffer,
+      "takeLastBuffer(Int, Long, TimeUnit, Scheduler)" -> commentForTakeLastBuffer,
+      "takeLastBuffer(Long, TimeUnit)" -> commentForTakeLastBuffer,
+      "takeLastBuffer(Long, TimeUnit, Scheduler)" -> commentForTakeLastBuffer,
       "takeWhileWithIndex(Func2[_ >: T, _ >: Integer, Boolean])" -> "[use `.zipWithIndex.takeWhile{case (elem, index) => condition}.map(_._1)`]",
       "timeout(Func0[_ <: Observable[U]], Func1[_ >: T, _ <: Observable[V]], Observable[_ <: T])" -> "timeout(() => Observable[U], T => Observable[V], Observable[O])",
       "timeout(Func1[_ >: T, _ <: Observable[V]], Observable[_ <: T])" -> "timeout(() => Observable[U], T => Observable[V])",
@@ -154,8 +170,8 @@ class CompletenessTest extends JUnitSuite {
       "range(Int, Int)" -> "apply(Range)",
       "repeat()" -> "repeat()",
       "retry()" -> "retry()",
-      "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))`]",
+      "sequenceEqual(Observable[_ <: T], Observable[_ <: T])" -> "sequenceEqual(Observable[U])",
+      "sequenceEqual(Observable[_ <: T], Observable[_ <: T], Func2[_ >: T, _ >: T, Boolean])" -> "sequenceEqual(Observable[U], (U, U) => Boolean)",
       "sum(Observable[Integer])" -> "sum(Numeric[U])",
       "sumDoubles(Observable[Double])" -> "sum(Numeric[U])",
       "sumFloats(Observable[Float])" -> "sum(Numeric[U])",

From 2e46c824a3b347656b80fd341cf0f2ece86de0e8 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Sun, 18 May 2014 17:02:14 +0800
Subject: [PATCH 396/422] Eliminate compiler warnings

---
 .../scala/rx/lang/scala/examples/RxScalaDemo.scala         | 3 +--
 .../src/main/scala/rx/lang/scala/Observable.scala          | 7 +++----
 2 files changed, 4 insertions(+), 6 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 d040306432..de6ae6b310 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
@@ -555,11 +555,10 @@ class RxScalaDemo extends JUnitSuite {
    * all elements are calculated.
    */
   @Test def createExampleBad() {
-    val o = Observable.create[String](observer => {
+    val o = Observable[String](observer => {
       observer.onNext(calculateElement(0))
       observer.onNext(calculateElement(1))
       observer.onCompleted()
-      Subscription {}
     })
     o.take(1).subscribe(println(_))
   }
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 6e91377c97..38c7b73dc0 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
@@ -21,6 +21,7 @@ import rx.Observable.OnSubscribeFunc
 import rx.lang.scala.observables.ConnectableObservable
 import scala.concurrent.duration
 import java.util
+import java.util.concurrent.TimeUnit
 import collection.JavaConversions._
 
 
@@ -2968,9 +2969,8 @@ trait Observable[+T]
    * @return an Observable that emits time interval information items
    */
   def timeInterval: Observable[(Duration, T)] = {
-    import scala.concurrent.duration.DurationLong
     toScalaObservable(asJavaObservable.timeInterval())
-      .map(inv => (inv.getIntervalInMilliseconds millis, inv.getValue))
+      .map(inv => (Duration(inv.getIntervalInMilliseconds, TimeUnit.MILLISECONDS), inv.getValue))
   }
 
   /**
@@ -2983,9 +2983,8 @@ trait Observable[+T]
    * @return an Observable that emits time interval information items
    */
   def timeInterval(scheduler: Scheduler): Observable[(Duration, T)] = {
-    import scala.concurrent.duration.DurationLong
     toScalaObservable(asJavaObservable.timeInterval(scheduler.asJavaScheduler))
-      .map(inv => (inv.getIntervalInMilliseconds millis, inv.getValue))
+      .map(inv => (Duration(inv.getIntervalInMilliseconds, TimeUnit.MILLISECONDS), inv.getValue))
   }
 
   /**

From 039378f784dc42eef051ce7ebcf257879904b928 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 19 May 2014 10:25:17 +0800
Subject: [PATCH 397/422] Fix the initialization order

---
 .../src/main/scala/rx/lang/scala/Subscriber.scala      | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
index 38934742c9..2b5d714076 100644
--- a/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
+++ b/language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Subscriber.scala
@@ -3,16 +3,16 @@ package rx.lang.scala
 trait Subscriber[-T] extends Observer[T] with Subscription {
 
   self =>
-  
-  private [scala] override val asJavaObserver: rx.Observer[_ >: T] = asJavaSubscriber
-  private [scala] override val asJavaSubscription: rx.Subscription = asJavaSubscriber
-  
+
   private [scala] val asJavaSubscriber: rx.Subscriber[_ >: T] = new rx.Subscriber[T] {
     def onNext(value: T): Unit = self.onNext(value)
     def onError(error: Throwable): Unit = self.onError(error)
     def onCompleted(): Unit = self.onCompleted()
   }
-  
+
+  private [scala] override val asJavaObserver: rx.Observer[_ >: T] = asJavaSubscriber
+  private [scala] override val asJavaSubscription: rx.Subscription = asJavaSubscriber
+
   /**
    * Used to register an unsubscribe callback.
    */

From 0cff93d2258a141371e27bf71ac741f7771d0052 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Mon, 19 May 2014 11:10:58 +0800
Subject: [PATCH 398/422] Revert createExampleBad and import
 scala.concurrent.duration.MILLISECONDS

---
 .../scala/rx/lang/scala/examples/RxScalaDemo.scala         | 3 ++-
 .../src/main/scala/rx/lang/scala/Observable.scala          | 7 +++----
 2 files changed, 5 insertions(+), 5 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 de6ae6b310..d040306432 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
@@ -555,10 +555,11 @@ class RxScalaDemo extends JUnitSuite {
    * all elements are calculated.
    */
   @Test def createExampleBad() {
-    val o = Observable[String](observer => {
+    val o = Observable.create[String](observer => {
       observer.onNext(calculateElement(0))
       observer.onNext(calculateElement(1))
       observer.onCompleted()
+      Subscription {}
     })
     o.take(1).subscribe(println(_))
   }
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 38c7b73dc0..6b19da8cde 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
@@ -21,7 +21,6 @@ import rx.Observable.OnSubscribeFunc
 import rx.lang.scala.observables.ConnectableObservable
 import scala.concurrent.duration
 import java.util
-import java.util.concurrent.TimeUnit
 import collection.JavaConversions._
 
 
@@ -80,7 +79,7 @@ trait Observable[+T]
 {
   import scala.collection.JavaConverters._
   import scala.collection.Seq
-  import scala.concurrent.duration.{Duration, TimeUnit}
+  import scala.concurrent.duration.{Duration, TimeUnit, MILLISECONDS}
   import rx.functions._
   import rx.lang.scala.observables.BlockingObservable
   import ImplicitFunctionConversions._
@@ -2970,7 +2969,7 @@ trait Observable[+T]
    */
   def timeInterval: Observable[(Duration, T)] = {
     toScalaObservable(asJavaObservable.timeInterval())
-      .map(inv => (Duration(inv.getIntervalInMilliseconds, TimeUnit.MILLISECONDS), inv.getValue))
+      .map(inv => (Duration(inv.getIntervalInMilliseconds, MILLISECONDS), inv.getValue))
   }
 
   /**
@@ -2984,7 +2983,7 @@ trait Observable[+T]
    */
   def timeInterval(scheduler: Scheduler): Observable[(Duration, T)] = {
     toScalaObservable(asJavaObservable.timeInterval(scheduler.asJavaScheduler))
-      .map(inv => (Duration(inv.getIntervalInMilliseconds, TimeUnit.MILLISECONDS), inv.getValue))
+      .map(inv => (Duration(inv.getIntervalInMilliseconds, MILLISECONDS), inv.getValue))
   }
 
   /**

From 044c13c7d9a3d824275ea8b486aa362876793d95 Mon Sep 17 00:00:00 2001
From: Haney Maxwell <hmrmaxwell@gmail.com>
Date: Mon, 19 May 2014 12:03:34 -0700
Subject: [PATCH 399/422] Exposing PublishSubject

All other subjects (Async, Behavior, Replay) have non-private companion objects.
---
 .../src/main/scala/rx/lang/scala/subjects/PublishSubject.scala  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 129717d8cc..577f6693ea 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,7 +17,7 @@ package rx.lang.scala.subjects
 
 import rx.lang.scala.Subject
 
-private [scala] object PublishSubject {
+object PublishSubject {
   def apply[T](): PublishSubject[T] =  new PublishSubject[T](rx.subjects.PublishSubject.create[T]())
 }
 

From d475bab09001be925b9943e3e282ad3f74abf7be Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Mon, 19 May 2014 23:50:05 -0700
Subject: [PATCH 400/422] Javadoc: Inner -> Worker

https://github.com/Netflix/RxJava/issues/808
---
 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 95fd31d85e..ea6ca51aa8 100644
--- a/rxjava-core/src/main/java/rx/Scheduler.java
+++ b/rxjava-core/src/main/java/rx/Scheduler.java
@@ -48,7 +48,7 @@ public abstract class Scheduler {
      * <p>
      * Work on a {@link Scheduler.Worker} is guaranteed to be sequential.
      * 
-     * @return Inner representing a serial queue of actions to be executed
+     * @return Worker representing a serial queue of actions to be executed
      */
     public abstract Worker createWorker();
 

From 07d65839bf1a78850621aae5420648f402fd0905 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@gmail.com>
Date: Tue, 20 May 2014 00:20:15 -0700
Subject: [PATCH 401/422] Re-enable testStaggeredCompletion

See https://github.com/Netflix/RxJava/issues/1011
---
 rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index 212cca5027..ebc6ee8183 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -429,7 +429,6 @@ public void call(String s) {
         assertEquals(37, sentEventCounter.get());
     }
 
-    @Ignore // ignore until https://github.com/Netflix/RxJava/issues/1011 is fixed
     @Test
     public void testStaggeredCompletion() throws InterruptedException {
         final AtomicInteger eventCounter = new AtomicInteger();

From c7ce158d3bd3128b0ca7f7f892c86fd87d539e3d Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Tue, 20 May 2014 12:32:42 +0200
Subject: [PATCH 402/422] ReplaySubject enhancement with time and/or size
 bounds

---
 rxjava-core/src/main/java/rx/Observable.java  |  16 +-
 .../java/rx/operators/OperatorReplay.java     | 729 +----------------
 .../main/java/rx/subjects/AsyncSubject.java   |   5 +-
 .../java/rx/subjects/BehaviorSubject.java     |   3 -
 .../main/java/rx/subjects/ReplaySubject.java  | 760 ++++++++++++++++--
 .../subjects/SubjectSubscriptionManager.java  |  10 -
 .../java/rx/operators/OperatorReplayTest.java |  59 +-
 .../ReplaySubjectBoundedConcurrencyTest.java  | 340 ++++++++
 .../java/rx/subjects/ReplaySubjectTest.java   | 152 ++++
 9 files changed, 1178 insertions(+), 896 deletions(-)
 create mode 100644 rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 3589745629..9e27a7d846 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4821,7 +4821,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
         return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperatorReplay.replayBuffered(bufferSize);
+                return ReplaySubject.<T>createWithSize(bufferSize);
             }
         }, selector));
     }
@@ -4889,7 +4889,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
         return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperatorReplay.replayWindowed(time, unit, bufferSize, scheduler);
+                return ReplaySubject.<T>createWithTimeAndSize(time, unit, bufferSize, scheduler);
             }
         }, selector));
     }
@@ -4920,7 +4920,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
         return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperatorReplay.<T> createScheduledSubject(OperatorReplay.<T> replayBuffered(bufferSize), scheduler);
+                return OperatorReplay.<T> createScheduledSubject(ReplaySubject.<T>createWithSize(bufferSize), scheduler);
             }
         }, selector));
     }
@@ -4979,7 +4979,7 @@ public final <R> Observable<R> replay(Func1<? super Observable<T>, ? extends Obs
         return create(new OperatorMulticastSelector<T, T, R>(this, new Func0<Subject<T, T>>() {
             @Override
             public final Subject<T, T> call() {
-                return OperatorReplay.replayWindowed(time, unit, -1, scheduler);
+                return ReplaySubject.<T>createWithTime(time, unit, scheduler);
             }
         }, selector));
     }
@@ -5028,7 +5028,7 @@ public final Subject<T, T> call() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211976.aspx">MSDN: Observable.Replay</a>
      */
     public final ConnectableObservable<T> replay(int bufferSize) {
-        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayBuffered(bufferSize));
+        return new OperatorMulticast<T, T>(this, ReplaySubject.<T>createWithSize(bufferSize));
     }
 
     /**
@@ -5081,7 +5081,7 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
         if (bufferSize < 0) {
             throw new IllegalArgumentException("bufferSize < 0");
         }
-        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, bufferSize, scheduler));
+        return new OperatorMulticast<T, T>(this, ReplaySubject.<T>createWithTimeAndSize(time, unit, bufferSize, scheduler));
     }
 
     /**
@@ -5104,7 +5104,7 @@ public final ConnectableObservable<T> replay(int bufferSize, long time, TimeUnit
     public final ConnectableObservable<T> replay(int bufferSize, Scheduler scheduler) {
         return new OperatorMulticast<T, T>(this,
                 OperatorReplay.createScheduledSubject(
-                        OperatorReplay.<T> replayBuffered(bufferSize), scheduler));
+                        ReplaySubject.<T>createWithSize(bufferSize), scheduler));
     }
 
     /**
@@ -5148,7 +5148,7 @@ public final ConnectableObservable<T> replay(long time, TimeUnit unit) {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh211811.aspx">MSDN: Observable.Replay</a>
      */
     public final ConnectableObservable<T> replay(long time, TimeUnit unit, Scheduler scheduler) {
-        return new OperatorMulticast<T, T>(this, OperatorReplay.<T> replayWindowed(time, unit, -1, scheduler));
+        return new OperatorMulticast<T, T>(this, ReplaySubject.<T>createWithTime(time, unit, scheduler));
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/operators/OperatorReplay.java b/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
index 67dd9e5496..0452ca3712 100644
--- a/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
+++ b/rxjava-core/src/main/java/rx/operators/OperatorReplay.java
@@ -15,25 +15,11 @@
  */
 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.OnSubscribe;
 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;
 
 /**
@@ -48,17 +34,6 @@ private OperatorReplay() {
         throw new IllegalStateException("No instances!");
     }
 
-    /**
-     * Create a CustomReplaySubject with the given buffer size.
-     * 
-     * @param <T> the element type
-     * @param bufferSize the maximum number of items to keep in the buffer
-     * @return the created subject
-     */
-    public static <T> Subject<T, T> replayBuffered(int bufferSize) {
-        return CustomReplaySubject.create(bufferSize);
-    }
-
     /**
      * Creates a subject whose client observers will observe events
      * propagated through the given wrapped subject.
@@ -80,74 +55,6 @@ public void call(Subscriber<? super T> o) {
         return s;
     }
 
-    /**
-     * Create a CustomReplaySubject with the given time window length
-     * and optional buffer size.
-     * 
-     * @param <T>
-     *            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 <T> Subject<T, T> 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!");
-        }
-        Func1<T, Timestamped<T>> timestamp = new Func1<T, Timestamped<T>>() {
-            @Override
-            public Timestamped<T> call(T t1) {
-                return new Timestamped<T>(scheduler.now(), t1);
-            }
-        };
-        Func1<Timestamped<T>, T> untimestamp = new Func1<Timestamped<T>, T>() {
-            @Override
-            public T call(Timestamped<T> t1) {
-                return t1.getValue();
-            }
-        };
-
-        ReplayState<Timestamped<T>, T> state;
-
-        if (bufferSize >= 0) {
-            state = new ReplayState<Timestamped<T>, T>(new VirtualBoundedList<Timestamped<T>>(bufferSize), untimestamp);
-        } else {
-            state = new ReplayState<Timestamped<T>, T>(new VirtualArrayList<Timestamped<T>>(), untimestamp);
-        }
-        final ReplayState<Timestamped<T>, 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<T> 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, Timestamped<T>, T> brs = new CustomReplaySubject<T, Timestamped<T>, T>(
-                new CustomReplaySubjectSubscribeFunc<Timestamped<T>, T>(state), state, timestamp
-                );
-
-        return brs;
-    }
-
     /**
      * Return an OnSubscribeFunc which delegates the subscription to the given observable.
      * 
@@ -193,638 +100,4 @@ public void 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 <T>
-     *            the value type
-     */
-    public interface VirtualList<T> {
-        /** @return the number of elements in this list */
-        int size();
-
-        /**
-         * 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 the element
-         */
-        T get(int index);
-
-        /**
-         * Remove elements up before the given logical index and move
-         * the start() to this index.
-         * <p>
-         * 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 the head index
-         */
-        int start();
-
-        /**
-         * Returns the current tail index of this list (where the next value would appear).
-         * 
-         * @return the tail index
-         */
-        int end();
-
-        /**
-         * Clears and resets the indexes of the list.
-         */
-        void reset();
-
-        /**
-         * Returns the current content as a list.
-         * 
-         * @return the {@link java.util.List} representation of this virtual list
-         */
-        List<T> toList();
-    }
-
-    /**
-     * Behaves like a normal, unbounded ArrayList but with virtual index.
-     * @param <T> the element type
-     */
-    public static final class VirtualArrayList<T> implements VirtualList<T> {
-        /** The backing list . */
-        final List<T> list = new ArrayList<T>();
-        /** 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;
-        }
-
-        @Override
-        public List<T> toList() {
-            return new ArrayList<T>(list);
-        }
-
-    }
-
-    /**
-     * A bounded list which increases its size up to a maximum capacity, then
-     * behaves like a circular buffer with virtual indexes.
-     * 
-     * @param <T> the element type
-     */
-    public static final class VirtualBoundedList<T> implements VirtualList<T> {
-        /** A list that grows up to maxSize. */
-        private final List<T> list = new ArrayList<T>();
-        /** 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;
-        }
-
-        @Override
-        public List<T> toList() {
-            List<T> r = new ArrayList<T>(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 <TIntermediate>
-     *            the intermediate type stored in the values buffer
-     * @param <TResult>
-     *            the result type transformed via the resultSelector
-     */
-    static final class ReplayState<TIntermediate, TResult> extends BaseState {
-        /** The values observed so far. */
-        final VirtualList<TIntermediate> values;
-        /** The result selector. */
-        final Func1<? super TIntermediate, ? extends TResult> resultSelector;
-        /** The received error. */
-        Throwable error;
-        /** General completion indicator. */
-        boolean done;
-        /** The map of replayers. */
-        final Map<Subscription, Replayer> replayers = new LinkedHashMap<Subscription, Replayer>();
-        /**
-         * Callback once a value has been added but before it is replayed
-         * (I.e, run a time based eviction policy).
-         * <p>
-         * 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).
-         * <p>
-         * 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).
-         * <p>
-         * 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).
-         * <p>
-         * 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<TIntermediate> values,
-                final Func1<? super TIntermediate, ? extends TResult> resultSelector) {
-            this.values = values;
-            this.resultSelector = resultSelector;
-        }
-
-        /**
-         * Returns a live collection of the observers.
-         * <p>
-         * Caller should hold the lock.
-         * 
-         * @return
-         */
-        Collection<Replayer> replayers() {
-            return new ArrayList<Replayer>(replayers.values());
-        }
-
-        /**
-         * Add a replayer to the replayers and create a Subscription for it.
-         * <p>
-         * Caller should hold the lock.
-         * 
-         * @param obs
-         * @return
-         */
-        Subscription addReplayer(Subscriber<? super TResult> obs) {
-            Subscription s = new Subscription() {
-                final AtomicBoolean once = new AtomicBoolean();
-
-                @Override
-                public void unsubscribe() {
-                    if (once.compareAndSet(false, true)) {
-                        remove(this);
-                    }
-                }
-
-                @Override
-                public boolean isUnsubscribed() {
-                    return once.get();
-                }
-
-            };
-            obs.add(s);
-            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 Subscriber<? super TResult> 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(Subscriber<? super TResult> 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.
-         * <p>
-         * 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 <TInput>
-     *            the Observer side's value type
-     * @param <TIntermediate>
-     *            the type of the elements in the replay buffer
-     * @param <TResult>
-     *            the value type of the observers subscribing to this subject
-     */
-    public static final class CustomReplaySubject<TInput, TIntermediate, TResult> extends Subject<TInput, TResult> {
-        /**
-         * Return a subject that retains all events and will replay them to an {@link Subscriber} that subscribes.
-         * @param <T> the common value type
-         * @return a subject that retains all events and will replay them to an {@link Subscriber} that subscribes.
-         */
-        public static <T> CustomReplaySubject<T, T, T> create() {
-            ReplayState<T, T> state = new ReplayState<T, T>(new VirtualArrayList<T>(), Functions.<T> identity());
-            return new CustomReplaySubject<T, T, T>(
-                    new CustomReplaySubjectSubscribeFunc<T, T>(state), state,
-                    Functions.<T> identity());
-        }
-
-        /**
-         * Create a bounded replay subject with the given maximum buffer size.
-         * 
-         * @param <T> the common value type
-         * @param maxSize
-         *            the maximum size in number of onNext notifications
-         * @return the custom replay subject
-         */
-        public static <T> CustomReplaySubject<T, T, T> create(int maxSize) {
-            ReplayState<T, T> state = new ReplayState<T, T>(new VirtualBoundedList<T>(maxSize), Functions.<T> identity());
-            return new CustomReplaySubject<T, T, T>(
-                    new CustomReplaySubjectSubscribeFunc<T, T>(state), state,
-                    Functions.<T> identity());
-        }
-
-        /** The replay state. */
-        protected final ReplayState<TIntermediate, TResult> state;
-        /** The result selector. */
-        protected final Func1<? super TInput, ? extends TIntermediate> intermediateSelector;
-
-        private CustomReplaySubject(
-                final OnSubscribe<TResult> onSubscribe,
-                ReplayState<TIntermediate, TResult> state,
-                Func1<? super TInput, ? extends TIntermediate> intermediateSelector) {
-            super(new OnSubscribe<TResult>() {
-
-                @Override
-                public void call(Subscriber<? super TResult> sub) {
-                    onSubscribe.call(sub);
-                }
-
-            });
-            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<TIntermediate, TResult>.Replayer rp : state.replayers()) {
-                rp.replayTill(s);
-            }
-        }
-    }
-
-    /**
-     * The subscription function.
-     * 
-     * @param <TIntermediate>
-     *            the type of the elements in the replay buffer
-     * @param <TResult>
-     *            the value type of the observers subscribing to this subject
-     */
-    protected static final class CustomReplaySubjectSubscribeFunc<TIntermediate, TResult>
-            implements Observable.OnSubscribe<TResult> {
-
-        private final ReplayState<TIntermediate, TResult> state;
-
-        protected CustomReplaySubjectSubscribeFunc(ReplayState<TIntermediate, TResult> state) {
-            this.state = state;
-        }
-
-        @Override
-        public void call(Subscriber<? super TResult> t1) {
-            VirtualList<TIntermediate> values;
-            Throwable error;
-            state.lock();
-            try {
-                if (!state.done) {
-                    state.onSubscription.call();
-                    state.addReplayer(t1);
-                    return;
-                }
-                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;
-                }
-            }
-            if (error != null) {
-                t1.onError(error);
-            } else {
-                t1.onCompleted();
-            }
-        }
-    }
-}
+}
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
index a1a65d7c5b..b9057d23d0 100644
--- a/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/AsyncSubject.java
@@ -58,7 +58,10 @@ public static <T> AsyncSubject<T> create() {
             public void call(SubjectObserver<T> o) {
                 Object v = state.get();
                 o.accept(v);
-                o.completeSingle(v);
+                NotificationLite<T> nl = NotificationLite.instance();
+                if (v == null || (!nl.isCompleted(v) && !nl.isError(v))) {
+                    o.onCompleted();
+                }
             }
         };
         return new AsyncSubject<T>(state, state);
diff --git a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
index 78efdc0edf..932d6b0cd3 100644
--- a/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/BehaviorSubject.java
@@ -17,12 +17,9 @@
 
 
 import rx.Observer;
-import rx.Subscriber;
-import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.operators.NotificationLite;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
-import rx.subscriptions.Subscriptions;
 
 /**
  * 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/ReplaySubject.java b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
index 8bfb77be5d..f1de19d760 100644
--- a/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
+++ b/rxjava-core/src/main/java/rx/subjects/ReplaySubject.java
@@ -17,11 +17,18 @@
 
 import java.util.ArrayList;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 
 import rx.Observer;
+import rx.Scheduler;
 import rx.functions.Action1;
+import rx.functions.Func1;
+import rx.functions.Functions;
 import rx.operators.NotificationLite;
+import rx.schedulers.Timestamped;
+import rx.subjects.ReplaySubject.NodeList.Node;
 import rx.subjects.SubjectSubscriptionManager.SubjectObserver;
 
 /**
@@ -45,164 +52,302 @@
 
   } </pre>
  * 
- * @param <T>
+ * @param <T> the input and output type
  */
 public final class ReplaySubject<T> extends Subject<T, T> {
+    /**
+     * Create an unbounded replay subject.
+     * <p>The internal buffer is backed by an {@link ArrayList} and starts with
+     * an initial capacity of 16. Once the number of elements reaches this capacity,
+     * it will grow as necessary (usually by 50%). However, as the number of
+     * elements grows, this causes frequent array reallocation and copying, and
+     * may hurt performance and latency. This can be avoided with the {@link #create(int)}
+     * overload which takes an initial capacity parameter and can be tuned to
+     * reduce the array reallocation frequency as needed.
+     * @param <T> The input and output types
+     * @return the created subject
+     */
     public static <T> ReplaySubject<T> create() {
         return create(16);
     }
-
-    public static <T> ReplaySubject<T> create(int initialCapacity) {
-        final SubjectSubscriptionManager<T> subscriptionManager = new SubjectSubscriptionManager<T>();
-        final ReplayState<T> state = new ReplayState<T>(initialCapacity);
-        subscriptionManager.onStart = new Action1<SubjectObserver<T>>() {
+    /**
+     * Create an unbounded replay subject with the specified initial buffer capacity.
+     * <p>Use this method to avoid excessive array reallocation while the internal
+     * buffer grows to accomodate new elements. For example, if it is known that the
+     * buffer will hold 32k elements, one can ask the ReplaySubject to preallocate
+     * it internal array with a capacity to hold that many elements. Once the elements
+     * start to arrive, the internal array won't need to grow, creating less garbage and
+     * no overhead due to frequent array-copying.
+     * @param <T> The input and output types
+     * @param capacity the initial buffer capacity
+     * @return the created subject
+     */
+    public static <T> ReplaySubject<T> create(int capacity) {
+        final UnboundedReplayState<T> state = new UnboundedReplayState<T>(capacity);
+        SubjectSubscriptionManager<T> ssm = new SubjectSubscriptionManager<T>();
+        ssm.onStart = new Action1<SubjectObserver<T>>() {
             @Override
             public void call(SubjectObserver<T> o) {
                 // replay history for this observer using the subscribing thread
-                int lastIndex = replayObserverFromIndex(state.history, 0, o);
+                int lastIndex = state.replayObserverFromIndex(0, o);
 
                 // now that it is caught up add to observers
                 state.replayState.put(o, lastIndex);
             }
         };
-        subscriptionManager.onTerminated = new Action1<SubjectObserver<T>>() {
+        ssm.onTerminated = new Action1<SubjectObserver<T>>() {
             @Override
             public void call(SubjectObserver<T> o) {
                 Integer idx = state.replayState.remove(o);
                 if (idx == null) {
                     idx = 0;
                 }
-                replayObserverFromIndex(state.history, idx, o);
+                // we will finish replaying if there is anything left
+                state.replayObserverFromIndex(idx, o);
             }
         };
-        subscriptionManager.onUnsubscribed = new Action1<SubjectObserver<T>>() {
+        ssm.onUnsubscribed = new Action1<SubjectObserver<T>>() {
             @Override
             public void call(SubjectObserver<T> o) {
                 state.replayState.remove(o);
             }
         };
-        return new ReplaySubject<T>(subscriptionManager, subscriptionManager, state);
+        
+        return new ReplaySubject<T>(ssm, ssm, state);
     }
-
-    private static class ReplayState<T> {
-        // single-producer, multi-consumer
-        final History<T> history;
-        // each Observer is tracked here for what events they have received
-        final ConcurrentHashMap<Observer<? super T>, Integer> replayState;
-
-        public ReplayState(int initialCapacity) {
-            history = new History<T>(initialCapacity);
-            replayState = new ConcurrentHashMap<Observer<? super T>, Integer>();
-        }
+    /**
+     * Create an unbounded replay subject with the bounded-implementation for testing purposes.
+     * <p>This variant behaves like the regular unbounded ReplaySubject created via {@link #create()}
+     * but uses the structures of the bounded-implementation. This is by no means intended
+     * for the replacement of the original, array-backed and unbounded ReplaySubject due to
+     * the additional overhead of the linked-list based internal buffer. The sole purpose
+     * is to allow testing and reasoning about the behavior of the bounded implementations
+     * without the interference of the eviction policies.
+     * @param <T> the input and output types
+     * @return the created subject
+     */
+    /* public */ static <T> ReplaySubject<T> createUnbounded() {
+        final BoundedState<T> state = new BoundedState<T>(
+            new EmptyEvictionPolicy(),
+            Functions.identity(),
+            Functions.identity()
+        );
+        return createWithState(state, new DefaultOnAdd<T>(state));
+    }
+    /**
+     * Create a size-bounded replay subject.
+     * <p>In this setting, the ReplaySubject holds at most {@code size} elements in its
+     * internal buffer and discards the oldest element. 
+     * <p>When observers subscribe to a terminated
+     * ReplaySubject, they are guaranteed to see at most {@code size} onNext events followed by 
+     * a termination event. 
+     * <p>In case an observer subscribes while the ReplaySubject is active, it
+     * will receive all events from within the buffer at that point in time and each event afterwards,
+     * even if the buffer evicts elements due to the size constraint in the mean time. 
+     * In other terms, once an Observer subscribes, it will receive events without gaps in the sequence.
+     * @param <T> the input and output types
+     * @param size the maximum number of buffered items
+     * @return the created subject
+     */
+    public static <T> ReplaySubject<T> createWithSize(int size) {
+        final BoundedState<T> state = new BoundedState<T>(
+            new SizeEvictionPolicy(size),
+            Functions.identity(),
+            Functions.identity()
+        );
+        return createWithState(state, new DefaultOnAdd<T>(state));
+    }
+    /**
+     * Create a time-bounded replay subject.
+     * <p>In this setting, the ReplaySubject tags each received onNext event internally with a timestamp
+     * value supplied by the {@link Scheduler} and keeps only those whose age is less than
+     * the supplied time value converted to milliseconds. For example, a value arrives at T=0 and the max age
+     * is set to 5; at T&gt;=5 this first value is then evicted by any subsequent value or termination event, 
+     * leaving the buffer empty. 
+     * <p>Once the subject is terminated, observers subscribing to it will receive events that
+     * remained in the buffer after the terminal event, regardless of their age. 
+     * <p>In case an observer subscribes while the ReplaySubject is active, it
+     * will receive only those events from within the buffer, which have age less than the specified time and
+     * each event afterwards, even if the buffer evicts elements due to the time constraint in the mean time. 
+     * In other terms, once an Observer subscribes, it receives events without gaps in the sequence except the outdated events
+     * at the beginning of the sequence.
+     * <p>Note that terminal events (onError and onCompleted) trigger eviction as well. For example, with a max age of
+     * 5, the first value arrives at T=0, then an onCompleted arrives at T=10. If an observer subscribes at T=11, it will
+     * find an empty ReplaySubject with just an onCompleted event.
+     * @param <T> the input and output types
+     * @param time the maximum age of the contained items
+     * @param unit the time unit
+     * @param scheduler the scheduler providing the current time
+     * @return the created subject
+     */
+    public static <T> ReplaySubject<T> createWithTime(long time, TimeUnit unit, final Scheduler scheduler) {
+        final BoundedState<T> state = new BoundedState<T>(
+                new TimeEvictionPolicy(unit.toMillis(time), scheduler),
+                new AddTimestamped(scheduler),
+                new RemoveTimestamped()
+        );
+        return createWithState(state, new TimedOnAdd<T>(state, scheduler));
+    }
+    /**
+     * Create a time- and size-bounded replay subject.
+     * <p>In this setting, the ReplaySubject tags each received onNext event internally with a timestamp
+     * value supplied by the {@link Scheduler} and holds at most {@code size} elements in the internal buffer.
+     * Elements are evicted from the start of the buffer if their age becomes less-than or equal 
+     * to the supplied age in milliseconds or the buffer reaches its {@code size} limit.
+     * <p>When observers subscribe to a terminated ReplaySubject, receive the events that
+     * remained in the buffer after the terminal event, regardless of their age, but at most
+     * {@code size} elements.
+     * <p>In case an observer subscribes while the ReplaySubject is active, it
+     * will receive only those events from within the buffer, which have age less than the specified time and
+     * each event afterwards, even if the buffer evicts elements due to the time constraint in the mean time. 
+     * In other terms, once an Observer subscribes, it receives events without gaps in the sequence except the outdated events
+     * at the beginning of the sequence.
+     * <p>Note that terminal events (onError and onCompleted) trigger eviction as well. For example, with a max age of
+     * 5, the first value arrives at T=0, then an onCompleted arrives at T=10. If an observer subscribes at T=11, it will
+     * find an empty ReplaySubject with just an onCompleted event.
+     * @param <T> the input and output types
+     * @param time the maximum age of the contained items
+     * @param unit the time unit
+     * @param size the maximum number of buffered items
+     * @param scheduler the scheduler providing the current time
+     * @return the created subject
+     */
+    public static <T> ReplaySubject<T> createWithTimeAndSize(long time, TimeUnit unit, int size, final Scheduler scheduler) {
+        final BoundedState<T> state = new BoundedState<T>(
+                new PairEvictionPolicy(
+                        new SizeEvictionPolicy(size),
+                        new TimeEvictionPolicy(unit.toMillis(time), scheduler)
+                ),
+                new AddTimestamped(scheduler),
+                new RemoveTimestamped()
+        );
+        return createWithState(state, new TimedOnAdd<T>(state, scheduler));
     }
+    /**
+     * Create a bounded replay subject with the given state shared between the subject
+     * and the OnSubscribe functions.
+     * @param <T> the result value type
+     * @param state the shared state
+     * @return the subject created
+     */
+    static final <T> ReplaySubject<T> createWithState(final BoundedState<T> state,
+            Action1<SubjectObserver<T>> onStart) {
+        SubjectSubscriptionManager<T> ssm = new SubjectSubscriptionManager<T>();
+        ssm.onStart = onStart;
+        ssm.onTerminated = new Action1<SubjectObserver<T>>() {
 
-    private final SubjectSubscriptionManager<T> subscriptionManager;
-    private final ReplayState<T> state;
+            @Override
+            public void call(SubjectObserver<T> t1) {
+                NodeList.Node<Object> l = state.removeState(t1);
+                if (l == null) {
+                    l = state.head();
+                }
+                state.replayObserverFromIndex(l, t1);
+            }
+
+        };
+        ssm.onUnsubscribed = new Action1<SubjectObserver<T>>() {
+            @Override
+            public void call(SubjectObserver<T> t1) {
+                state.removeState(t1);
+            }
 
-    protected ReplaySubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> subscriptionManager, ReplayState<T> state) {
+        };
+        
+        return new ReplaySubject<T>(ssm, ssm, state);
+    }
+    /** The state storing the history and the references. */
+    final ReplayState<T, ?> state;
+    /** The manager of subscribers. */
+    final SubjectSubscriptionManager<T> ssm;
+    ReplaySubject(OnSubscribe<T> onSubscribe, SubjectSubscriptionManager<T> ssm, ReplayState<T, ?> state) {
         super(onSubscribe);
-        this.subscriptionManager = subscriptionManager;
+        this.ssm = ssm;
         this.state = state;
     }
-
+    
     @Override
-    public void onCompleted() {
-
-        if (subscriptionManager.active) {
-            state.history.complete();
-            for (SubjectObserver<T> o : subscriptionManager.terminate(NotificationLite.instance().completed())) {
+    public void onNext(T t) {
+        if (ssm.active) {
+            state.next(t);
+            for (SubjectSubscriptionManager.SubjectObserver<? super T> o : ssm.observers()) {
                 if (caughtUp(o)) {
-                    o.onCompleted();
+                    o.onNext(t);
                 }
             }
         }
     }
-
+    
     @Override
     public void onError(final Throwable e) {
-        if (subscriptionManager.active) {
-            state.history.complete(e);
-            for (SubjectObserver<T> o : subscriptionManager.terminate(NotificationLite.instance().completed())) {
+        if (ssm.active) {
+            state.error(e);
+            for (SubjectObserver<? super T> o : ssm.terminate(NotificationLite.instance().error(e))) {
                 if (caughtUp(o)) {
                     o.onError(e);
                 }
             }
         }
     }
-
+    
     @Override
-    public void onNext(T v) {
-        if (state.history.terminated) {
-            return;
-        }
-        state.history.next(v);
-        for (SubjectObserver<? super T> o : subscriptionManager.observers()) {
-            if (caughtUp(o)) {
-                o.onNext(v);
+    public void onCompleted() {
+        if (ssm.active) {
+            state.complete();
+            for (SubjectObserver<? super T> o : ssm.terminate(NotificationLite.instance().completed())) {
+                if (caughtUp(o)) {
+                    o.onCompleted();
+                }
             }
         }
     }
-
-    /*
-     * 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
+    /**
+     * @return Returns the number of subscribers.
      */
+    /* Support test. */int subscriberCount() {
+        return state.replayStateSize();
+    }
+    
     private boolean caughtUp(SubjectObserver<? super T> o) {
         if (!o.caughtUp) {
             o.caughtUp = true;
-            replayObserver(o);
+            state.replayObserver(o);
             return false;
         } else {
             // it was caught up so proceed the "raw route"
             return true;
         }
     }
-
-    private void replayObserver(SubjectObserver<? super T> observer) {
-        Integer lastEmittedLink = state.replayState.get(observer);
-        if (lastEmittedLink == null) {
-            lastEmittedLink = 0;
-        }
-        int l = replayObserverFromIndex(state.history, lastEmittedLink, observer);
-        state.replayState.put(observer, l);
-    }
-
-    static <T> int replayObserverFromIndex(History<T> history, int idx, SubjectObserver<? super T> observer) {
-        while (idx < history.index.get()) {
-            history.accept(observer, idx);
-            idx++;
-        }
-
-        return idx;
-    }
-
+    
+    // *********************
+    // State implementations
+    // *********************
+    
     /**
-     * NOT thread-safe for multi-writer. Assumes single-writer.
-     * Is thread-safe for multi-reader.
-     * 
-     * @param <T>
+     * The unbounded replay state.
+     * @param <T> the input and output type
      */
-    private static class History<T> {
+    static final class UnboundedReplayState<T> implements ReplayState<T, Integer> {
+        /** Each Observer is tracked here for what events they have received. */
+        final ConcurrentHashMap<Observer<? super T>, Integer> replayState;
         private final NotificationLite<T> nl = NotificationLite.instance();
+        /** The size of the buffer. */
         private final AtomicInteger index;
+        /** The buffer. */
         private final ArrayList<Object> list;
-        private boolean terminated;
-
-        public History(int initialCapacity) {
+        /** The termination flag. */
+        private volatile boolean terminated;
+        public UnboundedReplayState(int initialCapacity) {
             index = new AtomicInteger(0);
             list = new ArrayList<Object>(initialCapacity);
+            replayState = new ConcurrentHashMap<Observer<? super T>, Integer>();
         }
 
-        public boolean next(T n) {
+        @Override
+        public void next(T n) {
             if (!terminated) {
                 list.add(nl.next(n));
                 index.getAndIncrement();
-                return true;
-            } else {
-                return false;
             }
         }
 
@@ -210,6 +355,7 @@ public void accept(Observer<? super T> o, int idx) {
             nl.accept(o, list.get(idx));
         }
         
+        @Override
         public void complete() {
             if (!terminated) {
                 terminated = true;
@@ -217,19 +363,455 @@ public void complete() {
                 index.getAndIncrement();
             }
         }
-        public void complete(Throwable e) {
+        @Override
+        public void error(Throwable e) {
             if (!terminated) {
                 terminated = true;
                 list.add(nl.error(e));
                 index.getAndIncrement();
             }
         }
+
+        @Override
+        public boolean terminated() {
+            return terminated;
+        }
+
+        @Override
+        public void replayObserver(SubjectObserver<? super T> observer) {
+            Integer lastEmittedLink = replayState.get(observer);
+            if (lastEmittedLink != null) {
+                int l = replayObserverFromIndex(lastEmittedLink, observer);
+                replayState.put(observer, l);
+            } else {
+                throw new IllegalStateException("failed to find lastEmittedLink for: " + observer);
+            }
+        }
+
+        @Override
+        public Integer replayObserverFromIndex(Integer idx, SubjectObserver<? super T> observer) {
+            int i = idx;
+            while (i < index.get()) {
+                accept(observer, i);
+                i++;
+            }
+
+            return i;
+        }
+
+        @Override
+        public Integer replayObserverFromIndexTest(Integer idx, SubjectObserver<? super T> observer, long now) {
+            return replayObserverFromIndex(idx, observer);
+        }
+
+        @Override
+        public int replayStateSize() {
+            return replayState.size();
+        }
+        
     }
+    
+    
+    /** 
+     * The bounded replay state. 
+     * @param <T> the input and output type
+     */
+    static final class BoundedState<T> implements ReplayState<T, NodeList.Node<Object>> {
+        final NodeList<Object> list;
+        final AtomicReference<NodeList.Node<Object>> tail;
+        final ConcurrentHashMap<Observer<? super T>, NodeList.Node<Object>> replayState;
+        final EvictionPolicy evictionPolicy;
+        final Func1<Object, Object> enterTransform;
+        final Func1<Object, Object> leaveTransform;
+        final NotificationLite<T> nl = NotificationLite.instance();
+        volatile boolean terminated;
+        public BoundedState(EvictionPolicy evictionPolicy, Func1<Object, Object> enterTransform, 
+                Func1<Object, Object> leaveTransform) {
+            this.list = new NodeList<Object>();
+            this.tail = new AtomicReference<NodeList.Node<Object>>(list.tail);
+            this.replayState = new ConcurrentHashMap<Observer<? super T>, NodeList.Node<Object>>();
+            this.evictionPolicy = evictionPolicy;
+            this.enterTransform = enterTransform;
+            this.leaveTransform = leaveTransform;
+        }
+        @Override
+        public void next(T value) {
+            if (!terminated) {
+                list.addLast(enterTransform.call(nl.next(value)));
+                evictionPolicy.evict(list);
+                tail.set(list.tail);
+            }
+        }
+        @Override
+        public void complete() {
+            if (!terminated) {
+                terminated = true;
+                // don't evict the terminal value
+                evictionPolicy.evict(list);
+                // so add it later
+                list.addLast(enterTransform.call(nl.completed()));
+                tail.set(list.tail);
+            }
+            
+        }
+        @Override
+        public void error(Throwable e) {
+            if (!terminated) {
+                terminated = true;
+                // don't evict the terminal value
+                evictionPolicy.evict(list);
+                // so add it later
+                list.addLast(enterTransform.call(nl.error(e)));
+                tail.set(list.tail);
+            }
+        }
+        public void accept(Observer<? super T> o, NodeList.Node<Object> node) {
+            nl.accept(o, leaveTransform.call(node.value));
+        }
+        /**
+         * Accept only non-stale nodes.
+         * @param o the target observer
+         * @param node the node to accept or reject
+         * @param now the current time
+         */
+        public void acceptTest(Observer<? super T> o, NodeList.Node<Object> node, long now) {
+            Object v = node.value;
+            if (!evictionPolicy.test(v, now)) {
+                nl.accept(o, leaveTransform.call(v));
+            }
+        }
+        public Node<Object> head() {
+            return list.head;
+        }
+        public Node<Object> tail() {
+            return tail.get();
+        }
+        public Node<Object> removeState(SubjectObserver<? super T> o) {
+            return replayState.remove(o);
+        }
+        public void addState(SubjectObserver<? super T> o, Node<Object> state) {
+            if (state == null) {
+                throw new IllegalStateException("Null state!");
+            } else {
+                replayState.put(o, state);
+            }
+        }
+        @Override
+        public void replayObserver(SubjectObserver<? super T> observer) {
+            NodeList.Node<Object> lastEmittedLink = replayState.get(observer);
+            NodeList.Node<Object> l = replayObserverFromIndex(lastEmittedLink, observer);
+            addState(observer, l);
+        }
 
+        @Override
+        public NodeList.Node<Object> replayObserverFromIndex(
+                NodeList.Node<Object> l, SubjectObserver<? super T> observer) {
+            while (l != tail()) {
+                accept(observer, l.next);
+                l = l.next;
+            }
+            return l;
+        }
+        @Override
+        public NodeList.Node<Object> replayObserverFromIndexTest(
+                NodeList.Node<Object> l, SubjectObserver<? super T> observer, long now) {
+            while (l != tail()) {
+                acceptTest(observer, l.next, now);
+                l = l.next;
+            }
+            return l;
+        }
+
+        @Override
+        public boolean terminated() {
+            return terminated;
+        }
+
+        @Override
+        public int replayStateSize() {
+            return replayState.size();
+        }
+    }
+    
+    // **************
+    // API interfaces
+    // **************
+    
     /**
-     * @return Returns the number of subscribers.
+     * General API for replay state management.
+     * @param <T> the input and output type
+     * @param <I> the index type
      */
-    /* Support test. */int subscriberCount() {
-        return state.replayState.size();
+    interface ReplayState<T, I> {
+        /** @return true if the subject has reached a terminal state. */
+        boolean terminated();
+        void replayObserver(SubjectObserver<? super T> observer);
+        /**
+         * Replay the buffered values from an index position and return a new index
+         * @param idx the current index position
+         * @param observer the receiver of events
+         * @return the new index position
+         */
+        I replayObserverFromIndex(
+                I idx, SubjectObserver<? super T> observer);
+        /**
+         * Replay the buffered values from an index position while testing for stale entries and return a new index
+         * @param idx the current index position
+         * @param observer the receiver of events
+         * @return the new index position
+         */
+        I replayObserverFromIndexTest(
+                I idx, SubjectObserver<? super T> observer, long now);
+        /**
+         * @return the size of the replay state map for testing purposes.
+         */
+        int replayStateSize();
+        /**
+         * Add an OnNext value to the buffer
+         * @param value the value to add
+         */
+        void next(T value);
+        /**
+         * Add an OnError exception and terminate the subject
+         * @param e the exception to add
+         */
+        void error(Throwable e);
+        /**
+         * Add an OnCompleted exception and terminate the subject
+         */
+        void complete();
+    }
+    
+    /** Interface to manage eviction checking. */
+    interface EvictionPolicy {
+        /**
+         * Subscribe-time checking for stale entries.
+         * @param value the value to test
+         * @param now the current time
+         * @return true if the value may be evicted
+         */
+        boolean test(Object value, long now);
+        /**
+         * Evict values from the list
+         * @param list 
+         */
+        void evict(NodeList<Object> list);
+    }
+
+    
+    // ************************
+    // Callback implementations
+    // ************************
+    
+    /**
+     * Remove elements from the beginning of the list if the size exceeds some threshold.
+     */
+    static final class SizeEvictionPolicy implements EvictionPolicy {
+        final int maxSize;
+        
+        public SizeEvictionPolicy(int maxSize) {
+            this.maxSize = maxSize;
+        }
+        
+        @Override
+        public void evict(NodeList<Object> t1) {
+            while (t1.size() > maxSize) {
+                t1.removeFirst();
+            }
+        }
+
+        @Override
+        public boolean test(Object value, long now) {
+            return true; // size gets never stale
+        }
+    }
+    /**
+     * Remove elements from the beginning of the list if the Timestamped value is older than
+     * a threshold.
+     */
+    static final class TimeEvictionPolicy implements EvictionPolicy {
+        final long maxAgeMillis;
+        final Scheduler scheduler;
+        
+        public TimeEvictionPolicy(long maxAgeMillis, Scheduler scheduler) {
+            this.maxAgeMillis = maxAgeMillis;
+            this.scheduler = scheduler;
+        }
+        
+        @Override
+        public void evict(NodeList<Object> t1) {
+            long now = scheduler.now();
+            while (!t1.isEmpty()) {
+                NodeList.Node<Object> n = t1.head.next;
+                if (test(n.value, now)) {
+                    t1.removeFirst();
+                } else {
+                    break;
+                }
+            }
+        }
+
+        @Override
+        public boolean test(Object value, long now) {
+            Timestamped<?> ts = (Timestamped<?>)value;
+            return ts.getTimestampMillis() <= now - maxAgeMillis;
+        }
+        
+    }
+    /**
+     * Pairs up two eviction policy callbacks.
+     */
+    static final class PairEvictionPolicy implements EvictionPolicy {
+        final EvictionPolicy first;
+        final EvictionPolicy second;
+        
+        public PairEvictionPolicy(EvictionPolicy first, EvictionPolicy second) {
+            this.first = first;
+            this.second = second;
+        }
+        
+        @Override
+        public void evict(NodeList<Object> t1) {
+            first.evict(t1);
+            second.evict(t1);
+        }
+
+        @Override
+        public boolean test(Object value, long now) {
+            return first.test(value, now) || second.test(value, now);
+        }
+    };
+    
+    /** Maps the values to Timestamped. */
+    static final class AddTimestamped implements Func1<Object, Object> {
+        final Scheduler scheduler;
+
+        public AddTimestamped(Scheduler scheduler) {
+            this.scheduler = scheduler;
+        }
+
+        @Override
+        public Object call(Object t1) {
+            return new Timestamped<Object>(scheduler.now(), t1);
+        }
+    }
+    /** Maps timestamped values back to raw objects. */
+    static final class RemoveTimestamped implements Func1<Object, Object> {
+        @Override
+        @SuppressWarnings("unchecked")
+        public Object call(Object t1) {
+            return ((Timestamped<Object>)t1).getValue();
+        }
+    }
+    /**
+     * Default action of simply replaying the buffer on subscribe.
+     * @param <T> the input and output value type
+     */
+    static final class DefaultOnAdd<T> implements Action1<SubjectObserver<T>> {
+        final BoundedState<T> state;
+
+        public DefaultOnAdd(BoundedState<T> state) {
+            this.state = state;
+        }
+        
+        @Override
+        public void call(SubjectObserver<T> t1) {
+            NodeList.Node<Object> l = state.replayObserverFromIndex(state.head(), t1);
+            state.addState(t1, l);
+        }
+        
+    }
+    /**
+     * Action of replaying non-stale entries of the buffer on subscribe
+     * @param <T> the input and output value
+     */
+    static final class TimedOnAdd<T> implements Action1<SubjectObserver<T>> {
+        final BoundedState<T> state;
+        final Scheduler scheduler;
+
+        public TimedOnAdd(BoundedState<T> state, Scheduler scheduler) {
+            this.state = state;
+            this.scheduler = scheduler;
+        }
+        
+        @Override
+        public void call(SubjectObserver<T> t1) {
+            NodeList.Node<Object> l;
+            if (!state.terminated) {
+                // ignore stale entries if still active
+                l = state.replayObserverFromIndexTest(state.head(), t1, scheduler.now());
+            }  else {
+                // accept all if terminated
+                l = state.replayObserverFromIndex(state.head(), t1);
+            }
+            state.addState(t1, l);
+        }
+        
     }
+    /**
+     * A singly-linked list with volatile next node pointer.
+     * @param <T> the value type
+     */
+    static final class NodeList<T> {
+        /**
+         * The node containing the value and references to neighbours.
+         * @param <T> the value type
+         */
+        static final class Node<T> {
+            /** The managed value. */
+            final T value;
+            /** The hard reference to the next node. */
+            volatile Node<T> next;
+            Node(T value) {
+                this.value = value;
+            }
+        }
+        /** The head of the list. */
+        final Node<T> head = new Node<T>(null);
+        /** The tail of the list. */
+        Node<T> tail = head;
+        /** The number of elements in the list. */
+        int size;
+        
+        public void addLast(T value) {
+            Node<T> t = tail;
+            Node<T> t2 = new Node<T>(value);
+            t.next = t2;
+            tail = t2;
+            size++;
+        }
+        public T removeFirst() {
+            if (head.next == null) {
+                throw new IllegalStateException("Empty!");
+            }
+            Node<T> t = head.next;
+            head.next = t.next;
+            if (head.next == null) {
+                tail = head;
+            }
+            size--;
+            return t.value;
+        }
+        public boolean isEmpty() {
+            return size == 0;
+        }
+        public int size() {
+            return size;
+        }
+        public void clear() {
+            tail = head;
+            size = 0;
+        }
+    }
+    /** Empty eviction policy. */
+    static final class EmptyEvictionPolicy implements EvictionPolicy {
+        @Override
+        public boolean test(Object value, long now) {
+            return true;
+        }
+        @Override
+        public void evict(NodeList<Object> list) {
+        }
+        
+    }    
 }
\ No newline at end of file
diff --git a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
index d3af5a17e7..6ed6a5e942 100644
--- a/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
+++ b/rxjava-core/src/main/java/rx/subjects/SubjectSubscriptionManager.java
@@ -314,16 +314,6 @@ protected void accept(Object n) {
             }
         }
         
-        /**
-         * Emit an OnCompleted event if the value object is 
-         * an OnNext NotificationLite object or null.
-         * @param value
-         */
-        protected void completeSingle(Object value) {
-            if (value == null || (!nl.isCompleted(value) && !nl.isError(value))) {
-                actual.onCompleted();
-            }
-        }
         /** @return the actual Observer. */
         protected Observer<? super T> getActual() {
             return actual;
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java b/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
index b52c6d22d9..216cc3321d 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorReplayTest.java
@@ -22,78 +22,23 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
-import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
-
-import org.junit.Assert;
 import static org.junit.Assert.assertEquals;
 import org.junit.Test;
 import org.mockito.InOrder;
 
+
 import rx.Observable;
 import rx.Observer;
 import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.observables.ConnectableObservable;
-import rx.operators.OperatorReplay.VirtualBoundedList;
 import rx.schedulers.TestScheduler;
 import rx.subjects.PublishSubject;
 
 public class OperatorReplayTest {
-    @Test
-    public void testBoundedList() {
-        VirtualBoundedList<Integer> list = new VirtualBoundedList<Integer>(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<Integer> list = new VirtualBoundedList<Integer>(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<Integer> list = new VirtualBoundedList<Integer>(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<Integer> source = PublishSubject.create();
@@ -520,4 +465,4 @@ public void call() {
             assertEquals(2, effectCounter.get());
         }
     }
-}
+}
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
new file mode 100644
index 0000000000..1138e4d226
--- /dev/null
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
@@ -0,0 +1,340 @@
+/**
+ * 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.subjects;
+
+import static org.junit.Assert.assertEquals;
+
+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.AtomicReference;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Action1;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+
+public class ReplaySubjectBoundedConcurrencyTest {
+
+    public static void main(String args[]) {
+        try {
+            for (int i = 0; i < 100; i++) {
+                new ReplaySubjectConcurrencyTest().testSubscribeCompletionRaceCondition();
+                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscriptions();
+                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test(timeout = 4000)
+    public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException {
+        final ReplaySubject<Long> replay = ReplaySubject.createUnbounded();
+        Thread source = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observable.create(new OnSubscribe<Long>() {
+
+                    @Override
+                    public void call(Subscriber<? super Long> 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();
+                    }
+                }).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() {
+                Subscriber<Long> slow = new Subscriber<Long>() {
+
+                    @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);
+                Subscriber<Long> fast = new Subscriber<Long>() {
+
+                    @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<Long> replay = ReplaySubject.createUnbounded();
+        Thread source = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observable.create(new OnSubscribe<Long>() {
+
+                    @Override
+                    public void call(Subscriber<? super Long> 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();
+                    }
+                }).subscribe(replay);
+            }
+        });
+
+        // used to collect results of each thread
+        final List<List<Long>> listOfListsOfValues = Collections.synchronizedList(new ArrayList<List<Long>>());
+        final List<Thread> threads = Collections.synchronizedList(new ArrayList<Thread>());
+
+        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<Long> 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<Long> sums = new ArrayList<Long>();
+        for (List<Long> 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<String> subject = ReplaySubject.createUnbounded();
+            final AtomicReference<String> value1 = new AtomicReference<String>();
+
+            subject.subscribe(new Action1<String>() {
+
+                @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());
+        }
+
+    }
+    
+    /**
+     * https://github.com/Netflix/RxJava/issues/1147
+     */
+    @Test
+    public void testRaceForTerminalState() {
+        final List<Integer> expected = Arrays.asList(1);
+        for (int i = 0; i < 100000; i++) {
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            Observable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts);
+            ts.awaitTerminalEvent();
+            ts.assertReceivedOnNext(expected);
+            ts.assertTerminalEvent();
+        }
+    }
+
+    private static class SubjectObserverThread extends Thread {
+
+        private final ReplaySubject<String> subject;
+        private final AtomicReference<String> value = new AtomicReference<String>();
+
+        public SubjectObserverThread(ReplaySubject<String> 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();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
index 4996b511d2..44e3dcfa67 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectTest.java
@@ -25,6 +25,7 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
 import org.junit.Test;
@@ -37,6 +38,7 @@
 import rx.Subscription;
 import rx.functions.Func1;
 import rx.schedulers.Schedulers;
+import rx.schedulers.TestScheduler;
 
 public class ReplaySubjectTest {
 
@@ -437,4 +439,154 @@ public void onCompleted() {
         verify(o).onCompleted();
         verify(o, never()).onError(any(Throwable.class));
     }
+    @Test
+    public void testNodeListSimpleAddRemove() {
+        ReplaySubject.NodeList<Integer> list = new ReplaySubject.NodeList<Integer>();
+        
+        assertEquals(0, list.size());
+        
+        // add and remove one
+        
+        list.addLast(1);
+
+        assertEquals(1, list.size());
+        
+        assertEquals((Integer)1, list.removeFirst());
+
+        assertEquals(0, list.size());
+
+        // add and remove one again
+        
+        list.addLast(1);
+
+        assertEquals(1, list.size());
+        
+        assertEquals((Integer)1, list.removeFirst());
+
+        // add and remove two items
+        
+        list.addLast(1);
+        list.addLast(2);
+
+        assertEquals(2, list.size());
+
+        assertEquals((Integer)1, list.removeFirst());
+        assertEquals((Integer)2, list.removeFirst());
+
+        assertEquals(0, list.size());
+        // clear two items
+        
+        list.addLast(1);
+        list.addLast(2);
+
+        assertEquals(2, list.size());
+        
+        list.clear();
+
+        assertEquals(0, list.size());
+    }
+    @Test
+    public void testReplay1AfterTermination() {
+        ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
+        
+        source.onNext(1);
+        source.onNext(2);
+        source.onCompleted();
+        
+        for (int i = 0; i < 1; i++) {
+            @SuppressWarnings("unchecked")
+            Observer<Integer> o = mock(Observer.class);
+
+            source.subscribe(o);
+
+            verify(o, never()).onNext(1);
+            verify(o).onNext(2);
+            verify(o).onCompleted();
+            verify(o, never()).onError(any(Throwable.class));
+        }
+    }
+    @Test
+    public void testReplay1Directly() {
+        ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o = mock(Observer.class);
+
+        source.onNext(1);
+        source.onNext(2);
+
+        source.subscribe(o);
+
+        source.onNext(3);
+        source.onCompleted();
+
+        verify(o, never()).onNext(1);
+        verify(o).onNext(2);
+        verify(o).onNext(3);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testReplayTimestampedAfterTermination() {
+        TestScheduler scheduler = new TestScheduler();
+        ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, scheduler);
+        
+        source.onNext(1);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onNext(2);
+
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        source.onNext(3);
+        source.onCompleted();
+
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o = mock(Observer.class);
+
+        source.subscribe(o);
+        
+        verify(o, never()).onNext(1);
+        verify(o, never()).onNext(2);
+        verify(o).onNext(3);
+        verify(o).onCompleted();
+        verify(o, never()).onError(any(Throwable.class));
+    }
+    
+    @Test
+    public void testReplayTimestampedDirectly() {
+        TestScheduler scheduler = new TestScheduler();
+        ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, scheduler);
+
+        source.onNext(1);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+
+        @SuppressWarnings("unchecked")
+        Observer<Integer> o = mock(Observer.class);
+
+        source.subscribe(o);
+
+        source.onNext(2);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onNext(3);
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        source.onCompleted();
+        
+        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
+        
+        verify(o, never()).onError(any(Throwable.class));
+        verify(o, never()).onNext(1);
+        verify(o).onNext(2);
+        verify(o).onNext(3);
+        verify(o).onCompleted();
+    }
 }

From 5996b9dd628a3d3f1047209918b6f6bf9fb7ff54 Mon Sep 17 00:00:00 2001
From: Michael Nitschinger <michael@nitschinger.at>
Date: Tue, 20 May 2014 14:49:40 +0200
Subject: [PATCH 403/422] Implement shorter toBlocking as shorter alias for
 toBlockingObservable.

Fixes #1220
---
 rxjava-core/src/main/java/rx/Observable.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 3589745629..c8dd7e45e8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7039,6 +7039,18 @@ public final BlockingObservable<T> toBlockingObservable() {
         return BlockingObservable.from(this);
     }
 
+    /**
+     * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking operators).
+     *
+     * This method is an alias for {@link #toBlockingObservable()}.
+     *
+     * @return a {@code BlockingObservable} version of this Observable
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators">RxJava Wiki: Blocking Observable Observers</a>
+     */
+    public final BlockingObservable<T> toBlocking() {
+        return toBlockingObservable();
+    }
+
     /**
      * Returns an Observable that emits a single item, a list composed of all the items emitted by the source
      * Observable.

From 3c90565b18444ccaafbe0c3ea866e27eb9a89aab Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 20 May 2014 23:47:17 +0800
Subject: [PATCH 404/422] Fix the bug that using mutable function in
 'zipWithIndex'

---
 .../src/main/scala/rx/lang/scala/Observable.scala         | 3 +--
 .../src/test/scala/rx/lang/scala/ObservableTest.scala     | 8 ++++++++
 2 files changed, 9 insertions(+), 2 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 bec1498d1d..119ec7bda9 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
@@ -407,8 +407,7 @@ trait Observable[+T]
    *         their index. Indices start at 0.
    */
   def zipWithIndex: Observable[(T, Int)] = {
-    var n = 0;
-    this.map(x => { val result = (x,n); n += 1; result })
+    zip((0 until Int.MaxValue).toObservable)
   }
 
   /**
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 029622d638..d8ef40590e 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
@@ -168,4 +168,12 @@ class ObservableTests extends JUnitSuite {
     val o: Observable[String] = List[String]().toObservable.tail
     o.toBlockingObservable.toList
   }
+
+  @Test
+  def testZipWithIndex() {
+    val o = List("alice", "bob", "carol").toObservable.zipWithIndex.map(_._2)
+    assertEquals(List(0, 1, 2), o.toBlockingObservable.toList)
+    assertEquals(List(0, 1, 2), o.toBlockingObservable.toList)
+  }
+
 }

From 1b30485a7daa99f5583cfb406beedd600fbe8404 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Tue, 20 May 2014 23:56:32 +0800
Subject: [PATCH 405/422] make 'zip(that, selector)' public and rename to
 'zipWith'

---
 .../src/main/scala/rx/lang/scala/Observable.scala           | 6 ++----
 1 file changed, 2 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 119ec7bda9..beeca0d0f3 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
@@ -385,7 +385,7 @@ trait Observable[+T]
    * is the minumum of the number of `onNext` invocations of `this` and `that`. 
    */
   def zip[U](that: Observable[U]): Observable[(T, U)] = {
-    zip(that, (t: T, u: U) => (t, u))
+    zipWith(that, (t: T, u: U) => (t, u))
   }
 
   /**
@@ -393,10 +393,8 @@ trait Observable[+T]
    * corresponding elements using the selector function.
    * The number of `onNext` invocations of the resulting `Observable[(T, U)]`
    * is the minumum of the number of `onNext` invocations of `this` and `that`.
-   *
-   * Note that this function is private because Scala collections don't have such a function.
    */
-  private def zip[U, R](that: Observable[U], selector: (T,U) => R): Observable[R] = {
+  def zipWith[U, R](that: Observable[U], selector: (T,U) => R): Observable[R] = {
     toScalaObservable[R](rx.Observable.zip[T, U, R](this.asJavaObservable, that.asJavaObservable, selector))
   }
 

From 4d05c9cd1688f129930666e0b2c134da80bd7743 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 20 May 2014 10:25:40 -0700
Subject: [PATCH 406/422] Git Reformats This File

---
 .../ReplaySubjectBoundedConcurrencyTest.java  | 678 +++++++++---------
 1 file changed, 339 insertions(+), 339 deletions(-)

diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
index 1138e4d226..6e32b8f6cf 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectBoundedConcurrencyTest.java
@@ -1,340 +1,340 @@
-/**
- * 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.subjects;
-
-import static org.junit.Assert.assertEquals;
-
-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.AtomicReference;
-
-import org.junit.Test;
-
-import rx.Observable;
-import rx.Observable.OnSubscribe;
-import rx.Subscriber;
-import rx.functions.Action1;
-import rx.observers.TestSubscriber;
-import rx.schedulers.Schedulers;
-
-public class ReplaySubjectBoundedConcurrencyTest {
-
-    public static void main(String args[]) {
-        try {
-            for (int i = 0; i < 100; i++) {
-                new ReplaySubjectConcurrencyTest().testSubscribeCompletionRaceCondition();
-                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscriptions();
-                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther();
-            }
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Test(timeout = 4000)
-    public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException {
-        final ReplaySubject<Long> replay = ReplaySubject.createUnbounded();
-        Thread source = new Thread(new Runnable() {
-
-            @Override
-            public void run() {
-                Observable.create(new OnSubscribe<Long>() {
-
-                    @Override
-                    public void call(Subscriber<? super Long> 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();
-                    }
-                }).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() {
-                Subscriber<Long> slow = new Subscriber<Long>() {
-
-                    @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);
-                Subscriber<Long> fast = new Subscriber<Long>() {
-
-                    @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<Long> replay = ReplaySubject.createUnbounded();
-        Thread source = new Thread(new Runnable() {
-
-            @Override
-            public void run() {
-                Observable.create(new OnSubscribe<Long>() {
-
-                    @Override
-                    public void call(Subscriber<? super Long> 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();
-                    }
-                }).subscribe(replay);
-            }
-        });
-
-        // used to collect results of each thread
-        final List<List<Long>> listOfListsOfValues = Collections.synchronizedList(new ArrayList<List<Long>>());
-        final List<Thread> threads = Collections.synchronizedList(new ArrayList<Thread>());
-
-        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<Long> 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<Long> sums = new ArrayList<Long>();
-        for (List<Long> 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<String> subject = ReplaySubject.createUnbounded();
-            final AtomicReference<String> value1 = new AtomicReference<String>();
-
-            subject.subscribe(new Action1<String>() {
-
-                @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());
-        }
-
-    }
-    
-    /**
-     * https://github.com/Netflix/RxJava/issues/1147
-     */
-    @Test
-    public void testRaceForTerminalState() {
-        final List<Integer> expected = Arrays.asList(1);
-        for (int i = 0; i < 100000; i++) {
-            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
-            Observable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts);
-            ts.awaitTerminalEvent();
-            ts.assertReceivedOnNext(expected);
-            ts.assertTerminalEvent();
-        }
-    }
-
-    private static class SubjectObserverThread extends Thread {
-
-        private final ReplaySubject<String> subject;
-        private final AtomicReference<String> value = new AtomicReference<String>();
-
-        public SubjectObserverThread(ReplaySubject<String> 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();
-            }
-        }
-    }
+/**
+ * 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.subjects;
+
+import static org.junit.Assert.assertEquals;
+
+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.AtomicReference;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Subscriber;
+import rx.functions.Action1;
+import rx.observers.TestSubscriber;
+import rx.schedulers.Schedulers;
+
+public class ReplaySubjectBoundedConcurrencyTest {
+
+    public static void main(String args[]) {
+        try {
+            for (int i = 0; i < 100; i++) {
+                new ReplaySubjectConcurrencyTest().testSubscribeCompletionRaceCondition();
+                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscriptions();
+                new ReplaySubjectConcurrencyTest().testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther();
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test(timeout = 4000)
+    public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException {
+        final ReplaySubject<Long> replay = ReplaySubject.createUnbounded();
+        Thread source = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observable.create(new OnSubscribe<Long>() {
+
+                    @Override
+                    public void call(Subscriber<? super Long> 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();
+                    }
+                }).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() {
+                Subscriber<Long> slow = new Subscriber<Long>() {
+
+                    @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);
+                Subscriber<Long> fast = new Subscriber<Long>() {
+
+                    @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<Long> replay = ReplaySubject.createUnbounded();
+        Thread source = new Thread(new Runnable() {
+
+            @Override
+            public void run() {
+                Observable.create(new OnSubscribe<Long>() {
+
+                    @Override
+                    public void call(Subscriber<? super Long> 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();
+                    }
+                }).subscribe(replay);
+            }
+        });
+
+        // used to collect results of each thread
+        final List<List<Long>> listOfListsOfValues = Collections.synchronizedList(new ArrayList<List<Long>>());
+        final List<Thread> threads = Collections.synchronizedList(new ArrayList<Thread>());
+
+        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<Long> 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<Long> sums = new ArrayList<Long>();
+        for (List<Long> 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<String> subject = ReplaySubject.createUnbounded();
+            final AtomicReference<String> value1 = new AtomicReference<String>();
+
+            subject.subscribe(new Action1<String>() {
+
+                @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());
+        }
+
+    }
+    
+    /**
+     * https://github.com/Netflix/RxJava/issues/1147
+     */
+    @Test
+    public void testRaceForTerminalState() {
+        final List<Integer> expected = Arrays.asList(1);
+        for (int i = 0; i < 100000; i++) {
+            TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+            Observable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts);
+            ts.awaitTerminalEvent();
+            ts.assertReceivedOnNext(expected);
+            ts.assertTerminalEvent();
+        }
+    }
+
+    private static class SubjectObserverThread extends Thread {
+
+        private final ReplaySubject<String> subject;
+        private final AtomicReference<String> value = new AtomicReference<String>();
+
+        public SubjectObserverThread(ReplaySubject<String> 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();
+            }
+        }
+    }
 }
\ No newline at end of file

From 7039d62b46075559130be3221b66677c8aa635c9 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 20 May 2014 10:47:14 -0700
Subject: [PATCH 407/422] Remove Ambiguous Subscribe Overloads with Scheduler

- Fixes https://github.com/Netflix/RxJava/issues/1116
- These should never have been added, the subscribeOn operator already provides this functionality
---
 .../main/scala/rx/lang/scala/Observable.scala |  66 ------------
 rxjava-core/src/main/java/rx/Observable.java  | 102 ------------------
 .../AbstractSchedulerConcurrencyTests.java    |   4 +-
 3 files changed, 2 insertions(+), 170 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 d144d1884b..c16f9d5af7 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
@@ -118,17 +118,6 @@ trait Observable[+T]
     asJavaObservable.subscribe()
   }
 
-  /**
-   * $subscribeObserverMain
-   *
-   * @param observer $subscribeObserverParamObserver
-   * @param scheduler $subscribeObserverParamScheduler
-   * @return $subscribeAllReturn
-   */
-  def subscribe(observer: Observer[T], scheduler: Scheduler): Subscription = {
-    asJavaObservable.subscribe(observer.asJavaObserver, scheduler)
-  }
-
   /**
    * $subscribeObserverMain
    *
@@ -147,19 +136,6 @@ trait Observable[+T]
    */
   def apply(observer: Observer[T]): Subscription = subscribe(observer)
 
-  /**
-   * $subscribeSubscriberMain
-   *
-   * @param subscriber $subscribeSubscriberParamObserver
-   * @param scheduler $subscribeSubscriberParamScheduler
-   * @return $subscribeAllReturn
-   */
-  def subscribe(subscriber: Subscriber[T], scheduler: Scheduler): Subscription = {
-    // Add the casting to avoid compile error "ambiguous reference to overloaded definition"
-    val thisJava = asJavaObservable.asInstanceOf[rx.Observable[T]]
-    thisJava.subscribe(subscriber.asJavaSubscriber, scheduler)
-  }
-
   /**
    * $subscribeSubscriberMain
    *
@@ -220,48 +196,6 @@ trait Observable[+T]
     )
   }
 
-  /**
-   * $subscribeCallbacksMainWithNotifications
-   *
-   * @param onNext $subscribeCallbacksParamOnNext
-   * @param onError $subscribeCallbacksParamOnError
-   * @param onCompleted $subscribeCallbacksParamOnComplete
-   * @param scheduler $subscribeCallbacksParamScheduler
-   * @return $subscribeAllReturn
-   */
-  def subscribe(onNext: T => Unit, onError: Throwable => Unit, onCompleted: () => Unit, scheduler: Scheduler): Subscription = {
-    asJavaObservable.subscribe(scalaFunction1ProducingUnitToAction1(onNext),
-      scalaFunction1ProducingUnitToAction1(onError),
-      scalaFunction0ProducingUnitToAction0(onCompleted),
-      scheduler)
-  }
-
-  /**
-   * $subscribeCallbacksMainWithNotifications
-   *
-   * @param onNext $subscribeCallbacksParamOnNext
-   * @param onError $subscribeCallbacksParamOnError
-   * @param scheduler $subscribeCallbacksParamScheduler
-   * @return $subscribeAllReturn
-   */
-  def subscribe(onNext: T => Unit, onError: Throwable => Unit, scheduler: Scheduler): Subscription = {
-    asJavaObservable.subscribe(
-      scalaFunction1ProducingUnitToAction1(onNext),
-      scalaFunction1ProducingUnitToAction1(onError),
-      scheduler)
-  }
-
-  /**
-   * $subscribeCallbacksMainNoNotifications
-   *
-   * @param onNext $subscribeCallbacksParamOnNext
-   * @param scheduler $subscribeCallbacksParamScheduler
-   * @return $subscribeAllReturn
-   */
-  def subscribe(onNext: T => Unit, scheduler: Scheduler): Subscription = {
-    asJavaObservable.subscribe(scalaFunction1ProducingUnitToAction1(onNext), scheduler)
-  }
-
   /**
    * Returns a pair of a start function and an [[rx.lang.scala.Observable]] that upon calling the start function causes the source Observable to
    * push results into the specified subject.
diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c0e9463ebe..b778d033c2 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6026,76 +6026,6 @@ 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.
-     * 
-     * @param onNext
-     *            FIXME FIXME FIXME
-     * @param onError
-     *            FIXME FIXME FIXME
-     * @param onComplete
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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
-     *            FIXME FIXME FIXME
-     * @param onError
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> 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
-     *            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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Action1<? super T> 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 <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     */
-    public final Subscription subscribe(final Observer<? super T> 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.
@@ -6241,38 +6171,6 @@ public void call() {
         }
     }
 
-    /**
-     * A {@link Subscriber} must call an Observable's {@code subscribe} method in order to receive items and
-     * notifications from the Observable.
-     * <p>
-     * A typical implementation of {@code subscribe} does the following:
-     * <ol>
-     * <li>It stores a reference to the Subscriber in a collection object, such as a {@code List<T>} object.</li>
-     * <li>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.</li>
-     * </ol><p>
-     * An {@code Observable<T>} instance is responsible for accepting all subscriptions and notifying all
-     * Subscribers. Unless the documentation for a particular {@code Observable<T>} implementation indicates
-     * otherwise, Subscribers should make no assumptions about the order in which multiple Subscribers will
-     * receive their notifications.
-     * <p>
-     * For more information see the
-     * <a href="https://github.com/Netflix/RxJava/wiki/Observable">RxJava Wiki</a>
-     * 
-     * @param observer
-     *            the {@link Subscriber}
-     * @param scheduler
-     *            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}
-     */
-    public final Subscription subscribe(Subscriber<? super T> observer, Scheduler scheduler) {
-        return subscribeOn(scheduler).subscribe(observer);
-    }
-
     /**
      * Asynchronously subscribes Observers to this Observable on the specified {@link Scheduler}.
      * <p>
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
index 332b9c257b..fd81a2d5fb 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java
@@ -371,7 +371,7 @@ public void call(Integer t) {
         final CountDownLatch latch = new CountDownLatch(5);
         final CountDownLatch first = new CountDownLatch(1);
 
-        o1.subscribe(new Action1<Integer>() {
+        o1.subscribeOn(scheduler).subscribe(new Action1<Integer>() {
 
             @Override
             public void call(Integer t) {
@@ -388,7 +388,7 @@ public void call(Integer t) {
                 count.incrementAndGet();
                 latch.countDown();
             }
-        }, scheduler);
+        });
 
         // assert we are async
         assertEquals(0, count.get());

From b42b4ac06df0259157e1c7d515d382fcc95330a0 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 20 May 2014 10:53:43 -0700
Subject: [PATCH 408/422] Operator Alias: Share

---
 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 c0e9463ebe..4d1f7284f2 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5324,6 +5324,23 @@ public final Observable<T> serialize() {
         return lift(new OperatorSerialize<T>());
     }
 
+    /**
+     * Returns a new {@link Observable} that multicasts (shares) the original {@link Observable}. 
+     * As long as there is more than 1 {@link Subscriber} this {@link Observable} will be subscribed and emitting data. 
+     * When all subscribers have unsubscribed it will unsubscribe from the source {@link Observable}. 
+     * <p>
+     * This is an alias for {@link #publish().refCount()}.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.png">
+     * 
+     * @return a {@link Observable} that upon connection causes the source Observable to emit items
+     *         to its {@link Observer}s
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: publish()</a>
+     */
+    public final Observable<T> share() {
+        return publish().refCount();
+    }
+    
     /**
      * 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 NoSuchElementException}.

From 06ba7523dd3eaa325ee77c9e91ee61f1eff7f39f Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 20 May 2014 10:58:43 -0700
Subject: [PATCH 409/422] Limit alias to Take

- as per Java 8 Stream naming conventions in discussion https://github.com/Netflix/RxJava/issues/678
---
 rxjava-core/src/main/java/rx/Observable.java | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index e19f1855df..c1d71f2291 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -4117,6 +4117,26 @@ public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolea
         return filter(predicate).takeLast(1).singleOrDefault(defaultValue);
     }
 
+    /**
+     * Returns an Observable that emits only the first {@code num} items emitted by the source Observable.
+     * <p>
+     * Alias of {@link #take(int)} to match Java 8 Stream API naming convention.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/take.png">
+     * <p>
+     * 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
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
+     */
+    public final Observable<T> limit(int num) {
+        return take(num);
+    }
+    
     /**
      * Returns an Observable that counts the total number of items emitted by the source Observable and emits
      * this count as a 64-bit Long.

From 48a845caafdf99bbcafe8d1a6163af31373b0928 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 20 May 2014 11:07:26 -0700
Subject: [PATCH 410/422] ForEach aliases to Subscribe to match Java 8
 Convention

As per discussion at https://github.com/Netflix/RxJava/issues/678

Code like this is now supported:

```java
Observable.from(1, 2, 3).forEach(System.out::println);
Observable.from(1, 2, 3).toBlocking().forEach(System.out::println);
```
---
 rxjava-core/src/main/java/rx/Observable.java | 63 ++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index c1d71f2291..c6964a6098 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3902,6 +3902,69 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
         return mergeMap(func);
     }
 
+    /**
+     * Subscribes to the {@link Observable} and receives notifications for each element.
+     * <p>
+     * Alias to {@link #subscribe(Action1)}
+     * 
+     * @param onNext
+     *            {@link Action1} to execute for each item.
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws IllegalArgumentException
+     *             if {@code onError} is null
+     * @throws IllegalArgumentException
+     *             if {@code onComplete} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     * */
+    public final void forEach(final Action1<? super T> onNext) {
+        subscribe(onNext);
+    }
+    
+    /**
+     * Subscribes to the {@link Observable} and receives notifications for each element and error events.
+     * <p>
+     * Alias to {@link #subscribe(Action1, Action1)}
+     * 
+     * @param onNext
+     *            {@link Action1} to execute for each item.
+     * @param onError
+     *            {@link Action1} to execute when an error is emitted.
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws IllegalArgumentException
+     *             if {@code onError} is null
+     * @throws IllegalArgumentException
+     *             if {@code onComplete} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     * */
+    public final void forEach(final Action1<? super T> onNext, final Action1<Throwable> onError) {
+        subscribe(onNext, onError);
+    }
+    
+    /**
+     * Subscribes to the {@link Observable} and receives notifications for each element and the terminal events.
+     * <p>
+     * Alias to {@link #subscribe(Action1, Action1, Action0)}
+     * 
+     * @param onNext
+     *            {@link Action1} to execute for each item.
+     * @param onError
+     *            {@link Action1} to execute when an error is emitted.
+     * @param onComplete
+     *            {@link Action0} to execute when completion is signalled.
+     * @throws IllegalArgumentException
+     *             if {@code onNext} is null
+     * @throws IllegalArgumentException
+     *             if {@code onError} is null
+     * @throws IllegalArgumentException
+     *             if {@code onComplete} is null
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
+     * */
+    public final void forEach(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete) {
+        subscribe(onNext, onError, onComplete);
+    }
+    
     /**
      * 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.

From 93ed3580887ede92edef39c2ab46abc9045e133b Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Tue, 20 May 2014 11:12:19 -0700
Subject: [PATCH 411/422] Deprecate toBlockingObservable in favor of toBlocking

As per discussion at https://github.com/Netflix/RxJava/pull/1224#issuecomment-43658284
---
 rxjava-core/src/main/java/rx/Observable.java  |  7 +++--
 .../rx/observables/BlockingObservable.java    |  2 +-
 .../schedulers/TestRecursionMemoryUsage.java  |  2 +-
 .../src/test/java/rx/CombineLatestTests.java  | 10 +++----
 rxjava-core/src/test/java/rx/ConcatTests.java | 14 ++++-----
 .../src/test/java/rx/GroupByTests.java        |  4 +--
 rxjava-core/src/test/java/rx/MergeTests.java  |  8 ++---
 .../src/test/java/rx/ObservableDoOnTest.java  |  6 ++--
 .../src/test/java/rx/ObservableTests.java     | 30 +++++++++----------
 .../test/java/rx/ObservableWindowTests.java   |  2 +-
 rxjava-core/src/test/java/rx/ReduceTests.java |  2 +-
 rxjava-core/src/test/java/rx/ScanTests.java   |  2 +-
 .../src/test/java/rx/StartWithTests.java      |  6 ++--
 rxjava-core/src/test/java/rx/ZipTests.java    | 14 ++++-----
 .../operators/BlockingOperatorLatestTest.java | 14 ++++-----
 .../BlockingOperatorMostRecentTest.java       |  2 +-
 .../operators/BlockingOperatorNextTest.java   |  2 +-
 .../rx/operators/OperatorElementAtTest.java   |  8 ++---
 .../rx/operators/OperatorGroupByTest.java     | 12 ++++----
 .../java/rx/operators/OperatorLastTest.java   |  8 ++---
 .../java/rx/operators/OperatorMapTest.java    | 10 +++----
 .../rx/operators/OperatorMaterializeTest.java |  4 +--
 .../OperatorMergeMaxConcurrentTest.java       |  8 ++---
 .../java/rx/operators/OperatorMergeTest.java  |  2 +-
 .../rx/operators/OperatorObserveOnTest.java   |  6 ++--
 .../operators/OperatorParallelMergeTest.java  | 10 +++----
 .../rx/operators/OperatorParallelTest.java    |  4 +--
 .../java/rx/operators/OperatorRepeatTest.java |  8 ++---
 .../java/rx/operators/OperatorTakeTest.java   |  4 +--
 .../rx/operators/OperatorTakeWhileTest.java   |  2 +-
 .../java/rx/operators/OperatorUsingTest.java  |  6 ++--
 .../java/rx/operators/OperatorWindowTest.java |  2 +-
 .../java/rx/operators/OperatorZipTest.java    |  2 +-
 .../rx/schedulers/AbstractSchedulerTests.java |  4 +--
 .../schedulers/ComputationSchedulerTests.java |  4 +--
 .../rx/schedulers/ImmediateSchedulerTest.java |  4 +--
 .../rx/schedulers/NewThreadSchedulerTest.java |  2 +-
 .../schedulers/TrampolineSchedulerTest.java   |  2 +-
 .../java/rx/subjects/AsyncSubjectTest.java    |  2 +-
 .../ReplaySubjectConcurrencyTest.java         |  6 ++--
 .../test/java/rx/util/AssertObservable.java   |  2 +-
 41 files changed, 125 insertions(+), 124 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index e19f1855df..ada099b813 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6949,7 +6949,10 @@ public final Observable<Timestamped<T>> timestamp(Scheduler scheduler) {
      * 
      * @return a {@code BlockingObservable} version of this Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators">RxJava Wiki: Blocking Observable Observers</a>
+     * 
+     * @deprecated Use {@link #toBlocking()} instead.
      */
+    @Deprecated
     public final BlockingObservable<T> toBlockingObservable() {
         return BlockingObservable.from(this);
     }
@@ -6957,13 +6960,11 @@ public final BlockingObservable<T> toBlockingObservable() {
     /**
      * Converts an Observable into a {@link BlockingObservable} (an Observable with blocking operators).
      *
-     * This method is an alias for {@link #toBlockingObservable()}.
-     *
      * @return a {@code BlockingObservable} version of this Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators">RxJava Wiki: Blocking Observable Observers</a>
      */
     public final BlockingObservable<T> toBlocking() {
-        return toBlockingObservable();
+        return BlockingObservable.from(this);
     }
 
     /**
diff --git a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
index bab6d67f90..da33d262d8 100644
--- a/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
+++ b/rxjava-core/src/main/java/rx/observables/BlockingObservable.java
@@ -35,7 +35,7 @@
  * An extension of {@link Observable} that provides blocking operators.
  * <p>
  * You construct a <code>BlockingObservable</code> from an
- * <code>Observable</code> with {@link #from(Observable)} or {@link Observable#toBlockingObservable()} <p>
+ * <code>Observable</code> with {@link #from(Observable)} or {@link Observable#toBlocking()} <p>
  * 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:
diff --git a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
index 7fc70cdd9d..1a353decfc 100644
--- a/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
+++ b/rxjava-core/src/perf/java/rx/archive/schedulers/TestRecursionMemoryUsage.java
@@ -66,6 +66,6 @@ public void call() {
                     }
                 });
             }
-        }).toBlockingObservable().last();
+        }).toBlocking().last();
     }
 }
diff --git a/rxjava-core/src/test/java/rx/CombineLatestTests.java b/rxjava-core/src/test/java/rx/CombineLatestTests.java
index dfc2ec1245..e8340cc141 100644
--- a/rxjava-core/src/test/java/rx/CombineLatestTests.java
+++ b/rxjava-core/src/test/java/rx/CombineLatestTests.java
@@ -36,11 +36,11 @@ public void testCovarianceOfCombineLatest() {
         Observable<HorrorMovie> horrors = Observable.from(new HorrorMovie());
         Observable<CoolRating> ratings = Observable.from(new CoolRating());
 
-        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
-        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
-        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(extendedAction);
-        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
-        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).toBlocking().forEach(action);
+        Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine).toBlocking().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).toBlocking().forEach(extendedAction);
+        Observable.<Media, Rating, Result> combineLatest(horrors, ratings, combine).toBlocking().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> combineLatest(horrors, ratings, combine).toBlocking().forEach(action);
 
         Observable.<Movie, CoolRating, Result> combineLatest(horrors, ratings, combine);
     }
diff --git a/rxjava-core/src/test/java/rx/ConcatTests.java b/rxjava-core/src/test/java/rx/ConcatTests.java
index 0dae3e327a..63b90a7d6e 100644
--- a/rxjava-core/src/test/java/rx/ConcatTests.java
+++ b/rxjava-core/src/test/java/rx/ConcatTests.java
@@ -35,7 +35,7 @@ public void testConcatSimple() {
         Observable<String> o1 = Observable.from("one", "two");
         Observable<String> o2 = Observable.from("three", "four");
 
-        List<String> values = Observable.concat(o1, o2).toList().toBlockingObservable().single();
+        List<String> values = Observable.concat(o1, o2).toList().toBlocking().single();
 
         assertEquals("one", values.get(0));
         assertEquals("two", values.get(1));
@@ -51,7 +51,7 @@ public void testConcatWithObservableOfObservable() {
 
         Observable<Observable<String>> os = Observable.from(o1, o2, o3);
 
-        List<String> values = Observable.concat(os).toList().toBlockingObservable().single();
+        List<String> values = Observable.concat(os).toList().toBlocking().single();
 
         assertEquals("one", values.get(0));
         assertEquals("two", values.get(1));
@@ -68,7 +68,7 @@ public void testConcatWithIterableOfObservable() {
         @SuppressWarnings("unchecked")
         Iterable<Observable<String>> is = Arrays.asList(o1, o2, o3);
 
-        List<String> values = Observable.concat(Observable.from(is)).toList().toBlockingObservable().single();
+        List<String> values = Observable.concat(Observable.from(is)).toList().toBlocking().single();
 
         assertEquals("one", values.get(0));
         assertEquals("two", values.get(1));
@@ -83,7 +83,7 @@ public void testConcatCovariance() {
 
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
-        List<Media> values = Observable.concat(os).toList().toBlockingObservable().single();
+        List<Media> values = Observable.concat(os).toList().toBlocking().single();
         
         assertEquals(4, values.size());
     }
@@ -95,7 +95,7 @@ public void testConcatCovariance2() {
 
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
-        List<Media> values = Observable.concat(os).toList().toBlockingObservable().single();
+        List<Media> values = Observable.concat(os).toList().toBlocking().single();
 
         assertEquals(5, values.size());
     }
@@ -105,7 +105,7 @@ public void testConcatCovariance3() {
         Observable<Movie> o1 = Observable.from(new HorrorMovie(), new Movie());
         Observable<Media> o2 = Observable.from(new Media(), new HorrorMovie());
 
-        List<Media> values = Observable.concat(o1, o2).toList().toBlockingObservable().single();
+        List<Media> values = Observable.concat(o1, o2).toList().toBlocking().single();
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
@@ -129,7 +129,7 @@ public void call(Subscriber<? super Movie> o) {
 
         Observable<Media> o2 = Observable.from(new Media(), new HorrorMovie());
 
-        List<Media> values = Observable.concat(o1, o2).toList().toBlockingObservable().single();
+        List<Media> values = Observable.concat(o1, o2).toList().toBlocking().single();
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
diff --git a/rxjava-core/src/test/java/rx/GroupByTests.java b/rxjava-core/src/test/java/rx/GroupByTests.java
index 414d1ad559..3530c08799 100644
--- a/rxjava-core/src/test/java/rx/GroupByTests.java
+++ b/rxjava-core/src/test/java/rx/GroupByTests.java
@@ -38,7 +38,7 @@ public String call(Event event) {
                     }
 
                 }).take(1)
-                .toBlockingObservable().forEach(new Action1<GroupedObservable<String, Event>>() {
+                .toBlocking().forEach(new Action1<GroupedObservable<String, Event>>() {
 
                     @Override
                     public void call(GroupedObservable<String, Event> g) {
@@ -79,7 +79,7 @@ public String call(Event event) {
 
                 })
                 .take(20)
-                .toBlockingObservable().forEach(new Action1<String>() {
+                .toBlocking().forEach(new Action1<String>() {
 
                     @Override
                     public void call(String v) {
diff --git a/rxjava-core/src/test/java/rx/MergeTests.java b/rxjava-core/src/test/java/rx/MergeTests.java
index 115c0b6a93..aca0cec086 100644
--- a/rxjava-core/src/test/java/rx/MergeTests.java
+++ b/rxjava-core/src/test/java/rx/MergeTests.java
@@ -46,7 +46,7 @@ public void testMergeCovariance() {
 
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
-        List<Media> values = Observable.merge(os).toList().toBlockingObservable().single();
+        List<Media> values = Observable.merge(os).toList().toBlocking().single();
         
         assertEquals(4, values.size());
     }
@@ -58,7 +58,7 @@ public void testMergeCovariance2() {
 
         Observable<Observable<Media>> os = Observable.from(o1, o2);
 
-        List<Media> values = Observable.merge(os).toList().toBlockingObservable().single();
+        List<Media> values = Observable.merge(os).toList().toBlocking().single();
 
         assertEquals(5, values.size());
     }
@@ -68,7 +68,7 @@ public void testMergeCovariance3() {
         Observable<Movie> o1 = Observable.from(new HorrorMovie(), new Movie());
         Observable<Media> o2 = Observable.from(new Media(), new HorrorMovie());
 
-        List<Media> values = Observable.merge(o1, o2).toList().toBlockingObservable().single();
+        List<Media> values = Observable.merge(o1, o2).toList().toBlocking().single();
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
@@ -92,7 +92,7 @@ public void call(Subscriber<? super Movie> o) {
 
         Observable<Media> o2 = Observable.from(new Media(), new HorrorMovie());
 
-        List<Media> values = Observable.merge(o1, o2).toList().toBlockingObservable().single();
+        List<Media> values = Observable.merge(o1, o2).toList().toBlocking().single();
 
         assertTrue(values.get(0) instanceof HorrorMovie);
         assertTrue(values.get(1) instanceof Movie);
diff --git a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
index bbbe88943e..7a39870bdf 100644
--- a/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
+++ b/rxjava-core/src/test/java/rx/ObservableDoOnTest.java
@@ -39,7 +39,7 @@ public void testDoOnEach() {
             public void call(String v) {
                 r.set(v);
             }
-        }).toBlockingObservable().single();
+        }).toBlocking().single();
 
         assertEquals("one", output);
         assertEquals("one", r.get());
@@ -56,7 +56,7 @@ Observable.<String> error(new RuntimeException("an error")).doOnError(new Action
                 public void call(Throwable v) {
                     r.set(v);
                 }
-            }).toBlockingObservable().single();
+            }).toBlocking().single();
             fail("expected exception, not a return value");
         } catch (Throwable e) {
             t = e;
@@ -75,7 +75,7 @@ public void testDoOnCompleted() {
             public void call() {
                 r.set(true);
             }
-        }).toBlockingObservable().single();
+        }).toBlocking().single();
 
         assertEquals("one", output);
         assertTrue(r.get());
diff --git a/rxjava-core/src/test/java/rx/ObservableTests.java b/rxjava-core/src/test/java/rx/ObservableTests.java
index e7da099eb6..d8ee4fe638 100644
--- a/rxjava-core/src/test/java/rx/ObservableTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableTests.java
@@ -74,9 +74,9 @@ public void before() {
     @Test
     public void fromArray() {
         String[] items = new String[] { "one", "two", "three" };
-        assertEquals(new Integer(3), Observable.from(items).count().toBlockingObservable().single());
-        assertEquals("two", Observable.from(items).skip(1).take(1).toBlockingObservable().single());
-        assertEquals("three", Observable.from(items).takeLast(1).toBlockingObservable().single());
+        assertEquals(new Integer(3), Observable.from(items).count().toBlocking().single());
+        assertEquals("two", Observable.from(items).skip(1).take(1).toBlocking().single());
+        assertEquals("three", Observable.from(items).takeLast(1).toBlocking().single());
     }
 
     @Test
@@ -86,26 +86,26 @@ public void fromIterable() {
         items.add("two");
         items.add("three");
 
-        assertEquals(new Integer(3), Observable.from(items).count().toBlockingObservable().single());
-        assertEquals("two", Observable.from(items).skip(1).take(1).toBlockingObservable().single());
-        assertEquals("three", Observable.from(items).takeLast(1).toBlockingObservable().single());
+        assertEquals(new Integer(3), Observable.from(items).count().toBlocking().single());
+        assertEquals("two", Observable.from(items).skip(1).take(1).toBlocking().single());
+        assertEquals("three", Observable.from(items).takeLast(1).toBlocking().single());
     }
 
     @Test
     public void fromArityArgs3() {
         Observable<String> items = Observable.from("one", "two", "three");
 
-        assertEquals(new Integer(3), items.count().toBlockingObservable().single());
-        assertEquals("two", items.skip(1).take(1).toBlockingObservable().single());
-        assertEquals("three", items.takeLast(1).toBlockingObservable().single());
+        assertEquals(new Integer(3), items.count().toBlocking().single());
+        assertEquals("two", items.skip(1).take(1).toBlocking().single());
+        assertEquals("three", items.takeLast(1).toBlocking().single());
     }
 
     @Test
     public void fromArityArgs1() {
         Observable<String> items = Observable.from("one");
 
-        assertEquals(new Integer(1), items.count().toBlockingObservable().single());
-        assertEquals("one", items.takeLast(1).toBlockingObservable().single());
+        assertEquals(new Integer(1), items.count().toBlocking().single());
+        assertEquals("one", items.takeLast(1).toBlocking().single());
     }
 
     @Test
@@ -253,7 +253,7 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
 
-        }).toBlockingObservable().forEach(new Action1<Integer>() {
+        }).toBlocking().forEach(new Action1<Integer>() {
 
             @Override
             public void call(Integer t1) {
@@ -279,7 +279,7 @@ public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
 
-        }).toBlockingObservable().last();
+        }).toBlocking().last();
 
         assertEquals(1, value);
     }
@@ -970,7 +970,7 @@ public void testCollectToList() {
             public void call(List<Integer> list, Integer v) {
                 list.add(v);
             }
-        }).toBlockingObservable().last();
+        }).toBlocking().last();
 
         assertEquals(3, list.size());
         assertEquals(1, list.get(0).intValue());
@@ -989,7 +989,7 @@ public void call(StringBuilder sb, Integer v) {
                 }
                 sb.append(v);
             }
-        }).toBlockingObservable().last().toString();
+        }).toBlocking().last().toString();
 
         assertEquals("1-2-3", value);
     }
diff --git a/rxjava-core/src/test/java/rx/ObservableWindowTests.java b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
index abcd053663..4b9ac9187d 100644
--- a/rxjava-core/src/test/java/rx/ObservableWindowTests.java
+++ b/rxjava-core/src/test/java/rx/ObservableWindowTests.java
@@ -37,7 +37,7 @@ public void testWindow() {
             public Observable<List<Integer>> call(Observable<Integer> xs) {
                 return xs.toList();
             }
-        })).toBlockingObservable().forEach(new Action1<List<Integer>>() {
+        })).toBlocking().forEach(new Action1<List<Integer>>() {
 
             @Override
             public void call(List<Integer> xs) {
diff --git a/rxjava-core/src/test/java/rx/ReduceTests.java b/rxjava-core/src/test/java/rx/ReduceTests.java
index 906591d5ef..8fd3b7cefa 100644
--- a/rxjava-core/src/test/java/rx/ReduceTests.java
+++ b/rxjava-core/src/test/java/rx/ReduceTests.java
@@ -34,7 +34,7 @@ public void reduceInts() {
             public Integer call(Integer t1, Integer t2) {
                 return t1 + t2;
             }
-        }).toBlockingObservable().single();
+        }).toBlocking().single();
 
         assertEquals(6, value);
     }
diff --git a/rxjava-core/src/test/java/rx/ScanTests.java b/rxjava-core/src/test/java/rx/ScanTests.java
index b94b8b50a3..36cb429255 100644
--- a/rxjava-core/src/test/java/rx/ScanTests.java
+++ b/rxjava-core/src/test/java/rx/ScanTests.java
@@ -40,7 +40,7 @@ public Map<String, String> call(Map<String, String> accum, Event perInstanceEven
 
                 })
                 .take(10)
-                .toBlockingObservable().forEach(new Action1<Map<String, String>>() {
+                .toBlocking().forEach(new Action1<Map<String, String>>() {
 
                     @Override
                     public void call(Map<String, String> v) {
diff --git a/rxjava-core/src/test/java/rx/StartWithTests.java b/rxjava-core/src/test/java/rx/StartWithTests.java
index b077046f89..f35cc14236 100644
--- a/rxjava-core/src/test/java/rx/StartWithTests.java
+++ b/rxjava-core/src/test/java/rx/StartWithTests.java
@@ -26,7 +26,7 @@ public class StartWithTests {
 
     @Test
     public void startWith1() {
-        List<String> values = Observable.from("one", "two").startWith("zero").toList().toBlockingObservable().single();
+        List<String> values = Observable.from("one", "two").startWith("zero").toList().toBlocking().single();
 
         assertEquals("zero", values.get(0));
         assertEquals("two", values.get(2));
@@ -37,7 +37,7 @@ public void startWithIterable() {
         List<String> li = new ArrayList<String>();
         li.add("alpha");
         li.add("beta");
-        List<String> values = Observable.from("one", "two").startWith(li).toList().toBlockingObservable().single();
+        List<String> values = Observable.from("one", "two").startWith(li).toList().toBlocking().single();
 
         assertEquals("alpha", values.get(0));
         assertEquals("beta", values.get(1));
@@ -50,7 +50,7 @@ public void startWithObservable() {
         List<String> li = new ArrayList<String>();
         li.add("alpha");
         li.add("beta");
-        List<String> values = Observable.from("one", "two").startWith(Observable.from(li)).toList().toBlockingObservable().single();
+        List<String> values = Observable.from("one", "two").startWith(Observable.from(li)).toList().toBlocking().single();
 
         assertEquals("alpha", values.get(0));
         assertEquals("beta", values.get(1));
diff --git a/rxjava-core/src/test/java/rx/ZipTests.java b/rxjava-core/src/test/java/rx/ZipTests.java
index a6f128ae8e..28bf13b9f4 100644
--- a/rxjava-core/src/test/java/rx/ZipTests.java
+++ b/rxjava-core/src/test/java/rx/ZipTests.java
@@ -69,7 +69,7 @@ public Map<String, String> call(Map<String, String> accum, Event perInstanceEven
                     }
                 })
                 .take(10)
-                .toBlockingObservable().forEach(new Action1<Map<String, String>>() {
+                .toBlocking().forEach(new Action1<Map<String, String>>() {
 
                     @Override
                     public void call(Map<String, String> v) {
@@ -89,11 +89,11 @@ public void testCovarianceOfZip() {
         Observable<HorrorMovie> horrors = Observable.from(new HorrorMovie());
         Observable<CoolRating> ratings = Observable.from(new CoolRating());
 
-        Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
-        Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
-        Observable.<Media, Rating, ExtendedResult> zip(horrors, ratings, combine).toBlockingObservable().forEach(extendedAction);
-        Observable.<Media, Rating, Result> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
-        Observable.<Media, Rating, ExtendedResult> zip(horrors, ratings, combine).toBlockingObservable().forEach(action);
+        Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine).toBlocking().forEach(action);
+        Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine).toBlocking().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> zip(horrors, ratings, combine).toBlocking().forEach(extendedAction);
+        Observable.<Media, Rating, Result> zip(horrors, ratings, combine).toBlocking().forEach(action);
+        Observable.<Media, Rating, ExtendedResult> zip(horrors, ratings, combine).toBlocking().forEach(action);
 
         Observable.<Movie, CoolRating, Result> zip(horrors, ratings, combine);
     }
@@ -120,7 +120,7 @@ public Object call(final Object... args) {
             }
         });
 
-        assertSame(invoked, result.toBlockingObservable().last());
+        assertSame(invoked, result.toBlocking().last());
     }
 
     Func2<Media, Rating, ExtendedResult> combine = new Func2<Media, Rating, ExtendedResult>() {
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorLatestTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorLatestTest.java
index 58eaf4d6a4..433659e755 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorLatestTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorLatestTest.java
@@ -33,7 +33,7 @@ public class BlockingOperatorLatestTest {
     public void testSimple() {
         TestScheduler scheduler = new TestScheduler();
 
-        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
+        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlocking();
 
         Iterable<Long> iter = source.latest();
 
@@ -57,7 +57,7 @@ public void testSimple() {
     public void testSameSourceMultipleIterators() {
         TestScheduler scheduler = new TestScheduler();
 
-        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
+        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlocking();
 
         Iterable<Long> iter = source.latest();
 
@@ -81,7 +81,7 @@ public void testSameSourceMultipleIterators() {
 
     @Test(timeout = 1000, expected = NoSuchElementException.class)
     public void testEmpty() {
-        BlockingObservable<Long> source = Observable.<Long> empty().toBlockingObservable();
+        BlockingObservable<Long> source = Observable.<Long> empty().toBlocking();
 
         Iterable<Long> iter = source.latest();
 
@@ -96,7 +96,7 @@ public void testEmpty() {
     public void testSimpleJustNext() {
         TestScheduler scheduler = new TestScheduler();
 
-        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
+        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlocking();
 
         Iterable<Long> iter = source.latest();
 
@@ -115,7 +115,7 @@ public void testSimpleJustNext() {
     public void testHasNextThrows() {
         TestScheduler scheduler = new TestScheduler();
 
-        BlockingObservable<Long> source = Observable.<Long> error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable();
+        BlockingObservable<Long> source = Observable.<Long> error(new RuntimeException("Forced failure!"), scheduler).toBlocking();
 
         Iterable<Long> iter = source.latest();
 
@@ -130,7 +130,7 @@ public void testHasNextThrows() {
     public void testNextThrows() {
         TestScheduler scheduler = new TestScheduler();
 
-        BlockingObservable<Long> source = Observable.<Long> error(new RuntimeException("Forced failure!"), scheduler).toBlockingObservable();
+        BlockingObservable<Long> source = Observable.<Long> error(new RuntimeException("Forced failure!"), scheduler).toBlocking();
 
         Iterable<Long> iter = source.latest();
         Iterator<Long> it = iter.iterator();
@@ -143,7 +143,7 @@ public void testNextThrows() {
     @Test(timeout = 1000)
     public void testFasterSource() {
         PublishSubject<Integer> source = PublishSubject.create();
-        BlockingObservable<Integer> blocker = source.toBlockingObservable();
+        BlockingObservable<Integer> blocker = source.toBlocking();
 
         Iterable<Integer> iter = blocker.latest();
         Iterator<Integer> it = iter.iterator();
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
index c165c65411..60e1e2f5ac 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorMostRecentTest.java
@@ -79,7 +79,7 @@ public void testMostRecentWithException() {
     @Test(timeout = 1000)
     public void testSingleSourceManyIterators() {
         TestScheduler scheduler = new TestScheduler();
-        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlockingObservable();
+        BlockingObservable<Long> source = Observable.interval(1, TimeUnit.SECONDS, scheduler).take(10).toBlocking();
 
         Iterable<Long> iter = source.mostRecent(-1L);
 
diff --git a/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
index 2a260c541c..953db5c6fd 100644
--- a/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
+++ b/rxjava-core/src/test/java/rx/operators/BlockingOperatorNextTest.java
@@ -295,7 +295,7 @@ public void run() {
     @Test /* (timeout = 8000) */
     public void testSingleSourceManyIterators() throws InterruptedException {
         PublishSubject<Long> ps = PublishSubject.create();
-        BlockingObservable<Long> source = ps.take(10).toBlockingObservable();
+        BlockingObservable<Long> source = ps.take(10).toBlocking();
 
         Iterable<Long> iter = source.next();
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java b/rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java
index a9a21f0087..d239988aca 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorElementAtTest.java
@@ -27,7 +27,7 @@ public class OperatorElementAtTest {
 
     @Test
     public void testElementAt() {
-        assertEquals(2, Observable.from(Arrays.asList(1, 2)).elementAt(1).toBlockingObservable().single()
+        assertEquals(2, Observable.from(Arrays.asList(1, 2)).elementAt(1).toBlocking().single()
                 .intValue());
     }
 
@@ -38,18 +38,18 @@ public void testElementAtWithMinusIndex() {
 
     @Test(expected = IndexOutOfBoundsException.class)
     public void testElementAtWithIndexOutOfBounds() {
-        Observable.from(Arrays.asList(1, 2)).elementAt(2).toBlockingObservable().single();
+        Observable.from(Arrays.asList(1, 2)).elementAt(2).toBlocking().single();
     }
 
     @Test
     public void testElementAtOrDefault() {
-        assertEquals(2, Observable.from(Arrays.asList(1, 2)).elementAtOrDefault(1, 0).toBlockingObservable()
+        assertEquals(2, Observable.from(Arrays.asList(1, 2)).elementAtOrDefault(1, 0).toBlocking()
                 .single().intValue());
     }
 
     @Test
     public void testElementAtOrDefaultWithIndexOutOfBounds() {
-        assertEquals(0, Observable.from(Arrays.asList(1, 2)).elementAtOrDefault(2, 0).toBlockingObservable()
+        assertEquals(0, Observable.from(Arrays.asList(1, 2)).elementAtOrDefault(2, 0).toBlocking()
                 .single().intValue());
     }
 
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
index ebc6ee8183..2e1249d2fc 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorGroupByTest.java
@@ -137,7 +137,7 @@ private static <K, V> Map<K, Collection<V>> toMap(Observable<GroupedObservable<K
 
         final ConcurrentHashMap<K, Collection<V>> result = new ConcurrentHashMap<K, Collection<V>>();
 
-        observable.toBlockingObservable().forEach(new Action1<GroupedObservable<K, V>>() {
+        observable.toBlocking().forEach(new Action1<GroupedObservable<K, V>>() {
 
             @Override
             public void call(final GroupedObservable<K, V> o) {
@@ -640,7 +640,7 @@ public String call(Integer t1) {
                 }
             }
 
-        }).toBlockingObservable().forEach(new Action1<String>() {
+        }).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String s) {
@@ -732,7 +732,7 @@ public void call(Notification<? super String> t1) {
                 System.err.println("outer notification => " + t1);
             }
 
-        }).toBlockingObservable().forEach(new Action1<String>() {
+        }).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String s) {
@@ -809,7 +809,7 @@ public String call(Integer t1) {
                 }
             }
 
-        }).toBlockingObservable().forEach(new Action1<String>() {
+        }).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String s) {
@@ -865,7 +865,7 @@ public void call(Notification<? super String> t1) {
                 System.out.println("notification => " + t1);
             }
 
-        }).toBlockingObservable().forEach(new Action1<String>() {
+        }).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String s) {
@@ -913,7 +913,7 @@ public String call(Integer t1) {
                 });
             }
 
-        }).toBlockingObservable().forEach(new Action1<String>() {
+        }).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String s) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorLastTest.java b/rxjava-core/src/test/java/rx/operators/OperatorLastTest.java
index 5eee929fbd..f4837daf37 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorLastTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorLastTest.java
@@ -35,20 +35,20 @@ public class OperatorLastTest {
     @Test
     public void testLastWithElements() {
         Observable<Integer> last = Observable.from(1, 2, 3).last();
-        assertEquals(3, last.toBlockingObservable().single().intValue());
+        assertEquals(3, last.toBlocking().single().intValue());
     }
 
     @Test(expected = NoSuchElementException.class)
     public void testLastWithNoElements() {
         Observable<?> last = Observable.empty().last();
-        last.toBlockingObservable().single();
+        last.toBlocking().single();
     }
 
     @Test
     public void testLastMultiSubscribe() {
         Observable<Integer> last = Observable.from(1, 2, 3).last();
-        assertEquals(3, last.toBlockingObservable().single().intValue());
-        assertEquals(3, last.toBlockingObservable().single().intValue());
+        assertEquals(3, last.toBlocking().single().intValue());
+        assertEquals(3, last.toBlocking().single().intValue());
     }
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
index ae0c505d46..9a087d2587 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMapTest.java
@@ -193,7 +193,7 @@ public void testMapWithIssue417() {
                     public Integer call(Integer arg0) {
                         throw new IllegalArgumentException("any error");
                     }
-                }).toBlockingObservable().single();
+                }).toBlocking().single();
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -210,7 +210,7 @@ public String call(String arg0) {
                 });
 
         // block for response, expecting exception thrown
-        m.toBlockingObservable().last();
+        m.toBlocking().last();
     }
 
     /**
@@ -225,7 +225,7 @@ public Integer call(Integer i) {
                 return i;
             }
 
-        }).toBlockingObservable().single();
+        }).toBlocking().single();
     }
 
     /**
@@ -240,7 +240,7 @@ public Object call(Object i) {
                 return i;
             }
 
-        }).toBlockingObservable().single();
+        }).toBlocking().single();
     }
 
     /**
@@ -256,7 +256,7 @@ public Integer call(Integer i) {
                 return i / 0;
             }
 
-        }).toBlockingObservable().single();
+        }).toBlocking().single();
     }
 
     @Test(expected = OnErrorNotImplementedException.class)
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
index 6f3e05efee..f3fa354ec6 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMaterializeTest.java
@@ -89,8 +89,8 @@ public void testMultipleSubscribes() throws InterruptedException, ExecutionExcep
 
         Observable<Notification<String>> m = Observable.create(o).materialize();
 
-        assertEquals(3, m.toList().toBlockingObservable().toFuture().get().size());
-        assertEquals(3, m.toList().toBlockingObservable().toFuture().get().size());
+        assertEquals(3, m.toList().toBlocking().toFuture().get().size());
+        assertEquals(3, m.toList().toBlocking().toFuture().get().size());
     }
 
     private static class TestObserver extends Subscriber<Notification<String>> {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
index e4a68e6c56..a51f791f5f 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeMaxConcurrentTest.java
@@ -53,7 +53,7 @@ public void testWhenMaxConcurrentIsOne() {
             os.add(Observable.from("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread()));
 
             List<String> expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five");
-            Iterator<String> iter = Observable.merge(os, 1).toBlockingObservable().toIterable().iterator();
+            Iterator<String> iter = Observable.merge(os, 1).toBlocking().toIterable().iterator();
             List<String> actual = new ArrayList<String>();
             while (iter.hasNext()) {
                 actual.add(iter.next());
@@ -78,7 +78,7 @@ public void testMaxConcurrent() {
                 os.add(Observable.create(sco));
             }
 
-            Iterator<String> iter = Observable.merge(os, maxConcurrent).toBlockingObservable().toIterable().iterator();
+            Iterator<String> iter = Observable.merge(os, maxConcurrent).toBlocking().toIterable().iterator();
             List<String> actual = new ArrayList<String>();
             while (iter.hasNext()) {
                 actual.add(iter.next());
@@ -134,7 +134,7 @@ public void testMergeALotOfSourcesOneByOneSynchronously() {
         for (int i = 0; i < n; i++) {
             sourceList.add(Observable.just(i));
         }
-        Iterator<Integer> it = Observable.merge(Observable.from(sourceList), 1).toBlockingObservable().getIterator();
+        Iterator<Integer> it = Observable.merge(Observable.from(sourceList), 1).toBlocking().getIterator();
         int j = 0;
         while (it.hasNext()) {
             assertEquals((Integer)j, it.next());
@@ -149,7 +149,7 @@ public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() {
         for (int i = 0; i < n; i++) {
             sourceList.add(Observable.just(i));
         }
-        Iterator<Integer> it = Observable.merge(Observable.from(sourceList), 1).take(n / 2).toBlockingObservable().getIterator();
+        Iterator<Integer> it = Observable.merge(Observable.from(sourceList), 1).take(n / 2).toBlocking().getIterator();
         int j = 0;
         while (it.hasNext()) {
             assertEquals((Integer)j, it.next());
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
index 7cec6e3e1f..7358194399 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorMergeTest.java
@@ -159,7 +159,7 @@ public void run() {
         });
 
         final AtomicInteger count = new AtomicInteger();
-        Observable.merge(source).take(6).toBlockingObservable().forEach(new Action1<Long>() {
+        Observable.merge(source).take(6).toBlocking().forEach(new Action1<Long>() {
 
             @Override
             public void call(Long v) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
index b556653b5a..daf203a25b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorObserveOnTest.java
@@ -235,7 +235,7 @@ public Integer call(Integer t1) {
             }
 
         }).observeOn(Schedulers.newThread())
-                .toBlockingObservable().forEach(new Action1<Integer>() {
+                .toBlocking().forEach(new Action1<Integer>() {
 
                     @Override
                     public void call(Integer t1) {
@@ -262,7 +262,7 @@ public Integer call(Integer t1) {
             }
 
         }).observeOn(Schedulers.computation())
-                .toBlockingObservable().forEach(new Action1<Integer>() {
+                .toBlocking().forEach(new Action1<Integer>() {
 
                     @Override
                     public void call(Integer t1) {
@@ -302,7 +302,7 @@ public Integer call(Integer t1) {
             }
 
         }).observeOn(Schedulers.computation())
-                .toBlockingObservable().forEach(new Action1<Integer>() {
+                .toBlocking().forEach(new Action1<Integer>() {
 
                     @Override
                     public void call(Integer t1) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorParallelMergeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorParallelMergeTest.java
index 138fbff62b..c64e3e217b 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorParallelMergeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorParallelMergeTest.java
@@ -44,9 +44,9 @@ public void testParallelMerge() {
         Observable<Observable<String>> twoStreams = Observable.parallelMerge(fourStreams, 2);
         Observable<Observable<String>> threeStreams = Observable.parallelMerge(fourStreams, 3);
 
-        List<? super Observable<String>> fourList = fourStreams.toList().toBlockingObservable().last();
-        List<? super Observable<String>> threeList = threeStreams.toList().toBlockingObservable().last();
-        List<? super Observable<String>> twoList = twoStreams.toList().toBlockingObservable().last();
+        List<? super Observable<String>> fourList = fourStreams.toList().toBlocking().last();
+        List<? super Observable<String>> threeList = threeStreams.toList().toBlocking().last();
+        List<? super Observable<String>> twoList = twoStreams.toList().toBlocking().last();
 
         System.out.println("two list: " + twoList);
         System.out.println("three list: " + threeList);
@@ -71,7 +71,7 @@ public Observable<String> call(Observable<String> o) {
                         return o.observeOn(Schedulers.newThread());
                     }
                 })
-                .toBlockingObservable().forEach(new Action1<String>() {
+                .toBlocking().forEach(new Action1<String>() {
 
                     @Override
                     public void call(String o) {
@@ -90,7 +90,7 @@ public void testNumberOfThreadsOnScheduledMerge() {
         // now we parallelMerge into 3 streams and observeOn for each
         // we expect 3 threads in the output
         Observable.merge(Observable.parallelMerge(getStreams(), 3, Schedulers.newThread()))
-                .toBlockingObservable().forEach(new Action1<String>() {
+                .toBlocking().forEach(new Action1<String>() {
 
                     @Override
                     public void call(String o) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
index b0b3ebd712..4d8ab49fb4 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorParallelTest.java
@@ -60,7 +60,7 @@ public Integer[] call(Integer t) {
                         });
                     }
                 })
-                .toBlockingObservable().forEach(new Action1<Integer[]>() {
+                .toBlocking().forEach(new Action1<Integer[]>() {
 
                     @Override
                     public void call(Integer[] v) {
@@ -94,7 +94,7 @@ public Observable<String> call(Integer t) {
 
                         });
                     }
-                }).toBlockingObservable().forEach(new Action1<String>() {
+                }).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String v) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
index 8693017478..e2916cea60 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorRepeatTest.java
@@ -48,7 +48,7 @@ public void call(final Subscriber<? super Integer> o) {
                 o.onNext(count.incrementAndGet());
                 o.onCompleted();
             }
-        }).repeat(Schedulers.computation()).take(NUM).toBlockingObservable().last();
+        }).repeat(Schedulers.computation()).take(NUM).toBlocking().last();
 
         assertEquals(NUM, value);
     }
@@ -56,13 +56,13 @@ public void call(final Subscriber<? super Integer> o) {
     @Test(timeout = 2000)
     public void testRepeatTake() {
         Observable<Integer> xs = Observable.from(1, 2);
-        Object[] ys = xs.repeat(Schedulers.newThread()).take(4).toList().toBlockingObservable().last().toArray();
+        Object[] ys = xs.repeat(Schedulers.newThread()).take(4).toList().toBlocking().last().toArray();
         assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys);
     }
 
     @Test(timeout = 20000)
     public void testNoStackOverFlow() {
-        Observable.from(1).repeat(Schedulers.newThread()).take(100000).toBlockingObservable().last();
+        Observable.from(1).repeat(Schedulers.newThread()).take(100000).toBlocking().last();
     }
 
     @Test
@@ -92,7 +92,7 @@ public Integer call(Integer t1) {
                 return t1;
             }
 
-        }).take(4).toList().toBlockingObservable().last().toArray();
+        }).take(4).toList().toBlocking().last().toArray();
 
         assertEquals(2, counter.get());
         assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys);
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
index ad2db450f4..2f663e7097 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeTest.java
@@ -83,7 +83,7 @@ public void testTakeWithError() {
             public Integer call(Integer t1) {
                 throw new IllegalArgumentException("some error");
             }
-        }).toBlockingObservable().single();
+        }).toBlocking().single();
     }
 
     @Test
@@ -237,7 +237,7 @@ public void call(Subscriber<? super Integer> s) {
                 }
             }
 
-        }).take(100).take(1).toBlockingObservable().forEach(new Action1<Integer>() {
+        }).take(100).take(1).toBlocking().forEach(new Action1<Integer>() {
 
             @Override
             public void call(Integer t1) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java b/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
index 00a8d5db34..b04e5f9965 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorTakeWhileTest.java
@@ -121,7 +121,7 @@ public void call(Subscriber<? super String> observer) {
             public Boolean call(String s) {
                 return false;
             }
-        }).toBlockingObservable().lastOrDefault("");
+        }).toBlocking().lastOrDefault("");
     }
 
     @Test
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java b/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
index dba65f5206..c6baadd4c5 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorUsingTest.java
@@ -152,7 +152,7 @@ public Observable<Integer> call(Subscription subscription) {
             }
         };
 
-        Observable.using(resourceFactory, observableFactory).toBlockingObservable().last();
+        Observable.using(resourceFactory, observableFactory).toBlocking().last();
     }
 
     @Test
@@ -173,7 +173,7 @@ public Observable<Integer> call(Subscription subscription) {
         };
 
         try {
-            Observable.using(resourceFactory, observableFactory).toBlockingObservable().last();
+            Observable.using(resourceFactory, observableFactory).toBlocking().last();
             fail("Should throw a TestException when the observableFactory throws it");
         } catch (TestException e) {
             // Make sure that unsubscribe is called so that users can close
@@ -205,7 +205,7 @@ public void call(Subscriber<? super Integer> t1) {
         };
 
         try {
-            Observable.using(resourceFactory, observableFactory).toBlockingObservable().last();
+            Observable.using(resourceFactory, observableFactory).toBlocking().last();
             fail("Should throw a TestException when the observableFactory throws it");
         } catch (TestException e) {
             // Make sure that unsubscribe is called so that users can close
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java b/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
index d8d90aca1f..fbb094dcbd 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorWindowTest.java
@@ -62,7 +62,7 @@ public Observable<List<T>> call(Observable<T> xs) {
                 return xs.toList();
             }
         }))
-                .toBlockingObservable()
+                .toBlocking()
                 .forEach(new Action1<List<T>>() {
                     @Override
                     public void call(List<T> xs) {
diff --git a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
index 245dc85d2e..2068a98d80 100644
--- a/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
+++ b/rxjava-core/src/test/java/rx/operators/OperatorZipTest.java
@@ -1036,7 +1036,7 @@ public Object call(final Object... args) {
             }
         });
 
-        o.toBlockingObservable().last();
+        o.toBlocking().last();
     }
 
     Observable<Integer> OBSERVABLE_OF_5_INTEGERS = OBSERVABLE_OF_5_INTEGERS(new AtomicInteger());
diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index c1f1ef69c7..003be4852c 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -130,7 +130,7 @@ public String call(String s) {
 
         });
 
-        List<String> strings = m.toList().toBlockingObservable().last();
+        List<String> strings = m.toList().toBlocking().last();
 
         assertEquals(4, strings.size());
         // because flatMap does a merge there is no guarantee of order
@@ -333,7 +333,7 @@ public void call() {
         });
 
         final AtomicInteger lastValue = new AtomicInteger();
-        obs.toBlockingObservable().forEach(new Action1<Integer>() {
+        obs.toBlocking().forEach(new Action1<Integer>() {
 
             @Override
             public void call(Integer v) {
diff --git a/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
index ae492f9997..c4090bd1aa 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ComputationSchedulerTests.java
@@ -102,7 +102,7 @@ public String call(Integer t) {
             }
         });
 
-        o.subscribeOn(Schedulers.computation()).toBlockingObservable().forEach(new Action1<String>() {
+        o.subscribeOn(Schedulers.computation()).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String t) {
@@ -129,7 +129,7 @@ public String call(Integer t) {
             }
         });
 
-        o.toBlockingObservable().forEach(new Action1<String>() {
+        o.toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String t) {
diff --git a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
index 36cae71fee..ee52a0b5fd 100644
--- a/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/ImmediateSchedulerTest.java
@@ -68,7 +68,7 @@ public String call(Integer t) {
             }
         });
 
-        o.toBlockingObservable().forEach(new Action1<String>() {
+        o.toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String t) {
@@ -93,7 +93,7 @@ public String call(Integer t) {
             }
         });
 
-        o.toBlockingObservable().forEach(new Action1<String>() {
+        o.toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String t) {
diff --git a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
index 2bc2f2088d..37b314a0dd 100644
--- a/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/NewThreadSchedulerTest.java
@@ -49,7 +49,7 @@ public String call(Integer t) {
             }
         });
 
-        o.subscribeOn(Schedulers.io()).toBlockingObservable().forEach(new Action1<String>() {
+        o.subscribeOn(Schedulers.io()).toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String t) {
diff --git a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
index 0add9db59d..a904675f13 100644
--- a/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
+++ b/rxjava-core/src/test/java/rx/schedulers/TrampolineSchedulerTest.java
@@ -47,7 +47,7 @@ public String call(Integer t) {
             }
         });
 
-        o.toBlockingObservable().forEach(new Action1<String>() {
+        o.toBlocking().forEach(new Action1<String>() {
 
             @Override
             public void call(String t) {
diff --git a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
index b6e5606dd7..1d7c189cae 100644
--- a/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/AsyncSubjectTest.java
@@ -274,7 +274,7 @@ public SubjectObserverThread(AsyncSubject<String> subject) {
         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();
+                String v = subject.timeout(2000, TimeUnit.MILLISECONDS).toBlocking().single();
                 value.set(v);
             } catch (Exception e) {
                 e.printStackTrace();
diff --git a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
index 7e0a58974b..54ea5ce21c 100644
--- a/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
+++ b/rxjava-core/src/test/java/rx/subjects/ReplaySubjectConcurrencyTest.java
@@ -71,7 +71,7 @@ public void call(Subscriber<? super Long> o) {
         });
         source.start();
 
-        long v = replay.toBlockingObservable().last();
+        long v = replay.toBlocking().last();
         assertEquals(10000, v);
 
         // it's been played through once so now it will all be replays
@@ -198,7 +198,7 @@ public void call(Subscriber<? super Long> o) {
 
                 @Override
                 public void run() {
-                    List<Long> values = replay.toList().toBlockingObservable().last();
+                    List<Long> values = replay.toList().toBlocking().last();
                     listOfListsOfValues.add(values);
                     System.out.println("Finished thread: " + count);
                 }
@@ -330,7 +330,7 @@ public SubjectObserverThread(ReplaySubject<String> subject) {
         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();
+                String v = subject.timeout(2000, TimeUnit.MILLISECONDS).toBlocking().single();
                 value.set(v);
             } catch (Exception e) {
                 e.printStackTrace();
diff --git a/rxjava-core/src/test/java/rx/util/AssertObservable.java b/rxjava-core/src/test/java/rx/util/AssertObservable.java
index f2249aa60b..d95a1bb54d 100644
--- a/rxjava-core/src/test/java/rx/util/AssertObservable.java
+++ b/rxjava-core/src/test/java/rx/util/AssertObservable.java
@@ -48,7 +48,7 @@ public static <T> void assertObservableEqualsBlocking(Observable<T> expected, Ob
      *            Observable with actual values
      */
     public static <T> void assertObservableEqualsBlocking(String message, Observable<T> expected, Observable<T> actual) {
-        assertObservableEquals(expected, actual).toBlockingObservable().lastOrDefault(null);
+        assertObservableEquals(expected, actual).toBlocking().lastOrDefault(null);
     }
 
     /**

From 17529d01162b56024c571200b2e4f27744d03fef Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Tue, 20 May 2014 11:12:32 -0700
Subject: [PATCH 412/422] (#1230) javadocs for serialize() also some
 improvements to javadocs for share()

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index e19f1855df..0e6818ff91 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -5318,6 +5318,17 @@ public final <R> Observable<R> scan(R initialValue, Func2<R, ? super T, R> accum
     }
 
     /*
+     * Forces an Observable to make synchronous calls and to be well-behaved.
+     * <p>
+     * It is possible for an Observable to invoke its Subscribers' methods asynchronously, perhaps in different
+     * threads. This could make an Observable poorly-behaved, in that it might invoke {@code onCompleted} or
+     * {@code onError} before one of its {@code onNext} invocations. You can force such an Observable to be
+     * well-behaved and synchronous by applying the {@code serialize()} method to it.
+     * <p>
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/synchronize.png">
+     *
+     * @return a {@link Observable} that is guaranteed to be well-behaved and synchronous
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable-Utility-Operators#serialize">RxJava Wiki: serialize()</a>
      * @since 0.17
      */
     public final Observable<T> serialize() {
@@ -5325,17 +5336,18 @@ public final Observable<T> serialize() {
     }
 
     /**
-     * Returns a new {@link Observable} that multicasts (shares) the original {@link Observable}. 
-     * As long as there is more than 1 {@link Subscriber} this {@link Observable} will be subscribed and emitting data. 
+     * Returns a new {@link Observable} that multicasts (shares) the original {@link Observable}. As long as
+     * there is more than 1 {@link Subscriber} this {@link Observable} will be subscribed and emitting data. 
      * When all subscribers have unsubscribed it will unsubscribe from the source {@link Observable}. 
      * <p>
      * This is an alias for {@link #publish().refCount()}.
      * <p>
-     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishConnect.png">
+     * <img width="640" src="https://raw.github.com/wiki/Netflix/RxJava/images/rx-operators/publishRefCount.png">
      * 
      * @return a {@link Observable} that upon connection causes the source Observable to emit items
      *         to its {@link Observer}s
-     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#wiki-observablepublish-and-observablemulticast">RxJava Wiki: publish()</a>
+     * @see <a href="https://github.com/Netflix/RxJava/wiki/Connectable-Observable-Operators#connectableobservablerefcount">RxJava Wiki: refCount()</a>
+     * @since 0.19
      */
     public final Observable<T> share() {
         return publish().refCount();

From 6b60a4a75f52df4db1dd8c42499ed259eec3643a Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Tue, 20 May 2014 11:18:52 -0700
Subject: [PATCH 413/422] adding @since javadoc annotation to new methods

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

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 8ce2d39e83..700a263b17 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -3916,7 +3916,8 @@ public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? e
      * @throws IllegalArgumentException
      *             if {@code onComplete} is null
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     * */
+     * @since 0.19
+     */
     public final void forEach(final Action1<? super T> onNext) {
         subscribe(onNext);
     }
@@ -3937,7 +3938,8 @@ public final void forEach(final Action1<? super T> onNext) {
      * @throws IllegalArgumentException
      *             if {@code onComplete} is null
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     * */
+     * @since 0.19
+     */
     public final void forEach(final Action1<? super T> onNext, final Action1<Throwable> onError) {
         subscribe(onNext, onError);
     }
@@ -3960,7 +3962,8 @@ public final void forEach(final Action1<? super T> onNext, final Action1<Throwab
      * @throws IllegalArgumentException
      *             if {@code onComplete} is null
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Observable#wiki-onnext-oncompleted-and-onerror">RxJava Wiki: onNext, onCompleted, and onError</a>
-     * */
+     * @since 0.19
+     */
     public final void forEach(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onComplete) {
         subscribe(onNext, onError, onComplete);
     }
@@ -4195,6 +4198,7 @@ public final Observable<T> lastOrDefault(T defaultValue, Func1<? super T, Boolea
      * @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 <a href="https://github.com/Netflix/RxJava/wiki/Filtering-Observables#wiki-take">RxJava Wiki: take()</a>
+     * @since 0.19
      */
     public final Observable<T> limit(int num) {
         return take(num);

From 566e89282fe687a66571b6fe6c9a362f98238ee7 Mon Sep 17 00:00:00 2001
From: David Gross <davgross@netflix.com>
Date: Tue, 20 May 2014 11:23:56 -0700
Subject: [PATCH 414/422] Adding another @since annotation to the toBlocking()
 javadocs

---
 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 706e1d19e9..aff51453e8 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -7061,6 +7061,7 @@ public final BlockingObservable<T> toBlockingObservable() {
      *
      * @return a {@code BlockingObservable} version of this Observable
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Blocking-Observable-Operators">RxJava Wiki: Blocking Observable Observers</a>
+     * @since 0.19
      */
     public final BlockingObservable<T> toBlocking() {
         return BlockingObservable.from(this);

From 7a1ad18ae4f861b095ce64e55fdb8799cd57616d Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 21 May 2014 14:27:31 +0200
Subject: [PATCH 415/422] Switch to AtomicReferenceFieldUpdater.

---
 .../subscriptions/CompositeSubscription.java  | 44 ++++++++++---------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
index f9f045def7..79fd979f55 100644
--- a/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
+++ b/rxjava-core/src/main/java/rx/subscriptions/CompositeSubscription.java
@@ -18,6 +18,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
 import rx.Subscription;
 import rx.exceptions.CompositeException;
@@ -29,8 +30,11 @@
  * @see <a href="http://msdn.microsoft.com/en-us/library/system.reactive.disposables.compositedisposable(v=vs.103).aspx">Rx.Net equivalent CompositeDisposable</a>
  */
 public final class CompositeSubscription implements Subscription {
-
-    private final AtomicReference<State> state = new AtomicReference<State>();
+    /** The atomic state updater. */
+    static final AtomicReferenceFieldUpdater<CompositeSubscription, State> STATE_UPDATER
+            = AtomicReferenceFieldUpdater.newUpdater(CompositeSubscription.class, State.class, "state");
+    /** The subscription state. */
+    volatile State state;
 
     /** Empty initial state. */
     private static final State CLEAR_STATE;
@@ -97,43 +101,45 @@ State clear() {
     }
 
     public CompositeSubscription() {
-        state.set(CLEAR_STATE);
+        // this creates only a store-store barrier which is generally faster when
+        // CompositeSubscriptions are created in a tight loop.
+        STATE_UPDATER.lazySet(this, CLEAR_STATE);
     }
 
     public CompositeSubscription(final Subscription... subscriptions) {
-        state.set(new State(false, subscriptions));
+        STATE_UPDATER.lazySet(this, new State(false, subscriptions));
     }
 
     @Override
     public boolean isUnsubscribed() {
-        return state.get().isUnsubscribed;
+        return state.isUnsubscribed;
     }
 
     public void add(final Subscription s) {
         State oldState;
         State newState;
         do {
-            oldState = state.get();
+            oldState = state;
             if (oldState.isUnsubscribed) {
                 s.unsubscribe();
                 return;
             } else {
                 newState = oldState.add(s);
             }
-        } while (!state.compareAndSet(oldState, newState));
+        } while (!STATE_UPDATER.compareAndSet(this, oldState, newState));
     }
 
     public void remove(final Subscription s) {
         State oldState;
         State newState;
         do {
-            oldState = state.get();
+            oldState = state;
             if (oldState.isUnsubscribed) {
                 return;
             } else {
                 newState = oldState.remove(s);
             }
-        } while (!state.compareAndSet(oldState, newState));
+        } while (!STATE_UPDATER.compareAndSet(this, oldState, newState));
         // if we removed successfully we then need to call unsubscribe on it
         s.unsubscribe();
     }
@@ -142,29 +148,25 @@ public void clear() {
         State oldState;
         State newState;
         do {
-            oldState = state.get();
+            oldState = state;
             if (oldState.isUnsubscribed) {
                 return;
             } else {
                 newState = oldState.clear();
             }
-        } while (!state.compareAndSet(oldState, newState));
+        } while (!STATE_UPDATER.compareAndSet(this, oldState, newState));
         // if we cleared successfully we then need to call unsubscribe on all previous
         unsubscribeFromAll(oldState.subscriptions);
     }
 
     @Override
     public void unsubscribe() {
-        State oldState;
-        State newState;
-        do {
-            oldState = state.get();
-            if (oldState.isUnsubscribed) {
-                return;
-            } else {
-                newState = oldState.unsubscribe();
-            }
-        } while (!state.compareAndSet(oldState, newState));
+        State oldState = state;
+        if (oldState.isUnsubscribed) {
+            return;
+        }
+        // intrinsics may make this a single instruction and may prevent concurrent add/remove faster
+        oldState = STATE_UPDATER.getAndSet(this, oldState.unsubscribe());
         unsubscribeFromAll(oldState.subscriptions);
     }
 

From 3c13498d1445b024cab606b95fabdaf0f342e18b Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@gmail.com>
Date: Wed, 21 May 2014 14:50:12 +0200
Subject: [PATCH 416/422] Changed to field updater

---
 .../src/main/java/rx/observers/SafeSubscriber.java | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
index 1bdbcd8272..828ee41a0e 100644
--- a/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
+++ b/rxjava-core/src/main/java/rx/observers/SafeSubscriber.java
@@ -16,7 +16,7 @@
 package rx.observers;
 
 import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 
 import rx.Subscriber;
 import rx.exceptions.CompositeException;
@@ -60,7 +60,11 @@
 public class SafeSubscriber<T> extends Subscriber<T> {
 
     private final Subscriber<? super T> actual;
-    private final AtomicBoolean isFinished = new AtomicBoolean(false);
+    /** Terminal state indication if not zero. */
+    volatile int done;
+    @SuppressWarnings("rawtypes")
+    static final AtomicIntegerFieldUpdater<SafeSubscriber> DONE_UPDATER
+            = AtomicIntegerFieldUpdater.newUpdater(SafeSubscriber.class, "done");
 
     public SafeSubscriber(Subscriber<? super T> actual) {
         super(actual);
@@ -69,7 +73,7 @@ public SafeSubscriber(Subscriber<? super T> actual) {
 
     @Override
     public void onCompleted() {
-        if (isFinished.compareAndSet(false, true)) {
+        if (DONE_UPDATER.getAndSet(this, 1) == 0) {
             try {
                 actual.onCompleted();
             } catch (Throwable e) {
@@ -90,7 +94,7 @@ 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)) {
+        if (DONE_UPDATER.getAndSet(this, 1) == 0) {
             _onError(e);
         }
     }
@@ -98,7 +102,7 @@ public void onError(Throwable e) {
     @Override
     public void onNext(T args) {
         try {
-            if (!isFinished.get()) {
+            if (done == 0) {
                 actual.onNext(args);
             }
         } catch (Throwable e) {

From 784f67663740279d35a803247dcd7a763fa8a68a Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Wed, 21 May 2014 22:41:54 +0800
Subject: [PATCH 417/422] Update docs for "apply" and add an example

---
 .../rx/lang/scala/examples/RxScalaDemo.scala  | 28 +++++++++++++++++++
 .../main/scala/rx/lang/scala/Observable.scala | 11 +++++++-
 2 files changed, 38 insertions(+), 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 3800a85a21..40ed6bdf1f 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
@@ -620,6 +620,34 @@ class RxScalaDemo extends JUnitSuite {
     o.take(1).subscribe(println(_))
   }
 
+  @Test def createExampleGood2() {
+    import scala.io.{Codec, Source}
+
+    val rxscala = Observable[String](subscriber => {
+      try {
+        val input = new java.net.URL("http://rxscala.github.io/").openStream()
+        subscriber.add(Subscription {
+          input.close()
+        })
+        Source.fromInputStream(input)(Codec.UTF8).getLines()
+          .takeWhile(_ => !subscriber.isUnsubscribed)
+          .foreach(subscriber.onNext(_))
+        if (!subscriber.isUnsubscribed) {
+          subscriber.onCompleted()
+        }
+      }
+      catch {
+        case e: Throwable => if (!subscriber.isUnsubscribed) subscriber.onError(e)
+      }
+    }).subscribeOn(IOScheduler())
+
+    val count = rxscala.flatMap(_.split("\\W+").toSeq.toObservable)
+      .map(_.toLowerCase)
+      .filter(_ == "rxscala")
+      .size
+    println(s"RxScala appears ${count.toBlockingObservable.single} times in http://rxscala.github.io/")
+  }
+
   def output(s: String): Unit = println(s)
 
   /** Subscribes to obs and waits until obs has completed. Note that if you subscribe to
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 c16f9d5af7..eb3d078516 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
@@ -3330,10 +3330,19 @@ object Observable {
    * Write the function you pass so that it behaves as an Observable: It should invoke the
    * Subscriber's `onNext`, `onError`, and `onCompleted` methods appropriately.
    *
+   * You can `add` custom [[Subscription]]s to [[Subscriber]]. These [[Subscription]]s will be called
+   * <ul>
+   *   <li>when someone calls `unsubscribe`.</li>
+   *   <li>after `onCompleted` or `onError`.</li>
+   * </ul>
+   *
    * See <a href="http://go.microsoft.com/fwlink/?LinkID=205219">Rx Design Guidelines (PDF)</a> for detailed
    * information.
    *
-   * @tparam T
+   * See `<a href="https://github.com/Netflix/RxJava/blob/master/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala">RxScalaDemo</a>.createExampleGood`
+   * and `<a href="https://github.com/Netflix/RxJava/blob/master/language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala">RxScalaDemo</a>.createExampleGood2`.
+   *
+   * @param T
    *            the type of the items that this Observable emits
    * @param f
    *            a function that accepts a `Subscriber[T]`, and invokes its `onNext`,

From 310cecad2640e65f374a91605de3a9f056485f5e Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 21 May 2014 21:22:51 -0700
Subject: [PATCH 418/422] JMH Tests for Simple Use Cases

---
 .../perf/java/rx/usecases/PerfObserveOn.java  | 30 +++++++
 .../perf/java/rx/usecases/PerfTransforms.java | 71 ++++++++++++++++
 .../perf/java/rx/usecases/UseCaseInput.java   | 81 +++++++++++++++++++
 3 files changed, 182 insertions(+)
 create mode 100644 rxjava-core/src/perf/java/rx/usecases/PerfObserveOn.java
 create mode 100644 rxjava-core/src/perf/java/rx/usecases/PerfTransforms.java
 create mode 100644 rxjava-core/src/perf/java/rx/usecases/UseCaseInput.java

diff --git a/rxjava-core/src/perf/java/rx/usecases/PerfObserveOn.java b/rxjava-core/src/perf/java/rx/usecases/PerfObserveOn.java
new file mode 100644
index 0000000000..3b6aa1d2ea
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/usecases/PerfObserveOn.java
@@ -0,0 +1,30 @@
+/**
+ * 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.usecases;
+
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+
+import rx.schedulers.Schedulers;
+
+public class PerfObserveOn {
+
+    @GenerateMicroBenchmark
+    public void observeOn(UseCaseInput input) throws InterruptedException {
+        input.observable.observeOn(Schedulers.computation()).subscribe(input.observer);
+        input.awaitCompletion();
+    }
+
+}
diff --git a/rxjava-core/src/perf/java/rx/usecases/PerfTransforms.java b/rxjava-core/src/perf/java/rx/usecases/PerfTransforms.java
new file mode 100644
index 0000000000..d67ccd3a0e
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/usecases/PerfTransforms.java
@@ -0,0 +1,71 @@
+/**
+ * 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.usecases;
+
+import org.openjdk.jmh.annotations.GenerateMicroBenchmark;
+
+import rx.Observable;
+import rx.functions.Func1;
+
+public class PerfTransforms {
+
+    @GenerateMicroBenchmark
+    public void mapTransformation(UseCaseInput input) throws InterruptedException {
+        input.observable.map(new Func1<Integer, String>() {
+
+            @Override
+            public String call(Integer i) {
+                return String.valueOf(i);
+            }
+
+        }).map(new Func1<String, Integer>() {
+
+            @Override
+            public Integer call(String i) {
+                return Integer.parseInt(i);
+            }
+
+        }).subscribe(input.observer);
+        input.awaitCompletion();
+    }
+
+    @GenerateMicroBenchmark
+    public void flatMapTransformsUsingFrom(UseCaseInput input) throws InterruptedException {
+        input.observable.flatMap(new Func1<Integer, Observable<Integer>>() {
+
+            @Override
+            public Observable<Integer> call(Integer i) {
+                return Observable.from(i);
+            }
+
+        }).subscribe(input.observer);
+        input.awaitCompletion();
+    }
+
+    @GenerateMicroBenchmark
+    public void flatMapTransformsUsingJust(UseCaseInput input) throws InterruptedException {
+        input.observable.flatMap(new Func1<Integer, Observable<Integer>>() {
+
+            @Override
+            public Observable<Integer> call(Integer i) {
+                return Observable.just(i);
+            }
+
+        }).subscribe(input.observer);
+        input.awaitCompletion();
+    }
+
+}
diff --git a/rxjava-core/src/perf/java/rx/usecases/UseCaseInput.java b/rxjava-core/src/perf/java/rx/usecases/UseCaseInput.java
new file mode 100644
index 0000000000..c0463d9190
--- /dev/null
+++ b/rxjava-core/src/perf/java/rx/usecases/UseCaseInput.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.usecases;
+
+import java.util.concurrent.CountDownLatch;
+
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.logic.BlackHole;
+
+import rx.Observable;
+import rx.Observable.OnSubscribe;
+import rx.Observer;
+import rx.Subscriber;
+
+/**
+ * Exposes an Observable and Observer that increments n Integers and consumes them in a Blackhole.
+ */
+@State(Scope.Thread)
+public class UseCaseInput {
+    @Param({ "1", "1024" })
+    public int size;
+
+    public Observable<Integer> observable;
+    public Observer<Integer> observer;
+
+    private CountDownLatch latch;
+
+    @Setup
+    public void setup() {
+        observable = Observable.create(new OnSubscribe<Integer>() {
+            @Override
+            public void call(Subscriber<? super Integer> o) {
+                for (int value = 0; value < size; value++) {
+                    o.onNext(value);
+                }
+                o.onCompleted();
+            }
+        });
+
+        final BlackHole bh = new BlackHole();
+        latch = new CountDownLatch(1);
+
+        observer = new Observer<Integer>() {
+            @Override
+            public void onCompleted() {
+                latch.countDown();
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                throw new RuntimeException(e);
+            }
+
+            @Override
+            public void onNext(Integer value) {
+                bh.consume(value);
+            }
+        };
+
+    }
+
+    public void awaitCompletion() throws InterruptedException {
+        latch.await();
+    }
+}

From 0db09c361eae7a1521909ec53b9d046383e37838 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 21 May 2014 21:24:18 -0700
Subject: [PATCH 419/422] Remove Subscription Wrapper from Observable.subscribe

Performance increase from 7.7m to 8.8m ops/second

Before:

Benchmark                              (size)   Mode   Samples         Mean   Mean error    Units
r.u.PerfTransforms.mapTransformation        1  thrpt         5  7714453.187   362218.633    ops/s
r.u.PerfTransforms.mapTransformation        1  thrpt         5  7527144.767   497816.471    ops/s

After:

Benchmark                              (size)   Mode   Samples         Mean   Mean error    Units
r.u.PerfTransforms.mapTransformation        1  thrpt         5  8853534.333   183494.242    ops/s
r.u.PerfTransforms.mapTransformation        1  thrpt         5  8806958.403   452595.219    ops/s
---
 rxjava-core/src/main/java/rx/Observable.java | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index aff51453e8..4afefabc8e 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -6255,16 +6255,7 @@ public final Subscription subscribe(Subscriber<? super T> subscriber) {
                 subscriber = new SafeSubscriber<T>(subscriber);
             }
             onSubscribeFunction.call(subscriber);
-            final Subscription returnSubscription = hook.onSubscribeReturn(subscriber);
-            // 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();
-                }
-
-            });
+            return hook.onSubscribeReturn(subscriber);
         } catch (Throwable e) {
             // special handling for certain Throwable/Error/Exception types
             Exceptions.throwIfFatal(e);

From 2f3c0d5fc119de718124a16b681362d541bb5e09 Mon Sep 17 00:00:00 2001
From: Ben Christensen <benjchristensen@netflix.com>
Date: Wed, 21 May 2014 21:36:50 -0700
Subject: [PATCH 420/422] Observable.from(T) using Observable.just(T)

For code like `Observable.from(1)` Improve performance from ~3.9m to 4.5+m ops/second

Before;

```
r.u.PerfTransforms.flatMapTransformsUsingFrom        1  thrpt         5  3923845.687    46657.660    ops/s
r.u.PerfTransforms.flatMapTransformsUsingFrom     1024  thrpt         5     8924.953     1983.161    ops/s

r.u.PerfTransforms.flatMapTransformsUsingFrom        1  thrpt         5  3623228.857   490894.492    ops/s
r.u.PerfTransforms.flatMapTransformsUsingFrom     1024  thrpt         5     9176.330      923.929    ops/s
```

After:

```
Benchmark                                       (size)   Mode   Samples         Mean   Mean error    Units
r.u.PerfTransforms.flatMapTransformsUsingFrom        1  thrpt         5  4052364.587   100971.234    ops/s
r.u.PerfTransforms.flatMapTransformsUsingFrom     1024  thrpt         5    11682.783      496.656    ops/s

Benchmark                                       (size)   Mode   Samples         Mean   Mean error    Units
r.u.PerfTransforms.flatMapTransformsUsingFrom        1  thrpt         5  4700583.987    77742.037    ops/s
r.u.PerfTransforms.flatMapTransformsUsingFrom     1024  thrpt         5    12588.803       58.935    ops/s
```

Using this test:

```
../gradlew benchmarks '-Pjmh=-f 1 -tu s -bm thrpt -wi 5 -i 5 -r 5 -prof GC .*PerfTransforms.flatMapTransformsUsingFrom*'
```
---
 rxjava-core/src/main/java/rx/Observable.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java
index 4afefabc8e..9c6f419537 100644
--- a/rxjava-core/src/main/java/rx/Observable.java
+++ b/rxjava-core/src/main/java/rx/Observable.java
@@ -1084,10 +1084,8 @@ public final static <T> Observable<T> from(Iterable<? extends T> iterable, Sched
      * @return an Observable that emits the item
      * @see <a href="https://github.com/Netflix/RxJava/wiki/Creating-Observables#wiki-from">RxJava Wiki: from()</a>
      */
-    // suppress unchecked because we are using varargs inside the method
-    @SuppressWarnings("unchecked")
     public final static <T> Observable<T> from(T t1) {
-        return from(Arrays.asList(t1));
+        return just(t1);
     }
 
     /**

From ba6bf7c359e42a878c42419f4f0e009cb5f5ceb6 Mon Sep 17 00:00:00 2001
From: zsxwing <zsxwing@gmail.com>
Date: Thu, 22 May 2014 16:37:19 +0800
Subject: [PATCH 421/422] Update README.md to new constructors

---
 language-adaptors/rxjava-scala/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/language-adaptors/rxjava-scala/README.md b/language-adaptors/rxjava-scala/README.md
index 30b8d75b63..fb56b94eb1 100644
--- a/language-adaptors/rxjava-scala/README.md
+++ b/language-adaptors/rxjava-scala/README.md
@@ -5,14 +5,14 @@ This adaptor allows to use RxJava in Scala with anonymous functions, e.g.
 ```scala
 val o = Observable.interval(200 millis).take(5)
 o.subscribe(n => println("n = " + n))
-Observable(1, 2, 3, 4).reduce(_ + _)
+Observable.items(1, 2, 3, 4).reduce(_ + _)
 ```
 
 For-comprehensions are also supported:
 
 ```scala
-val first = Observable(10, 11, 12)
-val second = Observable(10, 11, 12)
+val first = Observable.items(10, 11, 12)
+val second = Observable.items(10, 11, 12)
 val booleans = for ((n1, n2) <- (first zip second)) yield (n1 == n2)
 ```
 

From 69894342bbace985bea834a30d258b1a58c5e52d Mon Sep 17 00:00:00 2001
From: akarnokd <akarnokd@akarnokd-PC2>
Date: Thu, 22 May 2014 20:23:13 +0200
Subject: [PATCH 422/422] Fixed testConcurrentOnNextFailsValidation

---
 .../src/test/java/rx/schedulers/AbstractSchedulerTests.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
index 003be4852c..093ad8d999 100644
--- a/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
+++ b/rxjava-core/src/test/java/rx/schedulers/AbstractSchedulerTests.java
@@ -453,8 +453,8 @@ public void onCompleted() {
 
         @Override
         public void onError(Throwable e) {
-            completed.countDown();
             error.set(e);
+            completed.countDown();
         }
 
         @Override