Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/jdk8/FlowableCollectWithCollector.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 org.reactivestreams.*;
21
22 import io.reactivex.rxjava3.annotations.NonNull;
23 import io.reactivex.rxjava3.core.*;
24 import io.reactivex.rxjava3.exceptions.Exceptions;
25 import io.reactivex.rxjava3.internal.subscriptions.*;
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 FlowableCollectWithCollector<T, A, R> extends Flowable<R> {
37
38 final Flowable<T> source;
39
40 final Collector<? super T, A, R> collector;
41
42 public FlowableCollectWithCollector(Flowable<T> source, Collector<? super T, A, R> collector) {
43 this.source = source;
44 this.collector = collector;
45 }
46
47 @Override
48 protected void subscribeActual(@NonNull Subscriber<? super R> s) {
49 A container;
50 BiConsumer<A, ? super T> accumulator;
51 Function<A, R> finisher;
52
53 try {
54 container = collector.supplier().get();
55 accumulator = collector.accumulator();
56 finisher = collector.finisher();
57 } catch (Throwable ex) {
58 Exceptions.throwIfFatal(ex);
59 EmptySubscription.error(ex, s);
60 return;
61 }
62
63 source.subscribe(new CollectorSubscriber<>(s, container, accumulator, finisher));
64 }
65
66 static final class CollectorSubscriber<T, A, R>
67 extends DeferredScalarSubscription<R>
68 implements FlowableSubscriber<T> {
69
70 private static final long serialVersionUID = -229544830565448758L;
71
72 final BiConsumer<A, T> accumulator;
73
74 final Function<A, R> finisher;
75
76 Subscription upstream;
77
78 boolean done;
79
80 A container;
81
82 CollectorSubscriber(Subscriber<? super R> downstream, A container, BiConsumer<A, T> accumulator, Function<A, R> finisher) {
83 super(downstream);
84 this.container = container;
85 this.accumulator = accumulator;
86 this.finisher = finisher;
87 }
88
89 @Override
90 public void onSubscribe(@NonNull Subscription s) {
91 if (SubscriptionHelper.validate(this.upstream, s)) {
92 this.upstream = s;
93
94 downstream.onSubscribe(this);
95
96 s.request(Long.MAX_VALUE);
97 }
98 }
99
100 @Override
101 public void onNext(T t) {
102 if (done) {
103 return;
104 }
105 try {
106 accumulator.accept(container, t);
107 } catch (Throwable ex) {
108 Exceptions.throwIfFatal(ex);
109 upstream.cancel();
110 onError(ex);
111 }
112 }
113
114 @Override
115 public void onError(Throwable t) {
116 if (done) {
117 RxJavaPlugins.onError(t);
118 } else {
119 done = true;
120 upstream = SubscriptionHelper.CANCELLED;
121 this.container = null;
122 downstream.onError(t);
123 }
124 }
125
126 @Override
127 public void onComplete() {
128 if (done) {
129 return;
130 }
131
132 done = true;
133 upstream = SubscriptionHelper.CANCELLED;
134 A container = this.container;
135 this.container = null;
136 R result;
137 try {
138 result = Objects.requireNonNull(finisher.apply(container), "The finisher returned a null value");
139 } catch (Throwable ex) {
140 Exceptions.throwIfFatal(ex);
141 downstream.onError(ex);
142 return;
143 }
144
145 complete(result);
146 }
147
148 @Override
149 public void cancel() {
150 super.cancel();
151 upstream.cancel();
152 }
153 }
154 }