*/
public abstract class ResourceSingleObserver<T> implements SingleObserver<T>, Disposable {
    /** The active subscription. */
    private final AtomicReference<Disposable> upstream = new AtomicReference<>();

    /** The resource composite, can never be null. */
    private final ListCompositeDisposable resources = new ListCompositeDisposable();

    /**

            

Reported by PMD.

                  private final AtomicReference<Disposable> upstream = new AtomicReference<>();

    /** The resource composite, can never be null. */
    private final ListCompositeDisposable resources = new ListCompositeDisposable();

    /**
     * Adds a resource to this {@code ResourceSingleObserver}.
     *
     * @param resource the resource to add

            

Reported by PMD.

              import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.SingleObserver;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.internal.disposables.*;
import io.reactivex.rxjava3.internal.util.EndConsumerHelper;

/**
 * An abstract {@link SingleObserver} that allows asynchronous cancellation of its subscription
 * and the associated resources.

            

Reported by PMD.

              extends BaseTestConsumer<T, TestObserver<T>>
implements Observer<T>, Disposable, MaybeObserver<T>, SingleObserver<T>, CompletableObserver {
    /** The actual observer to forward events to. */
    private final Observer<? super T> downstream;

    /** Holds the current subscription if any. */
    private final AtomicReference<Disposable> upstream = new AtomicReference<>();

    /**

            

Reported by PMD.

                  private final Observer<? super T> downstream;

    /** Holds the current subscription if any. */
    private final AtomicReference<Disposable> upstream = new AtomicReference<>();

    /**
     * Constructs a non-forwarding {@code TestObserver}.
     * @param <T> the value type received
     * @return the new {@code TestObserver} instance

            

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;

/**
 * An {@link Observer}, {@link MaybeObserver}, {@link SingleObserver} and

            

Reported by PMD.

                          }
            if (compareAndSet(index, o, resource)) {
                if (o != null) {
                    o.dispose();
                }
                return true;
            }
        }
    }

            

Reported by PMD.

                              Disposable o = get(i);
                if (o != DisposableHelper.DISPOSED) {
                    o = getAndSet(i, DisposableHelper.DISPOSED);
                    if (o != DisposableHelper.DISPOSED && o != null) {
                        o.dispose();
                    }
                }
            }
        }

            

Reported by PMD.

                              if (o != DisposableHelper.DISPOSED) {
                    o = getAndSet(i, DisposableHelper.DISPOSED);
                    if (o != DisposableHelper.DISPOSED && o != null) {
                        o.dispose();
                    }
                }
            }
        }
    }

            

Reported by PMD.

               */
public final class FlowableFromSupplier<T> extends Flowable<T> implements Supplier<T> {

    final Supplier<? extends T> supplier;

    public FlowableFromSupplier(Supplier<? extends T> supplier) {
        this.supplier = supplier;
    }


            

Reported by PMD.

                      T t;
        try {
            t = Objects.requireNonNull(supplier.get(), "The supplier returned a null value");
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            if (deferred.isCancelled()) {
                RxJavaPlugins.onError(ex);
            } else {
                s.onError(ex);

            

Reported by PMD.

              
        T t;
        try {
            t = Objects.requireNonNull(supplier.get(), "The supplier returned a null value");
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            if (deferred.isCancelled()) {
                RxJavaPlugins.onError(ex);
            } else {

            

Reported by PMD.

               */
public final class ObservableFromCompletionStage<T> extends Observable<T> {

    final CompletionStage<T> stage;

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


            

Reported by PMD.

              
        private static final long serialVersionUID = 4665335664328839859L;

        final BiConsumerAtomicReference<T> whenReference;

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

            

Reported by PMD.

              import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BiConsumer;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.observers.DeferredScalarDisposable;

/**
 * Wrap a CompletionStage and signal its outcome.
 * @param <T> the element type

            

Reported by PMD.

               */
public final class ObservableSingleStageObserver<T> extends ObservableStageObserver<T> {

    final boolean hasDefault;

    final T defaultItem;

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

            

Reported by PMD.

              
    final boolean hasDefault;

    final T defaultItem;

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

            

Reported by PMD.

                  @Override
    public void onNext(T t) {
        if (value != null) {
            value = null;
            completeExceptionally(new IllegalArgumentException("Sequence contains more than one element!"));
        } else {
            value = t;
        }
    }

            

Reported by PMD.

               */
abstract class ObservableStageObserver<T> extends CompletableFuture<T> implements Observer<T> {

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

    T value;

    @Override
    public final void onSubscribe(@NonNull Disposable d) {

            

Reported by PMD.

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

    T value;

    @Override
    public final void onSubscribe(@NonNull Disposable d) {
        DisposableHelper.setOnce(upstream, d);
    }

            

Reported by PMD.

                  }

    protected final void clear() {
        value = null;
        upstream.lazySet(DisposableHelper.DISPOSED);
    }

    @Override
    public final boolean cancel(boolean mayInterruptIfRunning) {

            

Reported by PMD.

               */
public final class SingleFlattenStreamAsFlowable<T, R> extends Flowable<R> {

    final Single<T> source;

    final Function<? super T, ? extends Stream<? extends R>> mapper;

    public SingleFlattenStreamAsFlowable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper) {
        this.source = source;

            

Reported by PMD.

              
    final Single<T> source;

    final Function<? super T, ? extends Stream<? extends R>> mapper;

    public SingleFlattenStreamAsFlowable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper) {
        this.source = source;
        this.mapper = mapper;
    }

            

Reported by PMD.

              import org.reactivestreams.Subscriber;

import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.functions.Function;
import io.reactivex.rxjava3.internal.jdk8.MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver;

/**
 * Map the success value into a Java {@link Stream} and emits its values.

            

Reported by PMD.

               */
public final class SingleFlattenStreamAsObservable<T, R> extends Observable<R> {

    final Single<T> source;

    final Function<? super T, ? extends Stream<? extends R>> mapper;

    public SingleFlattenStreamAsObservable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper) {
        this.source = source;

            

Reported by PMD.

              
    final Single<T> source;

    final Function<? super T, ? extends Stream<? extends R>> mapper;

    public SingleFlattenStreamAsObservable(Single<T> source, Function<? super T, ? extends Stream<? extends R>> mapper) {
        this.source = source;
        this.mapper = mapper;
    }

            

Reported by PMD.

              import java.util.stream.Stream;

import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.functions.Function;
import io.reactivex.rxjava3.internal.jdk8.MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver;

/**
 * Map the success value into a Java {@link Stream} and emits its values.

            

Reported by PMD.

               */
final class ObservableWindowSubscribeIntercept<T> extends Observable<T> {

    final Subject<T> window;

    final AtomicBoolean once;

    ObservableWindowSubscribeIntercept(Subject<T> source) {
        this.window = source;

            

Reported by PMD.

              
    final Subject<T> window;

    final AtomicBoolean once;

    ObservableWindowSubscribeIntercept(Subject<T> source) {
        this.window = source;
        this.once = new AtomicBoolean();
    }

            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicBoolean;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.subjects.Subject;

/**
 * Wrapper for a Subject that detects an incoming subscriber.
 * @param <T> the element type of the flow.

            

Reported by PMD.