extends CountDownLatch
implements MaybeObserver<T>, SingleObserver<T>, CompletableObserver, Disposable {

    T value;
    Throwable error;

    final SequentialDisposable upstream;

    public BlockingDisposableMultiObserver() {

            

Reported by PMD.

              implements MaybeObserver<T>, SingleObserver<T>, CompletableObserver, Disposable {

    T value;
    Throwable error;

    final SequentialDisposable upstream;

    public BlockingDisposableMultiObserver() {
        super(1);

            

Reported by PMD.

                  T value;
    Throwable error;

    final SequentialDisposable upstream;

    public BlockingDisposableMultiObserver() {
        super(1);
        upstream = new SequentialDisposable();
    }

            

Reported by PMD.

              import java.util.concurrent.CountDownLatch;

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

/**

            

Reported by PMD.

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

/**
 * Blocks until the upstream terminates and dispatches the outcome to
 * the actual observer.

            

Reported by PMD.

               */
public final class MaybeFromCompletable<T> extends Maybe<T> implements HasUpstreamCompletableSource {

    final CompletableSource source;

    public MaybeFromCompletable(CompletableSource source) {
        this.source = source;
    }


            

Reported by PMD.

               */
public final class MaybeFromCompletable<T> extends Maybe<T> implements HasUpstreamCompletableSource {

    final CompletableSource source;

    public MaybeFromCompletable(CompletableSource source) {
        this.source = source;
    }


            

Reported by PMD.

                  }

    static final class FromCompletableObserver<T> implements CompletableObserver, Disposable {
        final MaybeObserver<? super T> downstream;

        Disposable upstream;

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

            

Reported by PMD.

                  static final class FromCompletableObserver<T> implements CompletableObserver, Disposable {
        final MaybeObserver<? super T> downstream;

        Disposable upstream;

        FromCompletableObserver(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;
import io.reactivex.rxjava3.internal.fuseable.HasUpstreamCompletableSource;

/**

            

Reported by PMD.

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

    final SingleSource<T> source;

    final Consumer<? super T> onSuccess;

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

            

Reported by PMD.

              
    final SingleSource<T> source;

    final Consumer<? super T> onSuccess;

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

            

Reported by PMD.

              
    final class DoOnSuccess implements SingleObserver<T> {

        final SingleObserver<? super T> downstream;

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


            

Reported by PMD.

                      public void onSuccess(T value) {
            try {
                onSuccess.accept(value);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                downstream.onError(ex);
                return;
            }
            downstream.onSuccess(value);

            

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;

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

            

Reported by PMD.

              
        private static final long serialVersionUID = 4973004223787171406L;

        Subscription upstream;

        long count;

        CountSubscriber(Subscriber<? super Long> downstream) {
            super(downstream);

            

Reported by PMD.

              
        Subscription upstream;

        long count;

        CountSubscriber(Subscriber<? super Long> downstream) {
            super(downstream);
        }


            

Reported by PMD.

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

import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.subscriptions.*;

public final class FlowableCount<T> extends AbstractFlowableWithUpstream<T, Long> {

            

Reported by PMD.

              
import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.subscriptions.*;

public final class FlowableCount<T> extends AbstractFlowableWithUpstream<T, Long> {

    public FlowableCount(Flowable<T> source) {

            

Reported by PMD.

              import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.subscriptions.*;

public final class FlowableCount<T> extends AbstractFlowableWithUpstream<T, Long> {

    public FlowableCount(Flowable<T> source) {
        super(source);

            

Reported by PMD.

                      source.subscribe(new IgnoreElementsSubscriber<>(t));
    }

    static final class IgnoreElementsSubscriber<T> implements FlowableSubscriber<T>, QueueSubscription<T> {
        final Subscriber<? super T> downstream;

        Subscription upstream;

        IgnoreElementsSubscriber(Subscriber<? super T> downstream) {

            

Reported by PMD.

                  }

    static final class IgnoreElementsSubscriber<T> implements FlowableSubscriber<T>, QueueSubscription<T> {
        final Subscriber<? super T> downstream;

        Subscription upstream;

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

            

Reported by PMD.

                  static final class IgnoreElementsSubscriber<T> implements FlowableSubscriber<T>, QueueSubscription<T> {
        final Subscriber<? super T> downstream;

        Subscription upstream;

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


            

Reported by PMD.

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

import org.reactivestreams.*;

import io.reactivex.rxjava3.annotations.Nullable;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.fuseable.QueueSubscription;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;

            

Reported by PMD.

              import org.reactivestreams.*;

import io.reactivex.rxjava3.annotations.Nullable;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.fuseable.QueueSubscription;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;

public final class FlowableIgnoreElements<T> extends AbstractFlowableWithUpstream<T, T> {


            

Reported by PMD.

               * @param <T>
 *          the type of items emitted by the {@code ConnectableObservable}
 */
public abstract class ConnectableObservable<T> extends Observable<T> {

    /**
     * Instructs the {@code ConnectableObservable} to begin emitting the items from its underlying
     * {@link Observable} to its {@link Observer}s.
     * <dl>

            

Reported by PMD.

              import java.util.Objects;
import java.util.concurrent.TimeUnit;

import io.reactivex.rxjava3.annotations.*;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.internal.functions.*;
import io.reactivex.rxjava3.internal.operators.observable.*;

            

Reported by PMD.

              import java.util.concurrent.TimeUnit;

import io.reactivex.rxjava3.annotations.*;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.internal.functions.*;
import io.reactivex.rxjava3.internal.operators.observable.*;
import io.reactivex.rxjava3.internal.util.ConnectConsumer;

            

Reported by PMD.

              import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.internal.functions.*;
import io.reactivex.rxjava3.internal.operators.observable.*;
import io.reactivex.rxjava3.internal.util.ConnectConsumer;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;
import io.reactivex.rxjava3.schedulers.Schedulers;


            

Reported by PMD.

              import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.functions.Consumer;
import io.reactivex.rxjava3.internal.functions.*;
import io.reactivex.rxjava3.internal.operators.observable.*;
import io.reactivex.rxjava3.internal.util.ConnectConsumer;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;
import io.reactivex.rxjava3.schedulers.Schedulers;

/**

            

Reported by PMD.

                  private static final long serialVersionUID = -5502432239815349361L;

    /** The target of the events. */
    protected final Observer<? super T> downstream;

    /** The value stored temporarily when in fusion mode. */
    protected T value;

    /** Indicates there was a call to complete(T). */

            

Reported by PMD.

                  protected final Observer<? super T> downstream;

    /** The value stored temporarily when in fusion mode. */
    protected T value;

    /** Indicates there was a call to complete(T). */
    static final int TERMINATED = 2;

    /** Indicates the Disposable has been disposed. */

            

Reported by PMD.

                  public final T poll() {
        if (get() == FUSED_READY) {
            T v = value;
            value = null;
            lazySet(FUSED_CONSUMED);
            return v;
        }
        return null;
    }

            

Reported by PMD.

                  @Override
    public final void clear() {
        lazySet(FUSED_CONSUMED);
        value = null;
    }

    @Override
    public void dispose() {
        set(DISPOSED);

            

Reported by PMD.

                  @Override
    public void dispose() {
        set(DISPOSED);
        value = null;
    }

    /**
     * Try disposing this Disposable and return true if the current thread succeeded.
     * @return true if the current thread succeeded

            

Reported by PMD.

                  static final class ErrorNotification implements Serializable {

        private static final long serialVersionUID = -8759979445933046293L;
        final Throwable e;
        ErrorNotification(Throwable e) {
            this.e = e;
        }

        @Override

            

Reported by PMD.

                  static final class SubscriptionNotification implements Serializable {

        private static final long serialVersionUID = -1322257508628817540L;
        final Subscription upstream;
        SubscriptionNotification(Subscription s) {
            this.upstream = s;
        }

        @Override

            

Reported by PMD.

                  static final class DisposableNotification implements Serializable {

        private static final long serialVersionUID = -7482590109178395495L;
        final Disposable upstream;

        DisposableNotification(Disposable d) {
            this.upstream = d;
        }


            

Reported by PMD.

                   * @param o the notification object
     * @return the extracted value
     */
    @SuppressWarnings("unchecked")
    public static <T> T getValue(Object o) {
        return (T)o;
    }

    /**

            

Reported by PMD.

              import java.io.Serializable;

import java.util.Objects;
import org.reactivestreams.*;

import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;

/**

            

Reported by PMD.

              import io.reactivex.rxjava3.internal.observers.BasicFuseableObserver;

public final class ObservableFilter<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super T> predicate;
    public ObservableFilter(ObservableSource<T> source, Predicate<? super T> predicate) {
        super(source);
        this.predicate = predicate;
    }


            

Reported by PMD.

                  }

    static final class FilterObserver<T> extends BasicFuseableObserver<T, T> {
        final Predicate<? super T> filter;

        FilterObserver(Observer<? super T> actual, Predicate<? super T> filter) {
            super(actual);
            this.filter = filter;
        }

            

Reported by PMD.

                              boolean b;
                try {
                    b = filter.test(t);
                } catch (Throwable e) {
                    fail(e);
                    return;
                }
                if (b) {
                    downstream.onNext(t);

            

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.Predicate;
import io.reactivex.rxjava3.internal.observers.BasicFuseableObserver;

public final class ObservableFilter<T> extends AbstractObservableWithUpstream<T, T> {
    final Predicate<? super T> predicate;

            

Reported by PMD.

                          if (sourceMode == NONE) {
                boolean b;
                try {
                    b = filter.test(t);
                } catch (Throwable e) {
                    fail(e);
                    return;
                }
                if (b) {

            

Reported by PMD.

              
        private static final long serialVersionUID = -5467847744262967226L;

        Subscription upstream;

        TakeLastOneSubscriber(Subscriber<? super T> downstream) {
            super(downstream);
        }


            

Reported by PMD.

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

        @Override
        public void onComplete() {

            

Reported by PMD.

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

import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.subscriptions.*;

public final class FlowableTakeLastOne<T> extends AbstractFlowableWithUpstream<T, T> {

            

Reported by PMD.

              
import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.subscriptions.*;

public final class FlowableTakeLastOne<T> extends AbstractFlowableWithUpstream<T, T> {

    public FlowableTakeLastOne(Flowable<T> source) {

            

Reported by PMD.

              import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.internal.subscriptions.*;

public final class FlowableTakeLastOne<T> extends AbstractFlowableWithUpstream<T, T> {

    public FlowableTakeLastOne(Flowable<T> source) {
        super(source);

            

Reported by PMD.