private static final long serialVersionUID = -8612022020200669122L;

    final Subscriber<? super T> downstream;

    final AtomicReference<Subscription> upstream = new AtomicReference<>();

    public SubscriberResourceWrapper(Subscriber<? super T> downstream) {
        this.downstream = downstream;

            

Reported by PMD.

              
    final Subscriber<? super T> downstream;

    final AtomicReference<Subscription> upstream = new AtomicReference<>();

    public SubscriberResourceWrapper(Subscriber<? super T> downstream) {
        this.downstream = downstream;
    }


            

Reported by PMD.

                  @Override
    public void request(long n) {
        if (SubscriptionHelper.validate(n)) {
            upstream.get().request(n);
        }
    }

    @Override
    public void dispose() {

            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicReference;

import org.reactivestreams.*;

import io.reactivex.rxjava3.core.FlowableSubscriber;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;

            

Reported by PMD.

              public final class CompletionStageConsumer<T> extends CompletableFuture<T>
implements MaybeObserver<T>, SingleObserver<T>, CompletableObserver {

    final AtomicReference<Disposable> upstream;

    final boolean hasDefault;

    final T defaultItem;


            

Reported by PMD.

              
    final AtomicReference<Disposable> upstream;

    final boolean hasDefault;

    final T defaultItem;

    public CompletionStageConsumer(boolean hasDefault, T defaultItem) {
        this.hasDefault = hasDefault;

            

Reported by PMD.

              
    final boolean hasDefault;

    final T defaultItem;

    public CompletionStageConsumer(boolean hasDefault, T defaultItem) {
        this.hasDefault = hasDefault;
        this.defaultItem = defaultItem;
        this.upstream = new AtomicReference<>();

            

Reported by PMD.

              import java.util.concurrent.atomic.AtomicReference;

import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.DisposableHelper;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

/**

            

Reported by PMD.

              @State(Scope.Thread)
public class BlockingPerf {
    @Param({ "1", "1000", "1000000" })
    public int times;

    Flowable<Integer> flowable;

    Observable<Integer> observable;


            

Reported by PMD.

                  @Param({ "1", "1000", "1000000" })
    public int times;

    Flowable<Integer> flowable;

    Observable<Integer> observable;

    @Setup
    public void setup() {

            

Reported by PMD.

              
    Flowable<Integer> flowable;

    Observable<Integer> observable;

    @Setup
    public void setup() {
        Integer[] array = new Integer[times];
        Arrays.fill(array, 777);

            

Reported by PMD.

              import java.util.Arrays;
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.*;

@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 5)
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS)
@OutputTimeUnit(TimeUnit.SECONDS)

            

Reported by PMD.

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

    final CompletionStage<T> stage;

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


            

Reported by PMD.

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

        final SingleObserver<? super T> downstream;

        final BiConsumerAtomicReference<T> whenReference;

        CompletionStageHandler(SingleObserver<? super T> downstream, BiConsumerAtomicReference<T> whenReference) {
            this.downstream = downstream;

            

Reported by PMD.

              
        final SingleObserver<? super T> downstream;

        final BiConsumerAtomicReference<T> whenReference;

        CompletionStageHandler(SingleObserver<? super T> 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.

              implements SingleObserver<T>, Disposable {

    private static final long serialVersionUID = 4943102778943297569L;
    final BiConsumer<? super T, ? super Throwable> onCallback;

    public BiConsumerSingleObserver(BiConsumer<? super T, ? super Throwable> onCallback) {
        this.onCallback = onCallback;
    }


            

Reported by PMD.

                      try {
            lazySet(DisposableHelper.DISPOSED);
            onCallback.accept(null, e);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            RxJavaPlugins.onError(new CompositeException(e, ex));
        }
    }


            

Reported by PMD.

                      try {
            lazySet(DisposableHelper.DISPOSED);
            onCallback.accept(value, null);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            RxJavaPlugins.onError(ex);
        }
    }


            

Reported by PMD.

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

public final class BiConsumerSingleObserver<T>

            

Reported by PMD.

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

    final MaybeOperator<? extends R, ? super T> operator;

    public MaybeLift(MaybeSource<T> source, MaybeOperator<? extends R, ? super T> operator) {
        super(source);
        this.operator = operator;
    }

            

Reported by PMD.

              
        try {
            lifted = Objects.requireNonNull(operator.apply(observer), "The operator returned a null MaybeObserver");
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            EmptyDisposable.error(ex, observer);
            return;
        }


            

Reported by PMD.

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

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

import java.util.Objects;


            

Reported by PMD.

                      MaybeObserver<? super T> lifted;

        try {
            lifted = Objects.requireNonNull(operator.apply(observer), "The operator returned a null MaybeObserver");
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            EmptyDisposable.error(ex, observer);
            return;
        }

            

Reported by PMD.

               */
public final class MaybeFromCompletionStage<T> extends Maybe<T> {

    final CompletionStage<T> stage;

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


            

Reported by PMD.

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

        final MaybeObserver<? super T> downstream;

        final BiConsumerAtomicReference<T> whenReference;

        CompletionStageHandler(MaybeObserver<? super T> downstream, BiConsumerAtomicReference<T> whenReference) {
            this.downstream = downstream;

            

Reported by PMD.

              
        final MaybeObserver<? super T> downstream;

        final BiConsumerAtomicReference<T> whenReference;

        CompletionStageHandler(MaybeObserver<? super T> 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.

              @State(Scope.Thread)
public class PublishProcessorPerf {

    PublishProcessor<Integer> unbounded;

    PublishProcessor<Integer> bounded;

    PublishSubject<Integer> subject;


            

Reported by PMD.

              
    PublishProcessor<Integer> unbounded;

    PublishProcessor<Integer> bounded;

    PublishSubject<Integer> subject;

    @Setup
    public void setup(Blackhole bh) {

            

Reported by PMD.

              
    PublishProcessor<Integer> bounded;

    PublishSubject<Integer> subject;

    @Setup
    public void setup(Blackhole bh) {
        unbounded = PublishProcessor.create();
        unbounded.subscribe(new PerfConsumer(bh));

            

Reported by PMD.

              
import java.util.concurrent.TimeUnit;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;

import io.reactivex.rxjava3.processors.PublishProcessor;
import io.reactivex.rxjava3.subjects.PublishSubject;


            

Reported by PMD.

              
public final class ObservableIgnoreElementsCompletable<T> extends Completable implements FuseToObservable<T> {

    final ObservableSource<T> source;

    public ObservableIgnoreElementsCompletable(ObservableSource<T> source) {
        this.source = source;
    }


            

Reported by PMD.

                  }

    static final class IgnoreObservable<T> implements Observer<T>, Disposable {
        final CompletableObserver downstream;

        Disposable upstream;

        IgnoreObservable(CompletableObserver t) {
            this.downstream = t;

            

Reported by PMD.

                  static final class IgnoreObservable<T> implements Observer<T>, Disposable {
        final CompletableObserver downstream;

        Disposable upstream;

        IgnoreObservable(CompletableObserver t) {
            this.downstream = t;
        }


            

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.fuseable.FuseToObservable;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

public final class ObservableIgnoreElementsCompletable<T> extends Completable implements FuseToObservable<T> {

            

Reported by PMD.

              
public final class CompletableLift extends Completable {

    final CompletableSource source;

    final CompletableOperator onLift;

    public CompletableLift(CompletableSource source, CompletableOperator onLift) {
        this.source = source;

            

Reported by PMD.

              
    final CompletableSource source;

    final CompletableOperator onLift;

    public CompletableLift(CompletableSource source, CompletableOperator onLift) {
        this.source = source;
        this.onLift = onLift;
    }

            

Reported by PMD.

                          source.subscribe(sw);
        } catch (NullPointerException ex) { // NOPMD
            throw ex;
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            RxJavaPlugins.onError(ex);
        }
    }


            

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.plugins.RxJavaPlugins;

public final class CompletableLift extends Completable {


            

Reported by PMD.