Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/jdk8/ObservableFlatMapStream.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.jdk8;
15
16 import java.util.*;
17 import java.util.concurrent.atomic.AtomicInteger;
18 import java.util.stream.Stream;
19
20 import io.reactivex.rxjava3.annotations.NonNull;
21 import io.reactivex.rxjava3.core.Observable;
22 import io.reactivex.rxjava3.core.Observer;
23 import io.reactivex.rxjava3.disposables.Disposable;
24 import io.reactivex.rxjava3.exceptions.Exceptions;
25 import io.reactivex.rxjava3.functions.*;
26 import io.reactivex.rxjava3.internal.disposables.*;
27 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
28
29 /**
30 * Maps the upstream values onto {@link Stream}s and emits their items in order to the downstream.
31 *
32 * @param <T> the upstream element type
33 * @param <R> the inner {@code Stream} and result element type
34 * @since 3.0.0
35 */
36 public final class ObservableFlatMapStream<T, R> extends Observable<R> {
37
38 final Observable<T> source;
39
40 final Function<? super T, ? extends Stream<? extends R>> mapper;
41
42 public ObservableFlatMapStream(Observable<T> source, Function<? super T, ? extends Stream<? extends R>> mapper) {
43 this.source = source;
44 this.mapper = mapper;
45 }
46
47 @Override
48 protected void subscribeActual(Observer<? super R> observer) {
49 if (source instanceof Supplier) {
50 Stream<? extends R> stream = null;
51 try {
52 @SuppressWarnings("unchecked")
53 T t = ((Supplier<T>)source).get();
54 if (t != null) {
55 stream = Objects.requireNonNull(mapper.apply(t), "The mapper returned a null Stream");
56 }
57 } catch (Throwable ex) {
58 Exceptions.throwIfFatal(ex);
59 EmptyDisposable.error(ex, observer);
60 return;
61 }
62
63 if (stream != null) {
64 ObservableFromStream.subscribeStream(observer, stream);
65 } else {
66 EmptyDisposable.complete(observer);
67 }
68 } else {
69 source.subscribe(new FlatMapStreamObserver<>(observer, mapper));
70 }
71 }
72
73 static final class FlatMapStreamObserver<T, R> extends AtomicInteger
74 implements Observer<T>, Disposable {
75
76 private static final long serialVersionUID = -5127032662980523968L;
77
78 final Observer<? super R> downstream;
79
80 final Function<? super T, ? extends Stream<? extends R>> mapper;
81
82 Disposable upstream;
83
84 volatile boolean disposed;
85
86 boolean done;
87
88 FlatMapStreamObserver(Observer<? super R> downstream, Function<? super T, ? extends Stream<? extends R>> mapper) {
89 this.downstream = downstream;
90 this.mapper = mapper;
91 }
92
93 @Override
94 public void onSubscribe(@NonNull Disposable d) {
95 if (DisposableHelper.validate(this.upstream, d)) {
96 this.upstream = d;
97
98 downstream.onSubscribe(this);
99 }
100 }
101
102 @Override
103 public void onNext(@NonNull T t) {
104 if (done) {
105 return;
106 }
107 try {
108 try (Stream<? extends R> stream = Objects.requireNonNull(mapper.apply(t), "The mapper returned a null Stream")) {
109 Iterator<? extends R> it = stream.iterator();
110 while (it.hasNext()) {
111 if (disposed) {
112 done = true;
113 break;
114 }
115 R value = Objects.requireNonNull(it.next(), "The Stream's Iterator.next returned a null value");
116 if (disposed) {
117 done = true;
118 break;
119 }
120 downstream.onNext(value);
121 if (disposed) {
122 done = true;
123 break;
124 }
125 }
126 }
127 } catch (Throwable ex) {
128 Exceptions.throwIfFatal(ex);
129 upstream.dispose();
130 onError(ex);
131 }
132 }
133
134 @Override
135 public void onError(@NonNull Throwable e) {
136 if (done) {
137 RxJavaPlugins.onError(e);
138 } else {
139 done = true;
140 downstream.onError(e);
141 }
142 }
143
144 @Override
145 public void onComplete() {
146 if (!done) {
147 done = true;
148 downstream.onComplete();
149 }
150 }
151
152 @Override
153 public void dispose() {
154 disposed = true;
155 upstream.dispose();
156 }
157
158 @Override
159 public boolean isDisposed() {
160 return disposed;
161 }
162 }
163 }