Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFromArray.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.flowable;
15
16 import org.reactivestreams.Subscriber;
17
18 import io.reactivex.rxjava3.annotations.Nullable;
19 import io.reactivex.rxjava3.core.Flowable;
20 import io.reactivex.rxjava3.internal.subscriptions.*;
21 import io.reactivex.rxjava3.internal.util.BackpressureHelper;
22 import io.reactivex.rxjava3.operators.ConditionalSubscriber;
23
24 import java.util.Objects;
25
26 public final class FlowableFromArray<T> extends Flowable<T> {
27 final T[] array;
28
29 public FlowableFromArray(T[] array) {
30 this.array = array;
31 }
32
33 @Override
34 public void subscribeActual(Subscriber<? super T> s) {
35 if (s instanceof ConditionalSubscriber) {
36 s.onSubscribe(new ArrayConditionalSubscription<>(
37 (ConditionalSubscriber<? super T>)s, array));
38 } else {
39 s.onSubscribe(new ArraySubscription<>(s, array));
40 }
41 }
42
43 abstract static class BaseArraySubscription<T> extends BasicQueueSubscription<T> {
44 private static final long serialVersionUID = -2252972430506210021L;
45
46 final T[] array;
47
48 int index;
49
50 volatile boolean cancelled;
51
52 BaseArraySubscription(T[] array) {
53 this.array = array;
54 }
55
56 @Override
57 public final int requestFusion(int mode) {
58 return mode & SYNC;
59 }
60
61 @Nullable
62 @Override
63 public final T poll() {
64 int i = index;
65 T[] arr = array;
66 if (i == arr.length) {
67 return null;
68 }
69
70 index = i + 1;
71 return Objects.requireNonNull(arr[i], "array element is null");
72 }
73
74 @Override
75 public final boolean isEmpty() {
76 return index == array.length;
77 }
78
79 @Override
80 public final void clear() {
81 index = array.length;
82 }
83
84 @Override
85 public final void request(long n) {
86 if (SubscriptionHelper.validate(n)) {
87 if (BackpressureHelper.add(this, n) == 0L) {
88 if (n == Long.MAX_VALUE) {
89 fastPath();
90 } else {
91 slowPath(n);
92 }
93 }
94 }
95 }
96
97 @Override
98 public final void cancel() {
99 cancelled = true;
100 }
101
102 abstract void fastPath();
103
104 abstract void slowPath(long r);
105 }
106
107 static final class ArraySubscription<T> extends BaseArraySubscription<T> {
108
109 private static final long serialVersionUID = 2587302975077663557L;
110
111 final Subscriber<? super T> downstream;
112
113 ArraySubscription(Subscriber<? super T> actual, T[] array) {
114 super(array);
115 this.downstream = actual;
116 }
117
118 @Override
119 void fastPath() {
120 T[] arr = array;
121 int f = arr.length;
122 Subscriber<? super T> a = downstream;
123
124 for (int i = index; i != f; i++) {
125 if (cancelled) {
126 return;
127 }
128 T t = arr[i];
129 if (t == null) {
130 a.onError(new NullPointerException("The element at index " + i + " is null"));
131 return;
132 } else {
133 a.onNext(t);
134 }
135 }
136 if (cancelled) {
137 return;
138 }
139 a.onComplete();
140 }
141
142 @Override
143 void slowPath(long r) {
144 long e = 0;
145 T[] arr = array;
146 int f = arr.length;
147 int i = index;
148 Subscriber<? super T> a = downstream;
149
150 for (;;) {
151
152 while (e != r && i != f) {
153 if (cancelled) {
154 return;
155 }
156
157 T t = arr[i];
158
159 if (t == null) {
160 a.onError(new NullPointerException("The element at index " + i + " is null"));
161 return;
162 } else {
163 a.onNext(t);
164 }
165
166 e++;
167 i++;
168 }
169
170 if (i == f) {
171 if (!cancelled) {
172 a.onComplete();
173 }
174 return;
175 }
176
177 r = get();
178 if (e == r) {
179 index = i;
180 r = addAndGet(-e);
181 if (r == 0L) {
182 return;
183 }
184 e = 0L;
185 }
186 }
187 }
188 }
189
190 static final class ArrayConditionalSubscription<T> extends BaseArraySubscription<T> {
191
192 private static final long serialVersionUID = 2587302975077663557L;
193
194 final ConditionalSubscriber<? super T> downstream;
195
196 ArrayConditionalSubscription(ConditionalSubscriber<? super T> actual, T[] array) {
197 super(array);
198 this.downstream = actual;
199 }
200
201 @Override
202 void fastPath() {
203 T[] arr = array;
204 int f = arr.length;
205 ConditionalSubscriber<? super T> a = downstream;
206
207 for (int i = index; i != f; i++) {
208 if (cancelled) {
209 return;
210 }
211 T t = arr[i];
212 if (t == null) {
213 a.onError(new NullPointerException("The element at index " + i + " is null"));
214 return;
215 } else {
216 a.tryOnNext(t);
217 }
218 }
219 if (cancelled) {
220 return;
221 }
222 a.onComplete();
223 }
224
225 @Override
226 void slowPath(long r) {
227 long e = 0;
228 T[] arr = array;
229 int f = arr.length;
230 int i = index;
231 ConditionalSubscriber<? super T> a = downstream;
232
233 for (;;) {
234
235 while (e != r && i != f) {
236 if (cancelled) {
237 return;
238 }
239
240 T t = arr[i];
241
242 if (t == null) {
243 a.onError(new NullPointerException("The element at index " + i + " is null"));
244 return;
245 } else {
246 if (a.tryOnNext(t)) {
247 e++;
248 }
249
250 i++;
251 }
252 }
253
254 if (i == f) {
255 if (!cancelled) {
256 a.onComplete();
257 }
258 return;
259 }
260
261 r = get();
262 if (e == r) {
263 index = i;
264 r = addAndGet(-e);
265 if (r == 0L) {
266 return;
267 }
268 e = 0L;
269 }
270 }
271 }
272 }
273 }