import io.reactivex.rxjava3.subscribers.SerializedSubscriber;

public final class FlowableWithLatestFrom<T, U, R> extends AbstractFlowableWithUpstream<T, R> {
    final BiFunction<? super T, ? super U, ? extends R> combiner;
    final Publisher<? extends U> other;
    public FlowableWithLatestFrom(Flowable<T> source, BiFunction<? super T, ? super U, ? extends R> combiner, Publisher<? extends U> other) {
        super(source);
        this.combiner = combiner;
        this.other = other;

            

Reported by PMD.

              
public final class FlowableWithLatestFrom<T, U, R> extends AbstractFlowableWithUpstream<T, R> {
    final BiFunction<? super T, ? super U, ? extends R> combiner;
    final Publisher<? extends U> other;
    public FlowableWithLatestFrom(Flowable<T> source, BiFunction<? super T, ? super U, ? extends R> combiner, Publisher<? extends U> other) {
        super(source);
        this.combiner = combiner;
        this.other = other;
    }

            

Reported by PMD.

              
        private static final long serialVersionUID = -312246233408980075L;

        final Subscriber<? super R> downstream;

        final BiFunction<? super T, ? super U, ? extends R> combiner;

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


            

Reported by PMD.

              
        final Subscriber<? super R> downstream;

        final BiFunction<? super T, ? super U, ? extends R> combiner;

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

        final AtomicLong requested = new AtomicLong();


            

Reported by PMD.

              
        final BiFunction<? super T, ? super U, ? extends R> combiner;

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

        final AtomicLong requested = new AtomicLong();

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


            

Reported by PMD.

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

        final AtomicLong requested = new AtomicLong();

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

        WithLatestFromSubscriber(Subscriber<? super R> actual, BiFunction<? super T, ? super U, ? extends R> combiner) {
            this.downstream = actual;

            

Reported by PMD.

              
        final AtomicLong requested = new AtomicLong();

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

        WithLatestFromSubscriber(Subscriber<? super R> actual, BiFunction<? super T, ? super U, ? extends R> combiner) {
            this.downstream = actual;
            this.combiner = combiner;
        }

            

Reported by PMD.

                      @Override
        public void onNext(T t) {
            if (!tryOnNext(t)) {
                upstream.get().request(1);
            }
        }

        @Override
        public boolean tryOnNext(T t) {

            

Reported by PMD.

                              R r;
                try {
                    r = Objects.requireNonNull(combiner.apply(t, u), "The combiner returned a null value");
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    cancel();
                    downstream.onError(e);
                    return false;
                }

            

Reported by PMD.

                  }

    final class FlowableWithLatestSubscriber implements FlowableSubscriber<U> {
        private final WithLatestFromSubscriber<T, U, R> wlf;

        FlowableWithLatestSubscriber(WithLatestFromSubscriber<T, U, R> wlf) {
            this.wlf = wlf;
        }


            

Reported by PMD.

              import io.reactivex.rxjava3.internal.disposables.*;

public final class CompletableConcatIterable extends Completable {
    final Iterable<? extends CompletableSource> sources;

    public CompletableConcatIterable(Iterable<? extends CompletableSource> sources) {
        this.sources = sources;
    }


            

Reported by PMD.

              
        try {
            it = Objects.requireNonNull(sources.iterator(), "The iterator returned is null");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            EmptyDisposable.error(e, observer);
            return;
        }


            

Reported by PMD.

              
        private static final long serialVersionUID = -7965400327305809232L;

        final CompletableObserver downstream;
        final Iterator<? extends CompletableSource> sources;

        final SequentialDisposable sd;

        ConcatInnerObserver(CompletableObserver actual, Iterator<? extends CompletableSource> sources) {

            

Reported by PMD.

                      private static final long serialVersionUID = -7965400327305809232L;

        final CompletableObserver downstream;
        final Iterator<? extends CompletableSource> sources;

        final SequentialDisposable sd;

        ConcatInnerObserver(CompletableObserver actual, Iterator<? extends CompletableSource> sources) {
            this.downstream = actual;

            

Reported by PMD.

                      final CompletableObserver downstream;
        final Iterator<? extends CompletableSource> sources;

        final SequentialDisposable sd;

        ConcatInnerObserver(CompletableObserver actual, Iterator<? extends CompletableSource> sources) {
            this.downstream = actual;
            this.sources = sources;
            this.sd = new SequentialDisposable();

            

Reported by PMD.

                              boolean b;
                try {
                    b = a.hasNext();
                } catch (Throwable ex) {
                    Exceptions.throwIfFatal(ex);
                    downstream.onError(ex);
                    return;
                }


            

Reported by PMD.

              
                try {
                    c = Objects.requireNonNull(a.next(), "The CompletableSource returned is null");
                } catch (Throwable ex) {
                    Exceptions.throwIfFatal(ex);
                    downstream.onError(ex);
                    return;
                }


            

Reported by PMD.

                                  return;
                }

                c.subscribe(this);
            } while (decrementAndGet() != 0);
        }
    }
}

            

Reported by PMD.

              import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;

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

public final class CompletableConcatIterable extends Completable {

            

Reported by PMD.

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

public final class CompletableConcatIterable extends Completable {
    final Iterable<? extends CompletableSource> sources;

    public CompletableConcatIterable(Iterable<? extends CompletableSource> sources) {

            

Reported by PMD.

              
public final class FlowableCollectSingle<T, U> extends Single<U> implements FuseToFlowable<U> {

    final Flowable<T> source;

    final Supplier<? extends U> initialSupplier;
    final BiConsumer<? super U, ? super T> collector;

    public FlowableCollectSingle(Flowable<T> source, Supplier<? extends U> initialSupplier, BiConsumer<? super U, ? super T> collector) {

            

Reported by PMD.

              
    final Flowable<T> source;

    final Supplier<? extends U> initialSupplier;
    final BiConsumer<? super U, ? super T> collector;

    public FlowableCollectSingle(Flowable<T> source, Supplier<? extends U> initialSupplier, BiConsumer<? super U, ? super T> collector) {
        this.source = source;
        this.initialSupplier = initialSupplier;

            

Reported by PMD.

                  final Flowable<T> source;

    final Supplier<? extends U> initialSupplier;
    final BiConsumer<? super U, ? super T> collector;

    public FlowableCollectSingle(Flowable<T> source, Supplier<? extends U> initialSupplier, BiConsumer<? super U, ? super T> collector) {
        this.source = source;
        this.initialSupplier = initialSupplier;
        this.collector = collector;

            

Reported by PMD.

                      U u;
        try {
            u = Objects.requireNonNull(initialSupplier.get(), "The initialSupplier returned a null value");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            EmptyDisposable.error(e, observer);
            return;
        }


            

Reported by PMD.

              
    static final class CollectSubscriber<T, U> implements FlowableSubscriber<T>, Disposable {

        final SingleObserver<? super U> downstream;

        final BiConsumer<? super U, ? super T> collector;

        final U u;


            

Reported by PMD.

              
        final SingleObserver<? super U> downstream;

        final BiConsumer<? super U, ? super T> collector;

        final U u;

        Subscription upstream;


            

Reported by PMD.

              
        final BiConsumer<? super U, ? super T> collector;

        final U u;

        Subscription upstream;

        boolean done;


            

Reported by PMD.

              
        final U u;

        Subscription upstream;

        boolean done;

        CollectSubscriber(SingleObserver<? super U> actual, U u, BiConsumer<? super U, ? super T> collector) {
            this.downstream = actual;

            

Reported by PMD.

              
        Subscription upstream;

        boolean done;

        CollectSubscriber(SingleObserver<? super U> actual, U u, BiConsumer<? super U, ? super T> collector) {
            this.downstream = actual;
            this.collector = collector;
            this.u = u;

            

Reported by PMD.

                          }
            try {
                collector.accept(u, t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                upstream.cancel();
                onError(e);
            }
        }

            

Reported by PMD.

              import io.reactivex.rxjava3.observers.SerializedObserver;

public final class ObservableDelay<T> extends AbstractObservableWithUpstream<T, T> {
    final long delay;
    final TimeUnit unit;
    final Scheduler scheduler;
    final boolean delayError;

    public ObservableDelay(ObservableSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {

            

Reported by PMD.

              
public final class ObservableDelay<T> extends AbstractObservableWithUpstream<T, T> {
    final long delay;
    final TimeUnit unit;
    final Scheduler scheduler;
    final boolean delayError;

    public ObservableDelay(ObservableSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
        super(source);

            

Reported by PMD.

              public final class ObservableDelay<T> extends AbstractObservableWithUpstream<T, T> {
    final long delay;
    final TimeUnit unit;
    final Scheduler scheduler;
    final boolean delayError;

    public ObservableDelay(ObservableSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
        super(source);
        this.delay = delay;

            

Reported by PMD.

                  final long delay;
    final TimeUnit unit;
    final Scheduler scheduler;
    final boolean delayError;

    public ObservableDelay(ObservableSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError) {
        super(source);
        this.delay = delay;
        this.unit = unit;

            

Reported by PMD.

                  }

    static final class DelayObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final long delay;
        final TimeUnit unit;
        final Scheduler.Worker w;
        final boolean delayError;


            

Reported by PMD.

              
    static final class DelayObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final long delay;
        final TimeUnit unit;
        final Scheduler.Worker w;
        final boolean delayError;

        Disposable upstream;

            

Reported by PMD.

                  static final class DelayObserver<T> implements Observer<T>, Disposable {
        final Observer<? super T> downstream;
        final long delay;
        final TimeUnit unit;
        final Scheduler.Worker w;
        final boolean delayError;

        Disposable upstream;


            

Reported by PMD.

                      final Observer<? super T> downstream;
        final long delay;
        final TimeUnit unit;
        final Scheduler.Worker w;
        final boolean delayError;

        Disposable upstream;

        DelayObserver(Observer<? super T> actual, long delay, TimeUnit unit, Worker w, boolean delayError) {

            

Reported by PMD.

                      final long delay;
        final TimeUnit unit;
        final Scheduler.Worker w;
        final boolean delayError;

        Disposable upstream;

        DelayObserver(Observer<? super T> actual, long delay, TimeUnit unit, Worker w, boolean delayError) {
            super();

            

Reported by PMD.

                      final Scheduler.Worker w;
        final boolean delayError;

        Disposable upstream;

        DelayObserver(Observer<? super T> actual, long delay, TimeUnit unit, Worker w, boolean delayError) {
            super();
            this.downstream = actual;
            this.delay = delay;

            

Reported by PMD.

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

    final Function<? super T, ? extends CompletableSource> mapper;

    final boolean delayErrors;

    public ObservableFlatMapCompletable(ObservableSource<T> source,
            Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors) {

            

Reported by PMD.

              
    final Function<? super T, ? extends CompletableSource> mapper;

    final boolean delayErrors;

    public ObservableFlatMapCompletable(ObservableSource<T> source,
            Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors) {
        super(source);
        this.mapper = mapper;

            

Reported by PMD.

                  implements Observer<T> {
        private static final long serialVersionUID = 8443155186132538303L;

        final Observer<? super T> downstream;

        final AtomicThrowable errors;

        final Function<? super T, ? extends CompletableSource> mapper;


            

Reported by PMD.

              
        final Observer<? super T> downstream;

        final AtomicThrowable errors;

        final Function<? super T, ? extends CompletableSource> mapper;

        final boolean delayErrors;


            

Reported by PMD.

              
        final AtomicThrowable errors;

        final Function<? super T, ? extends CompletableSource> mapper;

        final boolean delayErrors;

        final CompositeDisposable set;


            

Reported by PMD.

              
        final Function<? super T, ? extends CompletableSource> mapper;

        final boolean delayErrors;

        final CompositeDisposable set;

        Disposable upstream;


            

Reported by PMD.

              
        final boolean delayErrors;

        final CompositeDisposable set;

        Disposable upstream;

        volatile boolean disposed;


            

Reported by PMD.

              
        final CompositeDisposable set;

        Disposable upstream;

        volatile boolean disposed;

        FlatMapCompletableMainObserver(Observer<? super T> observer, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors) {
            this.downstream = observer;

            

Reported by PMD.

              
        Disposable upstream;

        volatile boolean disposed;

        FlatMapCompletableMainObserver(Observer<? super T> observer, Function<? super T, ? extends CompletableSource> mapper, boolean delayErrors) {
            this.downstream = observer;
            this.mapper = mapper;
            this.delayErrors = delayErrors;

            

Reported by PMD.

              
            try {
                cs = Objects.requireNonNull(mapper.apply(value), "The mapper returned a null CompletableSource");
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                upstream.dispose();
                onError(ex);
                return;
            }

            

Reported by PMD.

              
public final class CompletableMergeArrayDelayError extends Completable {

    final CompletableSource[] sources;

    public CompletableMergeArrayDelayError(CompletableSource[] sources) {
        this.sources = sources;
    }


            

Reported by PMD.

              
    final CompletableSource[] sources;

    public CompletableMergeArrayDelayError(CompletableSource[] sources) {
        this.sources = sources;
    }

    @Override
    public void subscribeActual(final CompletableObserver observer) {

            

Reported by PMD.

                          }

            if (c == null) {
                Throwable ex = new NullPointerException("A completable source is null");
                errors.tryAddThrowableOrReport(ex);
                wip.decrementAndGet();
                continue;
            }


            

Reported by PMD.

                              continue;
            }

            c.subscribe(new MergeInnerCompletableObserver(observer, set, errors, wip));
        }

        if (wip.decrementAndGet() == 0) {
            errors.tryTerminateConsumer(observer);
        }

            

Reported by PMD.

                  }

    static final class TryTerminateAndReportDisposable implements Disposable {
        final AtomicThrowable errors;
        TryTerminateAndReportDisposable(AtomicThrowable errors) {
            this.errors = errors;
        }

        @Override

            

Reported by PMD.

              
    static final class MergeInnerCompletableObserver
    implements CompletableObserver {
        final CompletableObserver downstream;
        final CompositeDisposable set;
        final AtomicThrowable errors;
        final AtomicInteger wip;

        MergeInnerCompletableObserver(CompletableObserver observer, CompositeDisposable set, AtomicThrowable error,

            

Reported by PMD.

                  static final class MergeInnerCompletableObserver
    implements CompletableObserver {
        final CompletableObserver downstream;
        final CompositeDisposable set;
        final AtomicThrowable errors;
        final AtomicInteger wip;

        MergeInnerCompletableObserver(CompletableObserver observer, CompositeDisposable set, AtomicThrowable error,
                AtomicInteger wip) {

            

Reported by PMD.

                  implements CompletableObserver {
        final CompletableObserver downstream;
        final CompositeDisposable set;
        final AtomicThrowable errors;
        final AtomicInteger wip;

        MergeInnerCompletableObserver(CompletableObserver observer, CompositeDisposable set, AtomicThrowable error,
                AtomicInteger wip) {
            this.downstream = observer;

            

Reported by PMD.

                      final CompletableObserver downstream;
        final CompositeDisposable set;
        final AtomicThrowable errors;
        final AtomicInteger wip;

        MergeInnerCompletableObserver(CompletableObserver observer, CompositeDisposable set, AtomicThrowable error,
                AtomicInteger wip) {
            this.downstream = observer;
            this.set = set;

            

Reported by PMD.

              
import java.util.concurrent.atomic.AtomicInteger;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.disposables.*;
import io.reactivex.rxjava3.internal.util.AtomicThrowable;

public final class CompletableMergeArrayDelayError extends Completable {


            

Reported by PMD.

              
public final class CompletableTimeout extends Completable {

    final CompletableSource source;
    final long timeout;
    final TimeUnit unit;
    final Scheduler scheduler;
    final CompletableSource other;


            

Reported by PMD.

              public final class CompletableTimeout extends Completable {

    final CompletableSource source;
    final long timeout;
    final TimeUnit unit;
    final Scheduler scheduler;
    final CompletableSource other;

    public CompletableTimeout(CompletableSource source, long timeout,

            

Reported by PMD.

              
    final CompletableSource source;
    final long timeout;
    final TimeUnit unit;
    final Scheduler scheduler;
    final CompletableSource other;

    public CompletableTimeout(CompletableSource source, long timeout,
                              TimeUnit unit, Scheduler scheduler, CompletableSource other) {

            

Reported by PMD.

                  final CompletableSource source;
    final long timeout;
    final TimeUnit unit;
    final Scheduler scheduler;
    final CompletableSource other;

    public CompletableTimeout(CompletableSource source, long timeout,
                              TimeUnit unit, Scheduler scheduler, CompletableSource other) {
        this.source = source;

            

Reported by PMD.

                  final long timeout;
    final TimeUnit unit;
    final Scheduler scheduler;
    final CompletableSource other;

    public CompletableTimeout(CompletableSource source, long timeout,
                              TimeUnit unit, Scheduler scheduler, CompletableSource other) {
        this.source = source;
        this.timeout = timeout;

            

Reported by PMD.

              
    static final class TimeOutObserver implements CompletableObserver {

        private final CompositeDisposable set;
        private final AtomicBoolean once;
        private final CompletableObserver downstream;

        TimeOutObserver(CompositeDisposable set, AtomicBoolean once, CompletableObserver observer) {
            this.set = set;

            

Reported by PMD.

                  static final class TimeOutObserver implements CompletableObserver {

        private final CompositeDisposable set;
        private final AtomicBoolean once;
        private final CompletableObserver downstream;

        TimeOutObserver(CompositeDisposable set, AtomicBoolean once, CompletableObserver observer) {
            this.set = set;
            this.once = once;

            

Reported by PMD.

              
        private final CompositeDisposable set;
        private final AtomicBoolean once;
        private final CompletableObserver downstream;

        TimeOutObserver(CompositeDisposable set, AtomicBoolean once, CompletableObserver observer) {
            this.set = set;
            this.once = once;
            this.downstream = observer;

            

Reported by PMD.

                  }

    final class DisposeTask implements Runnable {
        private final AtomicBoolean once;
        final CompositeDisposable set;
        final CompletableObserver downstream;

        DisposeTask(AtomicBoolean once, CompositeDisposable set, CompletableObserver observer) {
            this.once = once;

            

Reported by PMD.

              
    final class DisposeTask implements Runnable {
        private final AtomicBoolean once;
        final CompositeDisposable set;
        final CompletableObserver downstream;

        DisposeTask(AtomicBoolean once, CompositeDisposable set, CompletableObserver observer) {
            this.once = once;
            this.set = set;

            

Reported by PMD.

              import java.util.Objects;

public final class FlowableOnErrorNext<T> extends AbstractFlowableWithUpstream<T, T> {
    final Function<? super Throwable, ? extends Publisher<? extends T>> nextSupplier;

    public FlowableOnErrorNext(Flowable<T> source,
            Function<? super Throwable, ? extends Publisher<? extends T>> nextSupplier) {
        super(source);
        this.nextSupplier = nextSupplier;

            

Reported by PMD.

                  implements FlowableSubscriber<T> {
        private static final long serialVersionUID = 4063763155303814625L;

        final Subscriber<? super T> downstream;

        final Function<? super Throwable, ? extends Publisher<? extends T>> nextSupplier;

        boolean once;


            

Reported by PMD.

              
        final Subscriber<? super T> downstream;

        final Function<? super Throwable, ? extends Publisher<? extends T>> nextSupplier;

        boolean once;

        boolean done;


            

Reported by PMD.

              
        final Function<? super Throwable, ? extends Publisher<? extends T>> nextSupplier;

        boolean once;

        boolean done;

        long produced;


            

Reported by PMD.

              
        boolean once;

        boolean done;

        long produced;

        OnErrorNextSubscriber(Subscriber<? super T> actual, Function<? super Throwable, ? extends Publisher<? extends T>> nextSupplier) {
            super(false);

            

Reported by PMD.

              
        boolean done;

        long produced;

        OnErrorNextSubscriber(Subscriber<? super T> actual, Function<? super Throwable, ? extends Publisher<? extends T>> nextSupplier) {
            super(false);
            this.downstream = actual;
            this.nextSupplier = nextSupplier;

            

Reported by PMD.

              
            try {
                p = Objects.requireNonNull(nextSupplier.apply(t), "The nextSupplier returned a null Publisher");
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                downstream.onError(new CompositeException(t, e));
                return;
            }


            

Reported by PMD.

                          }

            long mainProduced = produced;
            if (mainProduced != 0L) {
                produced(mainProduced);
            }

            p.subscribe(this);
        }

            

Reported by PMD.

                              produced(mainProduced);
            }

            p.subscribe(this);
        }

        @Override
        public void onComplete() {
            if (done) {

            

Reported by PMD.

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

import org.reactivestreams.*;

import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.*;
import io.reactivex.rxjava3.functions.Function;
import io.reactivex.rxjava3.internal.subscriptions.SubscriptionArbiter;

            

Reported by PMD.

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

    final Future<? extends T> future;

    final long timeout;

    final TimeUnit unit;


            

Reported by PMD.

              
    final Future<? extends T> future;

    final long timeout;

    final TimeUnit unit;

    public MaybeFromFuture(Future<? extends T> future, long timeout, TimeUnit unit) {
        this.future = future;

            

Reported by PMD.

              
    final long timeout;

    final TimeUnit unit;

    public MaybeFromFuture(Future<? extends T> future, long timeout, TimeUnit unit) {
        this.future = future;
        this.timeout = timeout;
        this.unit = unit;

            

Reported by PMD.

                  protected void subscribeActual(MaybeObserver<? super T> observer) {
        Disposable d = Disposable.empty();
        observer.onSubscribe(d);
        if (!d.isDisposed()) {
            T v;
            try {
                if (timeout <= 0L) {
                    v = future.get();
                } else {

            

Reported by PMD.

                      if (!d.isDisposed()) {
            T v;
            try {
                if (timeout <= 0L) {
                    v = future.get();
                } else {
                    v = future.get(timeout, unit);
                }
            } catch (Throwable ex) {

            

Reported by PMD.

                              } else {
                    v = future.get(timeout, unit);
                }
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (ex instanceof ExecutionException) {
                    ex = ex.getCause();
                }
                Exceptions.throwIfFatal(ex);

            

Reported by PMD.

                              }
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (ex instanceof ExecutionException) {
                    ex = ex.getCause();
                }
                Exceptions.throwIfFatal(ex);
                if (!d.isDisposed()) {
                    observer.onError(ex);

            

Reported by PMD.

                          } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (ex instanceof ExecutionException) {
                    ex = ex.getCause();
                }
                Exceptions.throwIfFatal(ex);
                if (!d.isDisposed()) {
                    observer.onError(ex);
                }

            

Reported by PMD.

                          } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                if (ex instanceof ExecutionException) {
                    ex = ex.getCause();
                }
                Exceptions.throwIfFatal(ex);
                if (!d.isDisposed()) {
                    observer.onError(ex);
                }

            

Reported by PMD.

              
import java.util.concurrent.*;

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

/**
 * Waits until the source Future completes or the wait times out; treats a {@code null}

            

Reported by PMD.

              import java.util.Objects;

public final class ObservableCollect<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Supplier<? extends U> initialSupplier;
    final BiConsumer<? super U, ? super T> collector;

    public ObservableCollect(ObservableSource<T> source,
            Supplier<? extends U> initialSupplier, BiConsumer<? super U, ? super T> collector) {
        super(source);

            

Reported by PMD.

              
public final class ObservableCollect<T, U> extends AbstractObservableWithUpstream<T, U> {
    final Supplier<? extends U> initialSupplier;
    final BiConsumer<? super U, ? super T> collector;

    public ObservableCollect(ObservableSource<T> source,
            Supplier<? extends U> initialSupplier, BiConsumer<? super U, ? super T> collector) {
        super(source);
        this.initialSupplier = initialSupplier;

            

Reported by PMD.

                      U u;
        try {
            u = Objects.requireNonNull(initialSupplier.get(), "The initialSupplier returned a null value");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            EmptyDisposable.error(e, t);
            return;
        }


            

Reported by PMD.

                  }

    static final class CollectObserver<T, U> implements Observer<T>, Disposable {
        final Observer<? super U> downstream;
        final BiConsumer<? super U, ? super T> collector;
        final U u;

        Disposable upstream;


            

Reported by PMD.

              
    static final class CollectObserver<T, U> implements Observer<T>, Disposable {
        final Observer<? super U> downstream;
        final BiConsumer<? super U, ? super T> collector;
        final U u;

        Disposable upstream;

        boolean done;

            

Reported by PMD.

                  static final class CollectObserver<T, U> implements Observer<T>, Disposable {
        final Observer<? super U> downstream;
        final BiConsumer<? super U, ? super T> collector;
        final U u;

        Disposable upstream;

        boolean done;


            

Reported by PMD.

                      final BiConsumer<? super U, ? super T> collector;
        final U u;

        Disposable upstream;

        boolean done;

        CollectObserver(Observer<? super U> actual, U u, BiConsumer<? super U, ? super T> collector) {
            this.downstream = actual;

            

Reported by PMD.

              
        Disposable upstream;

        boolean done;

        CollectObserver(Observer<? super U> actual, U u, BiConsumer<? super U, ? super T> collector) {
            this.downstream = actual;
            this.collector = collector;
            this.u = u;

            

Reported by PMD.

                          }
            try {
                collector.accept(u, t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                upstream.dispose();
                onError(e);
            }
        }

            

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.exceptions.Exceptions;
import io.reactivex.rxjava3.functions.*;
import io.reactivex.rxjava3.internal.disposables.*;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;

            

Reported by PMD.