add code samples for Conditional and Boolean Operators

Author: LEMUBIT

.idea/workspace.xml

@@ -0,0 +1,24 @@
+/*determine whether all items emitted by an Observable meet some criteria*/
+
+/*Pass a predicate function to the All operator that accepts an item emitted
+by the source Observable and returns a boolean value based on an evaluation of
+that item. All returns an Observable that emits a single boolean value: true if
+and only if the source Observable terminates normally and every item emitted by
+the source Observable evaluated as true according to this predicate; false if any
+item emitted by the source Observable evaluates as false according to this predicate.*/
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+public class All {
+
+    public static void main(String[] args) {
+        Observable.just(1, 2, 3)
+                .all(integer -> integer < 4)
+                .subscribe(
+                aBoolean -> System.out.println(aBoolean),
+                throwable -> System.out.println("Error"),
+                () -> System.out.println("Completed")
+        );
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/All.class

@@ -0,0 +1,31 @@
+/*given two or more source Observables, emit all of the items from only the first of these Observables to emit an item or notification*/
+
+/*When you pass a number of source Observables to Amb, it will pass through the emissions and notifications of exactly one of these
+Observables: the first one that sends a notification to Amb, either by emitting an item or sending an onError or onCompleted notification.
+Amb will ignore and discard the emissions and notifications of all of the other source Observables.*/
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class Amb {
+    public static void main(String[] args) throws InterruptedException {
+        CountDownLatch latch = new CountDownLatch(1);
+        Observable first = Observable.just(5, 5, 5).delay(5, TimeUnit.SECONDS);
+        Observable second = Observable.just(2, 2, 2).delay(2, TimeUnit.SECONDS);
+
+        Observable.amb(first, second).subscribe(
+                o -> System.out.println(o),
+                throwable -> System.out.println("Error"),
+                () -> {
+                    System.out.println("Completed");
+                    latch.countDown();
+                }
+
+        );
+
+        latch.await();
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/Amb.class

@@ -0,0 +1,23 @@
+/*determine whether an Observable emits a particular item or not*/
+
+/*Pass the Contains operator a particular item, and the Observable it returns will
+emit true if that item is emitted by the source Observable, or false if the source
+Observable terminates without emitting that item.
+
+A related operator, IsEmpty returns an Observable that emits true if and only if the
+source Observable completes without emitting any items. It emits false if the source
+Observable emits an item.*/
+
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+public class Contains {
+    public static void main(String[] args) {
+        Observable.just(1, 2, 3).contains(3).subscribe(
+                aBoolean -> System.out.println(aBoolean),
+                throwable -> System.out.println("Error"),
+                () -> System.out.println("Completed")
+        );
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/Contains.class

@@ -0,0 +1,19 @@
+/*emit items from the source Observable, or a default item if the source Observable emits nothing*/
+
+/*The DefaultIfEmpty operator simply mirrors the source Observable exactly if the source Observable
+emits any items. If the source Observable terminates normally (with an onComplete) without emitting any items,
+the Observable returned from DefaultIfEmpty will instead emit a default item of your choosing before it too completes.*/
+
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+public class DefaultIfEmpty {
+    public static void main(String[] args) {
+        Observable.empty().defaultIfEmpty(77).subscribe(
+                o -> System.out.println(o),
+                throwable -> System.out.println("Error"),
+                () -> System.out.println("Completed")
+        );
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/DefaultIfEmpty.class

@@ -0,0 +1,30 @@
+/*determine whether two Observables emit the same sequence of items*/
+
+/*Pass SequenceEqual two Observables, and it will compare the items
+emitted by each Observable, and the Observable it returns will emit
+true only if both sequences are the same (the same items, in the same
+order, with the same termination state).*/
+
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+public class SequenceEqual {
+    public static void main(String[] args) {
+        Observable first = Observable.just(1, 3, 2);
+        Observable second = Observable.just(1, 2, 3);
+        Observable third = Observable.just(1, 2, 3);
+
+        Observable.sequenceEqual(first, second).subscribe(
+                o -> System.out.println(o),
+                throwable -> System.out.println("Error"),
+                () -> System.out.println("Completed not equal")
+        );
+
+        Observable.sequenceEqual(second, third).subscribe(
+                o -> System.out.println(o),
+                throwable -> System.out.println("Error"),
+                () -> System.out.println("Completed equal")
+        );
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/SequenceEqual.class

@@ -0,0 +1,30 @@
+/*discard items emitted by an Observable until a second Observable emits an item*/
+
+/*The SkipUntil subscribes to the source Observable, but ignores its emissions until
+such time as a second Observable emits an item, at which point SkipUntil begins to mirror the source Observable.*/
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class SkipUntil {
+    public static void main(String[] args) throws InterruptedException {
+        CountDownLatch latch = new CountDownLatch(1);
+
+        Observable first = Observable.interval(4, TimeUnit.SECONDS).take(1);
+
+        Observable second = Observable.interval(1, TimeUnit.SECONDS).take(7);
+
+        second.skipUntil(first).subscribe(o -> System.out.println(o),
+                throwable -> System.out.println("Error"),
+                () -> {
+                    System.out.println("Completed");
+                    latch.countDown();
+                }
+        );
+
+        latch.await();
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/SkipUntil.class

@@ -0,0 +1,28 @@
+/*discard items emitted by an Observable until a specified condition becomes false*/
+
+/*The SkipWhile subscribes to the source Observable, but ignores its emissions until
+such time as some condition you specify becomes false, at which point SkipWhile begins
+to mirror the source Observable.*/
+
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class SkipWhile {
+    public static void main(String[] args) throws InterruptedException {
+        CountDownLatch latch = new CountDownLatch(1);
+        Observable.interval(1, TimeUnit.SECONDS).skipWhile(i -> i < 5).take(7).subscribe(
+                aLong -> System.out.println(aLong),
+                throwable -> System.out.println("Error"),
+                () -> {
+                    System.out.println("Completed");
+                    latch.countDown();
+                }
+        );
+
+        latch.await();
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/SkipWhile.class

@@ -0,0 +1,33 @@
+/*discard any items emitted by an Observable after a second Observable emits an item or terminates*/
+
+/*The TakeUntil subscribes and begins mirroring the source Observable. It also monitors a second
+Observable that you provide. If this second Observable emits an item or sends a termination notification,
+the Observable returned by TakeUntil stops mirroring the source Observable and terminates.*/
+
+
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class TakeUntil {
+    public static void main(String[] args) throws InterruptedException {
+        CountDownLatch latch = new CountDownLatch(1);
+
+        Observable first = Observable.interval(4, TimeUnit.SECONDS).take(1);
+
+        Observable second = Observable.interval(1, TimeUnit.SECONDS).take(7);
+
+        second.takeUntil(first).subscribe(o -> System.out.println(o),
+                throwable -> System.out.println("Error"),
+                () -> {
+                    System.out.println("Completed");
+                    latch.countDown();
+                }
+        );
+
+        latch.await();
+    }
+}

out/production/classes/ConditionalAndBooleanOperators/TakeUntil.class

@@ -0,0 +1,23 @@
+package ConditionalAndBooleanOperators;
+
+import rx.Observable;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class TakeWhile {
+    public static void main(String[] args) throws InterruptedException {
+        CountDownLatch latch = new CountDownLatch(1);
+
+        Observable.interval(1, TimeUnit.SECONDS).takeWhile(i -> i < 5).take(7).subscribe(
+                aLong -> System.out.println(aLong),
+                throwable -> System.out.println("Error"),
+                () -> {
+                    System.out.println("Completed");
+                    latch.countDown();
+                }
+        );
+
+        latch.await();
+    }
+}