*/
public final class CompletableFromCompletionStage<T> extends Completable {

    final CompletionStage<T> stage;

    public CompletableFromCompletionStage(CompletionStage<T> stage) {
        this.stage = stage;
    }


            

Reported by PMD.

                  static final class CompletionStageHandler<T>
    implements Disposable, BiConsumer<T, Throwable> {

        final CompletableObserver downstream;

        final BiConsumerAtomicReference<T> whenReference;

        CompletionStageHandler(CompletableObserver downstream, BiConsumerAtomicReference<T> whenReference) {
            this.downstream = downstream;

            

Reported by PMD.

              
        final CompletableObserver downstream;

        final BiConsumerAtomicReference<T> whenReference;

        CompletionStageHandler(CompletableObserver downstream, BiConsumerAtomicReference<T> whenReference) {
            this.downstream = downstream;
            this.whenReference = whenReference;
        }

            

Reported by PMD.

              import java.util.concurrent.CompletionStage;
import java.util.function.BiConsumer;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.jdk8.FlowableFromCompletionStage.BiConsumerAtomicReference;

/**
 * Wrap a CompletionStage and signal its outcome.

            

Reported by PMD.

                  }

    static final class ToFlowableIterator<T> implements Iterator<Flowable<T>> {
        private final Iterator<? extends SingleSource<? extends T>> sit;

        ToFlowableIterator(Iterator<? extends SingleSource<? extends T>> sit) {
            this.sit = sit;
        }


            

Reported by PMD.

              
    static final class ToFlowableIterable<T> implements Iterable<Flowable<T>> {

        private final Iterable<? extends SingleSource<? extends T>> sources;

        ToFlowableIterable(Iterable<? extends SingleSource<? extends T>> sources) {
            this.sources = sources;
        }


            

Reported by PMD.

              
import org.reactivestreams.Publisher;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.functions.*;

/**
 * Helper utility class to support Single with inner classes.
 */

            

Reported by PMD.

              import org.reactivestreams.Publisher;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.functions.*;

/**
 * Helper utility class to support Single with inner classes.
 */
public final class SingleInternalHelper {

            

Reported by PMD.

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

    final SingleSource<? extends T> source;

    public SingleHide(SingleSource<? extends T> source) {
        this.source = source;
    }


            

Reported by PMD.

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

        final SingleObserver<? super T> downstream;

        Disposable upstream;

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

            

Reported by PMD.

              
        final SingleObserver<? super T> downstream;

        Disposable upstream;

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


            

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;

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


            

Reported by PMD.

              
public final class CompletableErrorSupplier extends Completable {

    final Supplier<? extends Throwable> errorSupplier;

    public CompletableErrorSupplier(Supplier<? extends Throwable> errorSupplier) {
        this.errorSupplier = errorSupplier;
    }


            

Reported by PMD.

              
        try {
            error = Objects.requireNonNull(errorSupplier.get(), "The error returned is null");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            error = e;
        }

        EmptyDisposable.error(error, observer);

            

Reported by PMD.

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

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.Exceptions;
import io.reactivex.rxjava3.functions.Supplier;
import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;

import java.util.Objects;

            

Reported by PMD.

                      Throwable error;

        try {
            error = Objects.requireNonNull(errorSupplier.get(), "The error returned is null");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            error = e;
        }


            

Reported by PMD.

               */
public final class ObservableDoAfterNext<T> extends AbstractObservableWithUpstream<T, T> {

    final Consumer<? super T> onAfterNext;

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

            

Reported by PMD.

              
    static final class DoAfterObserver<T> extends BasicFuseableObserver<T, T> {

        final Consumer<? super T> onAfterNext;

        DoAfterObserver(Observer<? 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.

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

import io.reactivex.rxjava3.annotations.Nullable;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.internal.observers.BasicFuseableObserver;

/**
 * Calls a consumer after pushing the current item to the downstream.

            

Reported by PMD.

              
public final class FlowableIgnoreElementsCompletable<T> extends Completable implements FuseToFlowable<T> {

    final Flowable<T> source;

    public FlowableIgnoreElementsCompletable(Flowable<T> source) {
        this.source = source;
    }


            

Reported by PMD.

                  }

    static final class IgnoreElementsSubscriber<T> implements FlowableSubscriber<T>, Disposable {
        final CompletableObserver downstream;

        Subscription upstream;

        IgnoreElementsSubscriber(CompletableObserver downstream) {
            this.downstream = downstream;

            

Reported by PMD.

                  static final class IgnoreElementsSubscriber<T> implements FlowableSubscriber<T>, Disposable {
        final CompletableObserver downstream;

        Subscription upstream;

        IgnoreElementsSubscriber(CompletableObserver downstream) {
            this.downstream = downstream;
        }


            

Reported by PMD.

              
import org.reactivestreams.Subscription;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.fuseable.FuseToFlowable;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;


            

Reported by PMD.

                  }

    static final class CountObserver implements Observer<Object>, Disposable {
        final Observer<? super Long> downstream;

        Disposable upstream;

        long count;


            

Reported by PMD.

                  static final class CountObserver implements Observer<Object>, Disposable {
        final Observer<? super Long> downstream;

        Disposable upstream;

        long count;

        CountObserver(Observer<? super Long> downstream) {
            this.downstream = downstream;

            

Reported by PMD.

              
        Disposable upstream;

        long count;

        CountObserver(Observer<? super Long> downstream) {
            this.downstream = downstream;
        }


            

Reported by PMD.

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

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

public final class ObservableCount<T> extends AbstractObservableWithUpstream<T, Long> {
    public ObservableCount(ObservableSource<T> source) {

            

Reported by PMD.

              
    private static final long serialVersionUID = -3830916580126663321L;
    /** The single value to emit, set to null. */
    final T value;
    /** The actual subscriber. */
    final Subscriber<? super T> subscriber;

    /** No request has been issued yet. */
    static final int NO_REQUEST = 0;

            

Reported by PMD.

                  /** The single value to emit, set to null. */
    final T value;
    /** The actual subscriber. */
    final Subscriber<? super T> subscriber;

    /** No request has been issued yet. */
    static final int NO_REQUEST = 0;
    /** Request has been called.*/
    static final int REQUESTED = 1;

            

Reported by PMD.

                      if (compareAndSet(NO_REQUEST, REQUESTED)) {
            Subscriber<? super T> s = subscriber;

            s.onNext(value);
            if (get() != CANCELLED) {
                s.onComplete();
            }
        }


            

Reported by PMD.

              
            s.onNext(value);
            if (get() != CANCELLED) {
                s.onComplete();
            }
        }

    }


            

Reported by PMD.

               */
public final class ObservableFromCallable<T> extends Observable<T> implements Supplier<T> {

    final Callable<? extends T> callable;

    public ObservableFromCallable(Callable<? extends T> callable) {
        this.callable = callable;
    }


            

Reported by PMD.

                      T value;
        try {
            value = ExceptionHelper.nullCheck(callable.call(), "Callable returned a null value.");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            if (!d.isDisposed()) {
                observer.onError(e);
            } else {
                RxJavaPlugins.onError(e);

            

Reported by PMD.

              
import java.util.concurrent.Callable;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.Exceptions;
import io.reactivex.rxjava3.functions.Supplier;
import io.reactivex.rxjava3.internal.observers.DeferredScalarDisposable;
import io.reactivex.rxjava3.internal.util.ExceptionHelper;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

            

Reported by PMD.

                      }
        T value;
        try {
            value = ExceptionHelper.nullCheck(callable.call(), "Callable returned a null value.");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            if (!d.isDisposed()) {
                observer.onError(e);
            } else {

            

Reported by PMD.

               */
public final class ObservableFromAction<T> extends Observable<T> implements Supplier<T> {

    final Action action;

    public ObservableFromAction(Action action) {
        this.action = action;
    }


            

Reported by PMD.

              
            try {
                action.run();
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (!qs.isDisposed()) {
                    observer.onError(ex);
                } else {
                    RxJavaPlugins.onError(ex);

            

Reported by PMD.

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

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.Exceptions;
import io.reactivex.rxjava3.functions.*;
import io.reactivex.rxjava3.internal.fuseable.CancellableQueueFuseable;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;


            

Reported by PMD.

              
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.Exceptions;
import io.reactivex.rxjava3.functions.*;
import io.reactivex.rxjava3.internal.fuseable.CancellableQueueFuseable;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

/**
 * Executes an {@link Action} and signals its exception or completes normally.

            

Reported by PMD.