Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/observable/ObservableInternalHelper.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.observable;
15
16 import java.util.Objects;
17 import java.util.concurrent.TimeUnit;
18
19 import io.reactivex.rxjava3.core.*;
20 import io.reactivex.rxjava3.functions.*;
21 import io.reactivex.rxjava3.internal.functions.*;
22 import io.reactivex.rxjava3.observables.ConnectableObservable;
23
24 /**
25 * Helper utility class to support Observable with inner classes.
26 */
27 public final class ObservableInternalHelper {
28
29 private ObservableInternalHelper() {
30 throw new IllegalStateException("No instances!");
31 }
32
33 static final class SimpleGenerator<T, S> implements BiFunction<S, Emitter<T>, S> {
34 final Consumer<Emitter<T>> consumer;
35
36 SimpleGenerator(Consumer<Emitter<T>> consumer) {
37 this.consumer = consumer;
38 }
39
40 @Override
41 public S apply(S t1, Emitter<T> t2) throws Throwable {
42 consumer.accept(t2);
43 return t1;
44 }
45 }
46
47 public static <T, S> BiFunction<S, Emitter<T>, S> simpleGenerator(Consumer<Emitter<T>> consumer) {
48 return new SimpleGenerator<>(consumer);
49 }
50
51 static final class SimpleBiGenerator<T, S> implements BiFunction<S, Emitter<T>, S> {
52 final BiConsumer<S, Emitter<T>> consumer;
53
54 SimpleBiGenerator(BiConsumer<S, Emitter<T>> consumer) {
55 this.consumer = consumer;
56 }
57
58 @Override
59 public S apply(S t1, Emitter<T> t2) throws Throwable {
60 consumer.accept(t1, t2);
61 return t1;
62 }
63 }
64
65 public static <T, S> BiFunction<S, Emitter<T>, S> simpleBiGenerator(BiConsumer<S, Emitter<T>> consumer) {
66 return new SimpleBiGenerator<>(consumer);
67 }
68
69 static final class ItemDelayFunction<T, U> implements Function<T, ObservableSource<T>> {
70 final Function<? super T, ? extends ObservableSource<U>> itemDelay;
71
72 ItemDelayFunction(Function<? super T, ? extends ObservableSource<U>> itemDelay) {
73 this.itemDelay = itemDelay;
74 }
75
76 @Override
77 public ObservableSource<T> apply(final T v) throws Throwable {
78 ObservableSource<U> o = Objects.requireNonNull(itemDelay.apply(v), "The itemDelay returned a null ObservableSource");
79 return new ObservableTake<>(o, 1).map(Functions.justFunction(v)).defaultIfEmpty(v);
80 }
81 }
82
83 public static <T, U> Function<T, ObservableSource<T>> itemDelay(final Function<? super T, ? extends ObservableSource<U>> itemDelay) {
84 return new ItemDelayFunction<>(itemDelay);
85 }
86
87 static final class ObserverOnNext<T> implements Consumer<T> {
88 final Observer<T> observer;
89
90 ObserverOnNext(Observer<T> observer) {
91 this.observer = observer;
92 }
93
94 @Override
95 public void accept(T v) {
96 observer.onNext(v);
97 }
98 }
99
100 static final class ObserverOnError<T> implements Consumer<Throwable> {
101 final Observer<T> observer;
102
103 ObserverOnError(Observer<T> observer) {
104 this.observer = observer;
105 }
106
107 @Override
108 public void accept(Throwable v) {
109 observer.onError(v);
110 }
111 }
112
113 static final class ObserverOnComplete<T> implements Action {
114 final Observer<T> observer;
115
116 ObserverOnComplete(Observer<T> observer) {
117 this.observer = observer;
118 }
119
120 @Override
121 public void run() {
122 observer.onComplete();
123 }
124 }
125
126 public static <T> Consumer<T> observerOnNext(Observer<T> observer) {
127 return new ObserverOnNext<>(observer);
128 }
129
130 public static <T> Consumer<Throwable> observerOnError(Observer<T> observer) {
131 return new ObserverOnError<>(observer);
132 }
133
134 public static <T> Action observerOnComplete(Observer<T> observer) {
135 return new ObserverOnComplete<>(observer);
136 }
137
138 static final class FlatMapWithCombinerInner<U, R, T> implements Function<U, R> {
139 private final BiFunction<? super T, ? super U, ? extends R> combiner;
140 private final T t;
141
142 FlatMapWithCombinerInner(BiFunction<? super T, ? super U, ? extends R> combiner, T t) {
143 this.combiner = combiner;
144 this.t = t;
145 }
146
147 @Override
148 public R apply(U w) throws Throwable {
149 return combiner.apply(t, w);
150 }
151 }
152
153 static final class FlatMapWithCombinerOuter<T, R, U> implements Function<T, ObservableSource<R>> {
154 private final BiFunction<? super T, ? super U, ? extends R> combiner;
155 private final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
156
157 FlatMapWithCombinerOuter(BiFunction<? super T, ? super U, ? extends R> combiner,
158 Function<? super T, ? extends ObservableSource<? extends U>> mapper) {
159 this.combiner = combiner;
160 this.mapper = mapper;
161 }
162
163 @Override
164 public ObservableSource<R> apply(final T t) throws Throwable {
165 @SuppressWarnings("unchecked")
166 ObservableSource<U> u = (ObservableSource<U>)Objects.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
167 return new ObservableMap<>(u, new FlatMapWithCombinerInner<U, R, T>(combiner, t));
168 }
169 }
170
171 public static <T, U, R> Function<T, ObservableSource<R>> flatMapWithCombiner(
172 final Function<? super T, ? extends ObservableSource<? extends U>> mapper,
173 final BiFunction<? super T, ? super U, ? extends R> combiner) {
174 return new FlatMapWithCombinerOuter<>(combiner, mapper);
175 }
176
177 static final class FlatMapIntoIterable<T, U> implements Function<T, ObservableSource<U>> {
178 private final Function<? super T, ? extends Iterable<? extends U>> mapper;
179
180 FlatMapIntoIterable(Function<? super T, ? extends Iterable<? extends U>> mapper) {
181 this.mapper = mapper;
182 }
183
184 @Override
185 public ObservableSource<U> apply(T t) throws Throwable {
186 return new ObservableFromIterable<>(Objects.requireNonNull(mapper.apply(t), "The mapper returned a null Iterable"));
187 }
188 }
189
190 public static <T, U> Function<T, ObservableSource<U>> flatMapIntoIterable(final Function<? super T, ? extends Iterable<? extends U>> mapper) {
191 return new FlatMapIntoIterable<>(mapper);
192 }
193
194 enum MapToInt implements Function<Object, Object> {
195 INSTANCE;
196 @Override
197 public Object apply(Object t) {
198 return 0;
199 }
200 }
201
202 public static <T> Supplier<ConnectableObservable<T>> replaySupplier(final Observable<T> parent) {
203 return new ReplaySupplier<>(parent);
204 }
205
206 public static <T> Supplier<ConnectableObservable<T>> replaySupplier(final Observable<T> parent, final int bufferSize, boolean eagerTruncate) {
207 return new BufferedReplaySupplier<>(parent, bufferSize, eagerTruncate);
208 }
209
210 public static <T> Supplier<ConnectableObservable<T>> replaySupplier(final Observable<T> parent, final int bufferSize, final long time, final TimeUnit unit, final Scheduler scheduler, boolean eagerTruncate) {
211 return new BufferedTimedReplaySupplier<>(parent, bufferSize, time, unit, scheduler, eagerTruncate);
212 }
213
214 public static <T> Supplier<ConnectableObservable<T>> replaySupplier(final Observable<T> parent, final long time, final TimeUnit unit, final Scheduler scheduler, boolean eagerTruncate) {
215 return new TimedReplayCallable<>(parent, time, unit, scheduler, eagerTruncate);
216 }
217
218 static final class ReplaySupplier<T> implements Supplier<ConnectableObservable<T>> {
219 private final Observable<T> parent;
220
221 ReplaySupplier(Observable<T> parent) {
222 this.parent = parent;
223 }
224
225 @Override
226 public ConnectableObservable<T> get() {
227 return parent.replay();
228 }
229 }
230
231 static final class BufferedReplaySupplier<T> implements Supplier<ConnectableObservable<T>> {
232 final Observable<T> parent;
233 final int bufferSize;
234
235 final boolean eagerTruncate;
236
237 BufferedReplaySupplier(Observable<T> parent, int bufferSize, boolean eagerTruncate) {
238 this.parent = parent;
239 this.bufferSize = bufferSize;
240 this.eagerTruncate = eagerTruncate;
241 }
242
243 @Override
244 public ConnectableObservable<T> get() {
245 return parent.replay(bufferSize, eagerTruncate);
246 }
247 }
248
249 static final class BufferedTimedReplaySupplier<T> implements Supplier<ConnectableObservable<T>> {
250 final Observable<T> parent;
251 final int bufferSize;
252 final long time;
253 final TimeUnit unit;
254 final Scheduler scheduler;
255
256 final boolean eagerTruncate;
257
258 BufferedTimedReplaySupplier(Observable<T> parent, int bufferSize, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate) {
259 this.parent = parent;
260 this.bufferSize = bufferSize;
261 this.time = time;
262 this.unit = unit;
263 this.scheduler = scheduler;
264 this.eagerTruncate = eagerTruncate;
265 }
266
267 @Override
268 public ConnectableObservable<T> get() {
269 return parent.replay(bufferSize, time, unit, scheduler, eagerTruncate);
270 }
271 }
272
273 static final class TimedReplayCallable<T> implements Supplier<ConnectableObservable<T>> {
274 final Observable<T> parent;
275 final long time;
276 final TimeUnit unit;
277 final Scheduler scheduler;
278
279 final boolean eagerTruncate;
280
281 TimedReplayCallable(Observable<T> parent, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate) {
282 this.parent = parent;
283 this.time = time;
284 this.unit = unit;
285 this.scheduler = scheduler;
286 this.eagerTruncate = eagerTruncate;
287 }
288
289 @Override
290 public ConnectableObservable<T> get() {
291 return parent.replay(time, unit, scheduler, eagerTruncate);
292 }
293 }
294 }