Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeAmb.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.maybe;
15
16 import java.util.concurrent.atomic.AtomicBoolean;
17
18 import io.reactivex.rxjava3.core.*;
19 import io.reactivex.rxjava3.disposables.*;
20 import io.reactivex.rxjava3.exceptions.Exceptions;
21 import io.reactivex.rxjava3.internal.disposables.EmptyDisposable;
22 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
23
24 /**
25 * Signals the event of the first MaybeSource that signals.
26 *
27 * @param <T> the value type emitted
28 */
29 public final class MaybeAmb<T> extends Maybe<T> {
30 private final MaybeSource<? extends T>[] sources;
31 private final Iterable<? extends MaybeSource<? extends T>> sourcesIterable;
32
33 public MaybeAmb(MaybeSource<? extends T>[] sources, Iterable<? extends MaybeSource<? extends T>> sourcesIterable) {
34 this.sources = sources;
35 this.sourcesIterable = sourcesIterable;
36 }
37
38 @Override
39 @SuppressWarnings("unchecked")
40 protected void subscribeActual(MaybeObserver<? super T> observer) {
41 MaybeSource<? extends T>[] sources = this.sources;
42 int count = 0;
43 if (sources == null) {
44 sources = new MaybeSource[8];
45 try {
46 for (MaybeSource<? extends T> element : sourcesIterable) {
47 if (element == null) {
48 EmptyDisposable.error(new NullPointerException("One of the sources is null"), observer);
49 return;
50 }
51 if (count == sources.length) {
52 MaybeSource<? extends T>[] b = new MaybeSource[count + (count >> 2)];
53 System.arraycopy(sources, 0, b, 0, count);
54 sources = b;
55 }
56 sources[count++] = element;
57 }
58 } catch (Throwable e) {
59 Exceptions.throwIfFatal(e);
60 EmptyDisposable.error(e, observer);
61 return;
62 }
63 } else {
64 count = sources.length;
65 }
66
67 CompositeDisposable set = new CompositeDisposable();
68 observer.onSubscribe(set);
69
70 AtomicBoolean winner = new AtomicBoolean();
71
72 for (int i = 0; i < count; i++) {
73 MaybeSource<? extends T> s = sources[i];
74 if (set.isDisposed()) {
75 return;
76 }
77
78 if (s == null) {
79 set.dispose();
80 NullPointerException ex = new NullPointerException("One of the MaybeSources is null");
81 if (winner.compareAndSet(false, true)) {
82 observer.onError(ex);
83 } else {
84 RxJavaPlugins.onError(ex);
85 }
86 return;
87 }
88
89 s.subscribe(new AmbMaybeObserver<T>(observer, set, winner));
90 }
91
92 if (count == 0) {
93 observer.onComplete();
94 }
95 }
96
97 static final class AmbMaybeObserver<T>
98 implements MaybeObserver<T> {
99
100 final MaybeObserver<? super T> downstream;
101
102 final AtomicBoolean winner;
103
104 final CompositeDisposable set;
105
106 Disposable upstream;
107
108 AmbMaybeObserver(MaybeObserver<? super T> downstream, CompositeDisposable set, AtomicBoolean winner) {
109 this.downstream = downstream;
110 this.set = set;
111 this.winner = winner;
112 }
113
114 @Override
115 public void onSubscribe(Disposable d) {
116 upstream = d;
117 set.add(d);
118 }
119
120 @Override
121 public void onSuccess(T value) {
122 if (winner.compareAndSet(false, true)) {
123 set.delete(upstream);
124 set.dispose();
125
126 downstream.onSuccess(value);
127 }
128 }
129
130 @Override
131 public void onError(Throwable e) {
132 if (winner.compareAndSet(false, true)) {
133 set.delete(upstream);
134 set.dispose();
135
136 downstream.onError(e);
137 } else {
138 RxJavaPlugins.onError(e);
139 }
140 }
141
142 @Override
143 public void onComplete() {
144 if (winner.compareAndSet(false, true)) {
145 set.delete(upstream);
146 set.dispose();
147
148 downstream.onComplete();
149 }
150 }
151 }
152 }