*/
public abstract class ResourceObserver<T> implements Observer<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 ResourceObserver}.
     *
     * @param resource the resource to add

            

Reported by PMD.

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

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

            

Reported by PMD.

              abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {

    /** The source consumable Observable. */
    protected final ObservableSource<T> source;

    /**
     * Constructs the ObservableSource with the given consumable.
     * @param source the consumable Observable
     */

            

Reported by PMD.

              abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {

    /** The source consumable Observable. */
    protected final ObservableSource<T> source;

    /**
     * Constructs the ObservableSource with the given consumable.
     * @param source the consumable Observable
     */

            

Reported by PMD.

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

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.fuseable.HasUpstreamObservableSource;

/**
 * Base class for operators with a source consumable.
 *

            

Reported by PMD.

                  private static final long serialVersionUID = -266195175408988651L;

    /** The upstream disposable. */
    protected Disposable upstream;

    /**
     * Creates a DeferredScalarObserver instance and wraps a downstream Observer.
     * @param downstream the downstream subscriber, not null (not verified)
     */

            

Reported by PMD.

              
    @Override
    public void onError(Throwable t) {
        value = null;
        error(t);
    }

    @Override
    public void onComplete() {

            

Reported by PMD.

                  public void onComplete() {
        R v = value;
        if (v != null) {
            value = null;
            complete(v);
        } else {
            complete();
        }
    }

            

Reported by PMD.

              public final class MaterializeSingleObserver<T>
implements SingleObserver<T>, MaybeObserver<T>, CompletableObserver, Disposable {

    final SingleObserver<? super Notification<T>> downstream;

    Disposable upstream;

    public MaterializeSingleObserver(SingleObserver<? super Notification<T>> downstream) {
        this.downstream = downstream;

            

Reported by PMD.

              
    final SingleObserver<? super Notification<T>> downstream;

    Disposable upstream;

    public MaterializeSingleObserver(SingleObserver<? super Notification<T>> downstream) {
        this.downstream = downstream;
    }


            

Reported by PMD.

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

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

/**
 * A consumer that implements the consumer types of Maybe, Single and Completable

            

Reported by PMD.

                  static final class IsEmptyMaybeObserver<T>
    implements MaybeObserver<T>, Disposable {

        final MaybeObserver<? super Boolean> downstream;

        Disposable upstream;

        IsEmptyMaybeObserver(MaybeObserver<? super Boolean> downstream) {
            this.downstream = downstream;

            

Reported by PMD.

              
        final MaybeObserver<? super Boolean> downstream;

        Disposable upstream;

        IsEmptyMaybeObserver(MaybeObserver<? super Boolean> downstream) {
            this.downstream = downstream;
        }


            

Reported by PMD.

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

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

/**
 * Signals true if the source Maybe signals onComplete, signals false if the source Maybe

            

Reported by PMD.

              
    static final class IgnoreMaybeObserver<T> implements MaybeObserver<T>, Disposable {

        final MaybeObserver<? super T> downstream;

        Disposable upstream;

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

            

Reported by PMD.

              
        final MaybeObserver<? super T> downstream;

        Disposable upstream;

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


            

Reported by PMD.

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

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

/**
 * Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.

            

Reported by PMD.

              
    static final class HideMaybeObserver<T> implements MaybeObserver<T>, Disposable {

        final MaybeObserver<? super T> downstream;

        Disposable upstream;

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

            

Reported by PMD.

              
        final MaybeObserver<? super T> downstream;

        Disposable upstream;

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


            

Reported by PMD.

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

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

/**
 * Hides the identity of the upstream Maybe and its Disposable sent through onSubscribe.

            

Reported by PMD.

               */
public abstract class ResourceMaybeObserver<T> implements MaybeObserver<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 ResourceMaybeObserver}.
     *
     * @param resource the resource to add

            

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.internal.disposables.*;
import io.reactivex.rxjava3.internal.util.EndConsumerHelper;

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

            

Reported by PMD.

               */
abstract class AbstractMaybeWithUpstream<T, R> extends Maybe<R> implements HasUpstreamMaybeSource<T> {

    protected final MaybeSource<T> source;

    AbstractMaybeWithUpstream(MaybeSource<T> source) {
        this.source = source;
    }


            

Reported by PMD.

               */
abstract class AbstractMaybeWithUpstream<T, R> extends Maybe<R> implements HasUpstreamMaybeSource<T> {

    protected final MaybeSource<T> source;

    AbstractMaybeWithUpstream(MaybeSource<T> source) {
        this.source = source;
    }


            

Reported by PMD.

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

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.fuseable.HasUpstreamMaybeSource;

/**
 * Abstract base class for intermediate Maybe operators that take an upstream MaybeSource.
 *

            

Reported by PMD.

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

    final Publisher<T> source;

    final long index;

    public FlowableElementAtMaybePublisher(Publisher<T> source, long index) {
        this.source = source;

            

Reported by PMD.

              
    final Publisher<T> source;

    final long index;

    public FlowableElementAtMaybePublisher(Publisher<T> source, long index) {
        this.source = source;
        this.index = index;
    }

            

Reported by PMD.

              
import org.reactivestreams.Publisher;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.operators.flowable.FlowableElementAtMaybe.ElementAtSubscriber;

/**
 * Emits the indexth element from a Publisher as a Maybe.
 *

            

Reported by PMD.