Merge branch 'master' of github.com:MarkVanDerVoort/RxJava into operator-all

Conflicts:
	rxjava-core/src/main/java/rx/Observable.java
	rxjava-core/src/main/java/rx/operators/OperationAll.java
	rxjava-core/src/test/java/rx/operators/OperatorAllTest.java

Author: benjchristensen

rxjava-core/src/main/java/rx/Observable.java

@@ -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));
     }
 
     /**

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));
+                }
+            }
+        };
+    }
+}

rxjava-core/src/test/java/rx/operators/OperationAllTest.java renamed to rxjava-core/src/test/java/rx/operators/OperatorAllTest.java

@@ -18,28 +18,32 @@
 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 java.util.Arrays;
 
 import org.junit.Test;
 
 import rx.Observable;
 import rx.Observer;
 import rx.functions.Func1;
+import rx.observers.TestSubscriber;
+
+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();
@@ -49,15 +53,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();
@@ -67,15 +66,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();
@@ -86,15 +80,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);