public abstract class BlockingBaseSubscriber<T> extends CountDownLatch
implements FlowableSubscriber<T> {

    T value;
    Throwable error;

    Subscription upstream;

    volatile boolean cancelled;

            

Reported by PMD.

              implements FlowableSubscriber<T> {

    T value;
    Throwable error;

    Subscription upstream;

    volatile boolean cancelled;


            

Reported by PMD.

                  T value;
    Throwable error;

    Subscription upstream;

    volatile boolean cancelled;

    public BlockingBaseSubscriber() {
        super(1);

            

Reported by PMD.

              
    Subscription upstream;

    volatile boolean cancelled;

    public BlockingBaseSubscriber() {
        super(1);
    }


            

Reported by PMD.

                          this.upstream = s;
            if (!cancelled) {
                s.request(Long.MAX_VALUE);
                if (cancelled) {
                    this.upstream = SubscriptionHelper.CANCELLED;
                    s.cancel();
                }
            }
        }

            

Reported by PMD.

                              Subscription s = this.upstream;
                this.upstream = SubscriptionHelper.CANCELLED;
                if (s != null) {
                    s.cancel();
                }
                throw ExceptionHelper.wrapOrThrow(ex);
            }
        }


            

Reported by PMD.

              
import io.reactivex.rxjava3.core.FlowableSubscriber;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
import io.reactivex.rxjava3.internal.util.*;

public abstract class BlockingBaseSubscriber<T> extends CountDownLatch
implements FlowableSubscriber<T> {

    T value;

            

Reported by PMD.

               */
public final class FlowableDoAfterNext<T> extends AbstractFlowableWithUpstream<T, T> {

    final Consumer<? super T> onAfterNext;

    public FlowableDoAfterNext(Flowable<T> source, Consumer<? super T> onAfterNext) {
        super(source);
        this.onAfterNext = onAfterNext;
    }

            

Reported by PMD.

              
    static final class DoAfterSubscriber<T> extends BasicFuseableSubscriber<T, T> {

        final Consumer<? super T> onAfterNext;

        DoAfterSubscriber(Subscriber<? super T> actual, Consumer<? super T> onAfterNext) {
            super(actual);
            this.onAfterNext = onAfterNext;
        }

            

Reported by PMD.

                          if (sourceMode == NONE) {
                try {
                    onAfterNext.accept(t);
                } catch (Throwable ex) {
                    fail(ex);
                }
            }
        }


            

Reported by PMD.

              
    static final class DoAfterConditionalSubscriber<T> extends BasicFuseableConditionalSubscriber<T, T> {

        final Consumer<? super T> onAfterNext;

        DoAfterConditionalSubscriber(ConditionalSubscriber<? super T> actual, Consumer<? super T> onAfterNext) {
            super(actual);
            this.onAfterNext = onAfterNext;
        }

            

Reported by PMD.

                          if (sourceMode == NONE) {
                try {
                    onAfterNext.accept(t);
                } catch (Throwable ex) {
                    fail(ex);
                }
            }
        }


            

Reported by PMD.

                          boolean b = downstream.tryOnNext(t);
            try {
                onAfterNext.accept(t);
            } catch (Throwable ex) {
                fail(ex);
            }
            return b;
        }


            

Reported by PMD.

              import io.reactivex.rxjava3.core.Flowable;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.internal.fuseable.ConditionalSubscriber;
import io.reactivex.rxjava3.internal.subscribers.*;

/**
 * Calls a consumer after pushing the current item to the downstream.
 * <p>History: 2.0.1 - experimental
 * @param <T> the value type

            

Reported by PMD.

                      }

        @Override
        public void onError(Throwable e) {
            try {
                onError.accept(e);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                e = new CompositeException(e, ex);

            

Reported by PMD.

              
public final class SingleDoOnError<T> extends Single<T> {

    final SingleSource<T> source;

    final Consumer<? super Throwable> onError;

    public SingleDoOnError(SingleSource<T> source, Consumer<? super Throwable> onError) {
        this.source = source;

            

Reported by PMD.

              
    final SingleSource<T> source;

    final Consumer<? super Throwable> onError;

    public SingleDoOnError(SingleSource<T> source, Consumer<? super Throwable> onError) {
        this.source = source;
        this.onError = onError;
    }

            

Reported by PMD.

                  }

    final class DoOnError implements SingleObserver<T> {
        private final SingleObserver<? super T> downstream;

        DoOnError(SingleObserver<? super T> observer) {
            this.downstream = observer;
        }


            

Reported by PMD.

                      public void onError(Throwable e) {
            try {
                onError.accept(e);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                e = new CompositeException(e, ex);
            }
            downstream.onError(e);
        }

            

Reported by PMD.

              
package io.reactivex.rxjava3.internal.operators.single;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Consumer;

public final class SingleDoOnError<T> extends Single<T> {

            

Reported by PMD.

              
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Consumer;

public final class SingleDoOnError<T> extends Single<T> {

    final SingleSource<T> source;

            

Reported by PMD.

               */
public final class SingleDoFinally<T> extends Single<T> {

    final SingleSource<T> source;

    final Action onFinally;

    public SingleDoFinally(SingleSource<T> source, Action onFinally) {
        this.source = source;

            

Reported by PMD.

              
    final SingleSource<T> source;

    final Action onFinally;

    public SingleDoFinally(SingleSource<T> source, Action onFinally) {
        this.source = source;
        this.onFinally = onFinally;
    }

            

Reported by PMD.

              
        private static final long serialVersionUID = 4109457741734051389L;

        final SingleObserver<? super T> downstream;

        final Action onFinally;

        Disposable upstream;


            

Reported by PMD.

              
        final SingleObserver<? super T> downstream;

        final Action onFinally;

        Disposable upstream;

        DoFinallyObserver(SingleObserver<? super T> actual, Action onFinally) {
            this.downstream = actual;

            

Reported by PMD.

              
        final Action onFinally;

        Disposable upstream;

        DoFinallyObserver(SingleObserver<? super T> actual, Action onFinally) {
            this.downstream = actual;
            this.onFinally = onFinally;
        }

            

Reported by PMD.

                          if (compareAndSet(0, 1)) {
                try {
                    onFinally.run();
                } catch (Throwable ex) {
                    Exceptions.throwIfFatal(ex);
                    RxJavaPlugins.onError(ex);
                }
            }
        }

            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicInteger;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.exceptions.Exceptions;
import io.reactivex.rxjava3.functions.Action;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

            

Reported by PMD.

               */
public final class SingleDoAfterSuccess<T> extends Single<T> {

    final SingleSource<T> source;

    final Consumer<? super T> onAfterSuccess;

    public SingleDoAfterSuccess(SingleSource<T> source, Consumer<? super T> onAfterSuccess) {
        this.source = source;

            

Reported by PMD.

              
    final SingleSource<T> source;

    final Consumer<? super T> onAfterSuccess;

    public SingleDoAfterSuccess(SingleSource<T> source, Consumer<? super T> onAfterSuccess) {
        this.source = source;
        this.onAfterSuccess = onAfterSuccess;
    }

            

Reported by PMD.

              
    static final class DoAfterObserver<T> implements SingleObserver<T>, Disposable {

        final SingleObserver<? super T> downstream;

        final Consumer<? super T> onAfterSuccess;

        Disposable upstream;


            

Reported by PMD.

              
        final SingleObserver<? super T> downstream;

        final Consumer<? super T> onAfterSuccess;

        Disposable upstream;

        DoAfterObserver(SingleObserver<? super T> actual, Consumer<? super T> onAfterSuccess) {
            this.downstream = actual;

            

Reported by PMD.

              
        final Consumer<? super T> onAfterSuccess;

        Disposable upstream;

        DoAfterObserver(SingleObserver<? super T> actual, Consumer<? super T> onAfterSuccess) {
            this.downstream = actual;
            this.onAfterSuccess = onAfterSuccess;
        }

            

Reported by PMD.

              
            try {
                onAfterSuccess.accept(t);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
             // remember, onSuccess is a terminal event and we can't call onError
                RxJavaPlugins.onError(ex);
            }
        }

            

Reported by PMD.

              
package io.reactivex.rxjava3.internal.operators.single;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.exceptions.Exceptions;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

            

Reported by PMD.

               */
public final class SingleDetach<T> extends Single<T> {

    final SingleSource<T> source;

    public SingleDetach(SingleSource<T> source) {
        this.source = source;
    }


            

Reported by PMD.

              
    static final class DetachSingleObserver<T> implements SingleObserver<T>, Disposable {

        SingleObserver<? super T> downstream;

        Disposable upstream;

        DetachSingleObserver(SingleObserver<? super T> downstream) {
            this.downstream = downstream;

            

Reported by PMD.

              
        SingleObserver<? super T> downstream;

        Disposable upstream;

        DetachSingleObserver(SingleObserver<? super T> downstream) {
            this.downstream = downstream;
        }


            

Reported by PMD.

              
        @Override
        public void dispose() {
            downstream = null;
            upstream.dispose();
            upstream = DisposableHelper.DISPOSED;
        }

        @Override

            

Reported by PMD.

                          upstream = DisposableHelper.DISPOSED;
            SingleObserver<? super T> a = downstream;
            if (a != null) {
                downstream = null;
                a.onSuccess(value);
            }
        }

        @Override

            

Reported by PMD.

                          upstream = DisposableHelper.DISPOSED;
            SingleObserver<? super T> a = downstream;
            if (a != null) {
                downstream = null;
                a.onError(e);
            }
        }
    }
}

            

Reported by PMD.

              
package io.reactivex.rxjava3.internal.operators.single;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;

/**
 * Breaks the references between the upstream and downstream when the Maybe terminates.

            

Reported by PMD.

               */
public final class SafeMaybeObserver<T> implements MaybeObserver<T> {

    final MaybeObserver<? super T> downstream;

    boolean onSubscribeFailed;

    public SafeMaybeObserver(MaybeObserver<? super T> downstream) {
        this.downstream = downstream;

            

Reported by PMD.

              
    final MaybeObserver<? super T> downstream;

    boolean onSubscribeFailed;

    public SafeMaybeObserver(MaybeObserver<? super T> downstream) {
        this.downstream = downstream;
    }


            

Reported by PMD.

                  public void onSubscribe(@NonNull Disposable d) {
        try {
            downstream.onSubscribe(d);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            onSubscribeFailed = true;
            d.dispose();
            RxJavaPlugins.onError(ex);
        }

            

Reported by PMD.

                      if (!onSubscribeFailed) {
            try {
                downstream.onSuccess(t);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                RxJavaPlugins.onError(ex);
            }
        }
    }

            

Reported by PMD.

                      } else {
            try {
                downstream.onError(e);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                RxJavaPlugins.onError(new CompositeException(e, ex));
            }
        }
    }

            

Reported by PMD.

                      if (!onSubscribeFailed) {
            try {
                downstream.onComplete();
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                RxJavaPlugins.onError(ex);
            }
        }
    }

            

Reported by PMD.

              import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.MaybeObserver;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

/**
 * Wraps another {@link MaybeObserver} and catches exceptions thrown by its
 * {@code onSubscribe}, {@code onSuccess}, {@code onError} or

            

Reported by PMD.

              
public final class SingleDelayWithObservable<T, U> extends Single<T> {

    final SingleSource<T> source;

    final ObservableSource<U> other;

    public SingleDelayWithObservable(SingleSource<T> source, ObservableSource<U> other) {
        this.source = source;

            

Reported by PMD.

              
    final SingleSource<T> source;

    final ObservableSource<U> other;

    public SingleDelayWithObservable(SingleSource<T> source, ObservableSource<U> other) {
        this.source = source;
        this.other = other;
    }

            

Reported by PMD.

              
        private static final long serialVersionUID = -8565274649390031272L;

        final SingleObserver<? super T> downstream;

        final SingleSource<T> source;

        boolean done;


            

Reported by PMD.

              
        final SingleObserver<? super T> downstream;

        final SingleSource<T> source;

        boolean done;

        OtherSubscriber(SingleObserver<? super T> actual, SingleSource<T> source) {
            this.downstream = actual;

            

Reported by PMD.

              
        final SingleSource<T> source;

        boolean done;

        OtherSubscriber(SingleObserver<? super T> actual, SingleSource<T> source) {
            this.downstream = actual;
            this.source = source;
        }

            

Reported by PMD.

              
        @Override
        public void onNext(U value) {
            get().dispose();
            onComplete();
        }

        @Override
        public void onError(Throwable e) {

            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicReference;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
import io.reactivex.rxjava3.internal.observers.ResumeSingleObserver;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;


            

Reported by PMD.

               */
public final class MaybeSubscribeOn<T> extends AbstractMaybeWithUpstream<T, T> {

    final Scheduler scheduler;

    public MaybeSubscribeOn(MaybeSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }

            

Reported by PMD.

                  }

    static final class SubscribeTask<T> implements Runnable {
        final MaybeObserver<? super T> observer;
        final MaybeSource<T> source;

        SubscribeTask(MaybeObserver<? super T> observer, MaybeSource<T> source) {
            this.observer = observer;
            this.source = source;

            

Reported by PMD.

              
    static final class SubscribeTask<T> implements Runnable {
        final MaybeObserver<? super T> observer;
        final MaybeSource<T> source;

        SubscribeTask(MaybeObserver<? super T> observer, MaybeSource<T> source) {
            this.observer = observer;
            this.source = source;
        }

            

Reported by PMD.

                  extends AtomicReference<Disposable>
    implements MaybeObserver<T>, Disposable {

        final SequentialDisposable task;

        private static final long serialVersionUID = 8571289934935992137L;

        final MaybeObserver<? super T> downstream;


            

Reported by PMD.

              
        private static final long serialVersionUID = 8571289934935992137L;

        final MaybeObserver<? super T> downstream;

        SubscribeOnMaybeObserver(MaybeObserver<? super T> downstream) {
            this.downstream = downstream;
            this.task = new SequentialDisposable();
        }

            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicReference;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.*;
/**
 * Subscribes to the upstream MaybeSource on the specified scheduler.
 *

            

Reported by PMD.

              
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.*;
/**
 * Subscribes to the upstream MaybeSource on the specified scheduler.
 *
 * @param <T> the value type delivered
 */

            

Reported by PMD.

               */
public final class MaybeSwitchIfEmpty<T> extends AbstractMaybeWithUpstream<T, T> {

    final MaybeSource<? extends T> other;

    public MaybeSwitchIfEmpty(MaybeSource<T> source, MaybeSource<? extends T> other) {
        super(source);
        this.other = other;
    }

            

Reported by PMD.

              
        private static final long serialVersionUID = -2223459372976438024L;

        final MaybeObserver<? super T> downstream;

        final MaybeSource<? extends T> other;

        SwitchIfEmptyMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> other) {
            this.downstream = actual;

            

Reported by PMD.

              
        final MaybeObserver<? super T> downstream;

        final MaybeSource<? extends T> other;

        SwitchIfEmptyMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> other) {
            this.downstream = actual;
            this.other = other;
        }

            

Reported by PMD.

                      public void onComplete() {
            Disposable d = get();
            if (d != DisposableHelper.DISPOSED) {
                if (compareAndSet(d, null)) {
                    other.subscribe(new OtherMaybeObserver<T>(downstream, this));
                }
            }
        }


            

Reported by PMD.

              
        static final class OtherMaybeObserver<T> implements MaybeObserver<T> {

            final MaybeObserver<? super T> downstream;

            final AtomicReference<Disposable> parent;
            OtherMaybeObserver(MaybeObserver<? super T> actual, AtomicReference<Disposable> parent) {
                this.downstream = actual;
                this.parent = parent;

            

Reported by PMD.

              
            final MaybeObserver<? super T> downstream;

            final AtomicReference<Disposable> parent;
            OtherMaybeObserver(MaybeObserver<? super T> actual, AtomicReference<Disposable> parent) {
                this.downstream = actual;
                this.parent = parent;
            }


            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicReference;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;

/**
 * Subscribes to the other source if the main source is empty.

            

Reported by PMD.