Unify Observable/Single implementations

trello-archive · May 5, 2016 · be808eb · be808eb
1 parent 2544929
commit be808eb
Show file tree

Hide file tree

Showing 5 changed files with 74 additions and 86 deletions.
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/TakeUntilGenerator.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/TakeUntilGenerator.java
@@ -0,0 +1,62 @@
+package com.trello.rxlifecycle;
+
+import android.support.annotation.CheckResult;
+import android.support.annotation.NonNull;
+import rx.Observable;
+import rx.exceptions.Exceptions;
+import rx.functions.Func1;
+import rx.functions.Func2;
+
+final class TakeUntilGenerator {
+
+    @NonNull
+    @CheckResult
+    static <T> Observable<T> takeUntilEvent(@NonNull final Observable<T> lifecycle, @NonNull final T event) {
+        return lifecycle.takeFirst(new Func1<T, Boolean>() {
+            @Override
+            public Boolean call(T lifecycleEvent) {
+                return lifecycleEvent.equals(event);
+            }
+        });
+    }
+
+    @NonNull
+    @CheckResult
+    static <T> Observable<Boolean> takeUntilCorrespondingEvent(@NonNull final Observable<T> lifecycle,
+                                                               @NonNull final Func1<T, T> correspondingEvents) {
+        return Observable.combineLatest(
+            lifecycle.take(1).map(correspondingEvents),
+            lifecycle.skip(1),
+            new Func2<T, T, Boolean>() {
+                @Override
+                public Boolean call(T bindUntilEvent, T lifecycleEvent) {
+                    return lifecycleEvent.equals(bindUntilEvent);
+                }
+            })
+            .onErrorReturn(RESUME_FUNCTION)
+            .takeFirst(SHOULD_COMPLETE);
+    }
+
+    private static final Func1<Throwable, Boolean> RESUME_FUNCTION = new Func1<Throwable, Boolean>() {
+        @Override
+        public Boolean call(Throwable throwable) {
+            if (throwable instanceof OutsideLifecycleException) {
+                return true;
+            }
+
+            Exceptions.propagate(throwable);
+            return false;
+        }
+    };
+
+    private static final Func1<Boolean, Boolean> SHOULD_COMPLETE = new Func1<Boolean, Boolean>() {
+        @Override
+        public Boolean call(Boolean shouldComplete) {
+            return shouldComplete;
+        }
+    };
+
+    private TakeUntilGenerator() {
+        throw new AssertionError("No instances!");
+    }
+}
diff --git a/...le/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventObservableTransformer.java b/...le/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventObservableTransformer.java
@@ -1,9 +1,9 @@
 package com.trello.rxlifecycle;
 
 import rx.Observable;
-import rx.exceptions.Exceptions;
 import rx.functions.Func1;
-import rx.functions.Func2;
+
+import static com.trello.rxlifecycle.TakeUntilGenerator.takeUntilCorrespondingEvent;
 
 /**
  * Continues a subscription until it sees a particular lifecycle event.
@@ -23,37 +23,6 @@ public UntilCorrespondingEventObservableTransformer(Observable<R> lifecycle, Fun
 
     @Override
     public Observable<T> call(Observable<T> source) {
-        return source.takeUntil(
-            Observable.combineLatest(
-                this.sharedLifecycle.take(1).map(correspondingEvents),
-                this.sharedLifecycle.skip(1),
-                new Func2<R, R, Boolean>() {
-                    @Override
-                    public Boolean call(R bindUntilEvent, R lifecycleEvent) {
-                        return lifecycleEvent.equals(bindUntilEvent);
-                    }
-                })
-                .onErrorReturn(RESUME_FUNCTION)
-                .takeFirst(SHOULD_COMPLETE)
-        );
+        return source.takeUntil(takeUntilCorrespondingEvent(sharedLifecycle, correspondingEvents));
     }
-
-    private static final Func1<Throwable, Boolean> RESUME_FUNCTION = new Func1<Throwable, Boolean>() {
-        @Override
-        public Boolean call(Throwable throwable) {
-            if (throwable instanceof OutsideLifecycleException) {
-                return true;
-            }
-
-            Exceptions.propagate(throwable);
-            return false;
-        }
-    };
-
-    private static final Func1<Boolean, Boolean> SHOULD_COMPLETE = new Func1<Boolean, Boolean>() {
-        @Override
-        public Boolean call(Boolean shouldComplete) {
-            return shouldComplete;
-        }
-    };
 }
diff --git a/...ecycle/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventSingleTransformer.java b/...ecycle/src/main/java/com/trello/rxlifecycle/UntilCorrespondingEventSingleTransformer.java
@@ -2,9 +2,9 @@
 
 import rx.Observable;
 import rx.Single;
-import rx.exceptions.Exceptions;
 import rx.functions.Func1;
-import rx.functions.Func2;
+
+import static com.trello.rxlifecycle.TakeUntilGenerator.takeUntilCorrespondingEvent;
 
 /**
  * Continues a subscription until it sees a particular lifecycle event.
@@ -24,37 +24,6 @@ public UntilCorrespondingEventSingleTransformer(Observable<R> lifecycle, Func1<R
 
     @Override
     public Single<T> call(Single<T> source) {
-        return source.takeUntil(
-            Observable.combineLatest(
-                this.sharedLifecycle.take(1).map(correspondingEvents),
-                this.sharedLifecycle.skip(1),
-                new Func2<R, R, Boolean>() {
-                    @Override
-                    public Boolean call(R bindUntilEvent, R lifecycleEvent) {
-                        return lifecycleEvent.equals(bindUntilEvent);
-                    }
-                })
-                .onErrorReturn(RESUME_FUNCTION)
-                .takeFirst(SHOULD_COMPLETE)
-        );
+        return source.takeUntil(takeUntilCorrespondingEvent(sharedLifecycle, correspondingEvents));
     }
-
-    private static final Func1<Throwable, Boolean> RESUME_FUNCTION = new Func1<Throwable, Boolean>() {
-        @Override
-        public Boolean call(Throwable throwable) {
-            if (throwable instanceof OutsideLifecycleException) {
-                return true;
-            }
-
-            Exceptions.propagate(throwable);
-            return false;
-        }
-    };
-
-    private static final Func1<Boolean, Boolean> SHOULD_COMPLETE = new Func1<Boolean, Boolean>() {
-        @Override
-        public Boolean call(Boolean shouldComplete) {
-            return shouldComplete;
-        }
-    };
 }
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventObservableTransformer.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventObservableTransformer.java
@@ -1,7 +1,8 @@
 package com.trello.rxlifecycle;
 
 import rx.Observable;
-import rx.functions.Func1;
+
+import static com.trello.rxlifecycle.TakeUntilGenerator.takeUntilEvent;
 
 /**
  * Continues a subscription until it sees a particular lifecycle event.
@@ -18,13 +19,6 @@ public UntilEventObservableTransformer(Observable<R> lifecycle, R event) {
 
     @Override
     public Observable<T> call(Observable<T> source) {
-        return source.takeUntil(
-            lifecycle.takeFirst(new Func1<R, Boolean>() {
-                @Override
-                public Boolean call(R lifecycleEvent) {
-                    return lifecycleEvent.equals(event);
-                }
-            })
-        );
+        return source.takeUntil(takeUntilEvent(lifecycle, event));
     }
 }
diff --git a/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventSingleTransformer.java b/rxlifecycle/src/main/java/com/trello/rxlifecycle/UntilEventSingleTransformer.java
@@ -2,7 +2,8 @@
 
 import rx.Observable;
 import rx.Single;
-import rx.functions.Func1;
+
+import static com.trello.rxlifecycle.TakeUntilGenerator.takeUntilEvent;
 
 /**
  * Continues a subscription until it sees a particular lifecycle event.
@@ -19,13 +20,6 @@ public UntilEventSingleTransformer(Observable<R> lifecycle, R event) {
 
     @Override
     public Single<T> call(Single<T> source) {
-        return source.takeUntil(
-            lifecycle.takeFirst(new Func1<R, Boolean>() {
-                @Override
-                public Boolean call(R lifecycleEvent) {
-                    return lifecycleEvent.equals(event);
-                }
-            })
-        );
+        return source.takeUntil(takeUntilEvent(lifecycle, event));
     }
 }