Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/jdk8/ObservableCollectWithCollectorSingle.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.Objects;
17 import java.util.function.*;
18 import java.util.stream.Collector;
19
20 import io.reactivex.rxjava3.annotations.NonNull;
21 import io.reactivex.rxjava3.core.*;
22 import io.reactivex.rxjava3.disposables.Disposable;
23 import io.reactivex.rxjava3.exceptions.Exceptions;
24 import io.reactivex.rxjava3.internal.disposables.*;
25 import io.reactivex.rxjava3.internal.fuseable.FuseToObservable;
26 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
27
28 /**
29 * Collect items into a container defined by a Stream {@link Collector} callback set.
30 *
31 * @param <T> the upstream value type
32 * @param <A> the intermediate accumulator type
33 * @param <R> the result type
34 * @since 3.0.0
35 */
36 public final class ObservableCollectWithCollectorSingle<T, A, R> extends Single<R> implements FuseToObservable<R> {
37
38 final Observable<T> source;
39
40 final Collector<? super T, A, R> collector;
41
42 public ObservableCollectWithCollectorSingle(Observable<T> source, Collector<? super T, A, R> collector) {
43 this.source = source;
44 this.collector = collector;
45 }
46
47 @Override
48 public Observable<R> fuseToObservable() {
49 return new ObservableCollectWithCollector<>(source, collector);
50 }
51
52 @Override
53 protected void subscribeActual(@NonNull SingleObserver<? super R> observer) {
54 A container;
55 BiConsumer<A, ? super T> accumulator;
56 Function<A, R> finisher;
57
58 try {
59 container = collector.supplier().get();
60 accumulator = collector.accumulator();
61 finisher = collector.finisher();
62 } catch (Throwable ex) {
63 Exceptions.throwIfFatal(ex);
64 EmptyDisposable.error(ex, observer);
65 return;
66 }
67
68 source.subscribe(new CollectorSingleObserver<>(observer, container, accumulator, finisher));
69 }
70
71 static final class CollectorSingleObserver<T, A, R> implements Observer<T>, Disposable {
72
73 final SingleObserver<? super R> downstream;
74
75 final BiConsumer<A, T> accumulator;
76
77 final Function<A, R> finisher;
78
79 Disposable upstream;
80
81 boolean done;
82
83 A container;
84
85 CollectorSingleObserver(SingleObserver<? super R> downstream, A container, BiConsumer<A, T> accumulator, Function<A, R> finisher) {
86 this.downstream = downstream;
87 this.container = container;
88 this.accumulator = accumulator;
89 this.finisher = finisher;
90 }
91
92 @Override
93 public void onSubscribe(@NonNull Disposable d) {
94 if (DisposableHelper.validate(this.upstream, d)) {
95 this.upstream = d;
96
97 downstream.onSubscribe(this);
98 }
99 }
100
101 @Override
102 public void onNext(T t) {
103 if (done) {
104 return;
105 }
106 try {
107 accumulator.accept(container, t);
108 } catch (Throwable ex) {
109 Exceptions.throwIfFatal(ex);
110 upstream.dispose();
111 onError(ex);
112 }
113 }
114
115 @Override
116 public void onError(Throwable t) {
117 if (done) {
118 RxJavaPlugins.onError(t);
119 } else {
120 done = true;
121 upstream = DisposableHelper.DISPOSED;
122 this.container = null;
123 downstream.onError(t);
124 }
125 }
126
127 @Override
128 public void onComplete() {
129 if (done) {
130 return;
131 }
132
133 done = true;
134 upstream = DisposableHelper.DISPOSED;
135 A container = this.container;
136 this.container = null;
137 R result;
138 try {
139 result = Objects.requireNonNull(finisher.apply(container), "The finisher returned a null value");
140 } catch (Throwable ex) {
141 Exceptions.throwIfFatal(ex);
142 downstream.onError(ex);
143 return;
144 }
145
146 downstream.onSuccess(result);
147 }
148
149 @Override
150 public void dispose() {
151 upstream.dispose();
152 upstream = DisposableHelper.DISPOSED;
153 }
154
155 @Override
156 public boolean isDisposed() {
157 return upstream == DisposableHelper.DISPOSED;
158 }
159 }
160 }