in autodispose/src/main/java/autodispose2/AutoDispose.java [102:405]
public static <@NonNull T> AutoDisposeConverter<T> autoDisposable(final CompletableSource scope) {
checkNotNull(scope, "scope == null");
return new AutoDisposeConverter<T>() {
@Override
public ParallelFlowableSubscribeProxy<T> apply(final ParallelFlowable<T> upstream) {
if (!AutoDisposePlugins.hideProxies) {
return new AutoDisposeParallelFlowable<>(upstream, scope);
}
return subscribers ->
new AutoDisposeParallelFlowable<>(upstream, scope).subscribe(subscribers);
}
@Override
public CompletableSubscribeProxy apply(final Completable upstream) {
if (!AutoDisposePlugins.hideProxies) {
return new AutoDisposeCompletable(upstream, scope);
}
return new CompletableSubscribeProxy() {
@Override
public Disposable subscribe() {
return new AutoDisposeCompletable(upstream, scope).subscribe();
}
@Override
public Disposable subscribe(Action action) {
return new AutoDisposeCompletable(upstream, scope).subscribe(action);
}
@Override
public Disposable subscribe(Action action, Consumer<? super Throwable> onError) {
return new AutoDisposeCompletable(upstream, scope).subscribe(action, onError);
}
@Override
public void subscribe(CompletableObserver observer) {
new AutoDisposeCompletable(upstream, scope).subscribe(observer);
}
@Override
public <@NonNull E extends CompletableObserver> E subscribeWith(E observer) {
return new AutoDisposeCompletable(upstream, scope).subscribeWith(observer);
}
@Override
public TestObserver<Void> test() {
TestObserver<Void> observer = new TestObserver<>();
subscribe(observer);
return observer;
}
@Override
public TestObserver<Void> test(boolean dispose) {
TestObserver<Void> observer = new TestObserver<>();
if (dispose) {
observer.dispose();
}
subscribe(observer);
return observer;
}
};
}
@Override
public FlowableSubscribeProxy<T> apply(final Flowable<T> upstream) {
if (!AutoDisposePlugins.hideProxies) {
return new AutoDisposeFlowable<>(upstream, scope);
}
return new FlowableSubscribeProxy<T>() {
@Override
public Disposable subscribe() {
return new AutoDisposeFlowable<>(upstream, scope).subscribe();
}
@Override
public Disposable subscribe(Consumer<? super T> onNext) {
return new AutoDisposeFlowable<>(upstream, scope).subscribe(onNext);
}
@Override
public Disposable subscribe(
Consumer<? super T> onNext, Consumer<? super Throwable> onError) {
return new AutoDisposeFlowable<>(upstream, scope).subscribe(onNext, onError);
}
@Override
public Disposable subscribe(
Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {
return new AutoDisposeFlowable<>(upstream, scope)
.subscribe(onNext, onError, onComplete);
}
@Override
public void subscribe(Subscriber<? super T> observer) {
new AutoDisposeFlowable<>(upstream, scope).subscribe(observer);
}
@Override
public <@NonNull E extends Subscriber<? super T>> E subscribeWith(E observer) {
return new AutoDisposeFlowable<>(upstream, scope).subscribeWith(observer);
}
@Override
public TestSubscriber<T> test() {
TestSubscriber<T> ts = new TestSubscriber<>();
subscribe(ts);
return ts;
}
@Override
public TestSubscriber<T> test(long initialRequest) {
TestSubscriber<T> ts = new TestSubscriber<>(initialRequest);
subscribe(ts);
return ts;
}
@Override
public TestSubscriber<T> test(long initialRequest, boolean cancel) {
TestSubscriber<T> ts = new TestSubscriber<>(initialRequest);
if (cancel) {
ts.cancel();
}
subscribe(ts);
return ts;
}
};
}
@Override
public MaybeSubscribeProxy<T> apply(final Maybe<T> upstream) {
if (!AutoDisposePlugins.hideProxies) {
return new AutoDisposeMaybe<>(upstream, scope);
}
return new MaybeSubscribeProxy<T>() {
@Override
public Disposable subscribe() {
return new AutoDisposeMaybe<>(upstream, scope).subscribe();
}
@Override
public Disposable subscribe(Consumer<? super T> onSuccess) {
return new AutoDisposeMaybe<>(upstream, scope).subscribe(onSuccess);
}
@Override
public Disposable subscribe(
Consumer<? super T> onSuccess, Consumer<? super Throwable> onError) {
return new AutoDisposeMaybe<>(upstream, scope).subscribe(onSuccess, onError);
}
@Override
public Disposable subscribe(
Consumer<? super T> onSuccess,
Consumer<? super Throwable> onError,
Action onComplete) {
return new AutoDisposeMaybe<>(upstream, scope)
.subscribe(onSuccess, onError, onComplete);
}
@Override
public void subscribe(MaybeObserver<? super T> observer) {
new AutoDisposeMaybe<>(upstream, scope).subscribe(observer);
}
@Override
public <@NonNull E extends MaybeObserver<? super T>> E subscribeWith(E observer) {
return new AutoDisposeMaybe<>(upstream, scope).subscribeWith(observer);
}
@Override
public TestObserver<T> test() {
TestObserver<T> observer = new TestObserver<>();
subscribe(observer);
return observer;
}
@Override
public TestObserver<T> test(boolean dispose) {
TestObserver<T> observer = new TestObserver<>();
if (dispose) {
observer.dispose();
}
subscribe(observer);
return observer;
}
};
}
@Override
public ObservableSubscribeProxy<T> apply(final Observable<T> upstream) {
if (!AutoDisposePlugins.hideProxies) {
return new AutoDisposeObservable<>(upstream, scope);
}
return new ObservableSubscribeProxy<T>() {
@Override
public Disposable subscribe() {
return new AutoDisposeObservable<>(upstream, scope).subscribe();
}
@Override
public Disposable subscribe(Consumer<? super T> onNext) {
return new AutoDisposeObservable<>(upstream, scope).subscribe(onNext);
}
@Override
public Disposable subscribe(
Consumer<? super T> onNext, Consumer<? super Throwable> onError) {
return new AutoDisposeObservable<>(upstream, scope).subscribe(onNext, onError);
}
@Override
public Disposable subscribe(
Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {
return new AutoDisposeObservable<>(upstream, scope)
.subscribe(onNext, onError, onComplete);
}
@Override
public void subscribe(Observer<? super T> observer) {
new AutoDisposeObservable<>(upstream, scope).subscribe(observer);
}
@Override
public <@NonNull E extends Observer<? super T>> E subscribeWith(E observer) {
return new AutoDisposeObservable<>(upstream, scope).subscribeWith(observer);
}
@Override
public TestObserver<T> test() {
TestObserver<T> observer = new TestObserver<>();
subscribe(observer);
return observer;
}
@Override
public TestObserver<T> test(boolean dispose) {
TestObserver<T> observer = new TestObserver<>();
if (dispose) {
observer.dispose();
}
subscribe(observer);
return observer;
}
};
}
@Override
public SingleSubscribeProxy<T> apply(final Single<T> upstream) {
if (!AutoDisposePlugins.hideProxies) {
return new AutoDisposeSingle<>(upstream, scope);
}
return new SingleSubscribeProxy<T>() {
@Override
public Disposable subscribe() {
return new AutoDisposeSingle<>(upstream, scope).subscribe();
}
@Override
public Disposable subscribe(Consumer<? super T> onSuccess) {
return new AutoDisposeSingle<>(upstream, scope).subscribe(onSuccess);
}
@SuppressWarnings("NullAway") // False positive
@Override
public Disposable subscribe(
BiConsumer<@Nullable ? super T, @Nullable ? super Throwable> biConsumer) {
return new AutoDisposeSingle<>(upstream, scope).subscribe(biConsumer);
}
@Override
public Disposable subscribe(
Consumer<? super T> onSuccess, Consumer<? super Throwable> onError) {
return new AutoDisposeSingle<>(upstream, scope).subscribe(onSuccess, onError);
}
@Override
public void subscribe(SingleObserver<? super T> observer) {
new AutoDisposeSingle<>(upstream, scope).subscribe(observer);
}
@Override
public <@NonNull E extends SingleObserver<? super T>> E subscribeWith(E observer) {
return new AutoDisposeSingle<>(upstream, scope).subscribeWith(observer);
}
@Override
public TestObserver<T> test() {
TestObserver<T> observer = new TestObserver<>();
subscribe(observer);
return observer;
}
@Override
public TestObserver<T> test(boolean dispose) {
TestObserver<T> observer = new TestObserver<>();
if (dispose) {
observer.dispose();
}
subscribe(observer);
return observer;
}
};
}
};
}