forked from ReactiveX/RxJavaDebug
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathDebugSubscriber.java
More file actions
129 lines (114 loc) · 3.89 KB
/
DebugSubscriber.java
File metadata and controls
129 lines (114 loc) · 3.89 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/**
* Copyright 2014 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is
* distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
* the License for the specific language governing permissions and limitations under the License.
*/
package rx.operators;
import rx.Observable.Operator;
import rx.Producer;
import rx.Subscriber;
import rx.exceptions.Exceptions;
import rx.plugins.DebugNotification;
import rx.plugins.DebugNotificationListener;
public final class DebugSubscriber<T, C> extends Subscriber<T> {
private DebugNotificationListener<C> listener;
private final Subscriber<? super T> o;
private Operator<? extends T, ?> from = null;
private Operator<?, ? super T> to = null;
public DebugSubscriber(DebugNotificationListener<C> listener, Subscriber<? super T> _o, Operator<? extends T, ?> _out, Operator<?, ? super T> _in) {
super(_o);
this.listener = listener;
this.o = _o;
this.from = _out;
this.to = _in;
this.add(new DebugSubscription<T, C>(this, listener));
}
@Override
public void onStart() {
final DebugNotification<T> n = DebugNotification.createStart(o, from, to);
C context = listener.start(n);
try {
o.onStart();
listener.complete(context);
} catch (Throwable e) {
listener.error(context, e);
throw Exceptions.propagate(e);
}
}
@Override
public void onCompleted() {
final DebugNotification<T> n = DebugNotification.createOnCompleted(o, from, to);
C context = listener.start(n);
try {
o.onCompleted();
listener.complete(context);
} catch (Throwable e) {
listener.error(context, e);
throw Exceptions.propagate(e);
}
}
@Override
public void onError(Throwable e) {
final DebugNotification<T> n = DebugNotification.createOnError(o, from, e, to);
C context = listener.start(n);
try {
o.onError(e);
listener.complete(context);
} catch (Throwable e2) {
listener.error(context, e2);
throw Exceptions.propagate(e);
}
}
@Override
public void onNext(T t) {
final DebugNotification<T> n = DebugNotification.createOnNext(o, from, t, to);
t = (T) listener.onNext(n);
C context = listener.start(n);
try {
o.onNext(t);
listener.complete(context);
} catch (Throwable e) {
listener.error(context, e);
throw Exceptions.propagate(e);
}
}
@Override
public void setProducer(final Producer producer) {
o.setProducer(new Producer() {
@Override
public void request(long n) {
final DebugNotification<T> dn = DebugNotification.createRequest(o, from, to, n);
C context = listener.start(dn);
try {
producer.request(n);
listener.complete(context);
} catch (Throwable e) {
listener.error(context, e);
throw Exceptions.propagate(e);
}
}
});
}
public Operator<? extends T, ?> getFrom() {
return from;
}
public void setFrom(Operator<? extends T, ?> bind) {
this.from = bind;
}
public Operator<?, ? super T> getTo() {
return to;
}
public void setTo(Operator<?, ? super T> op) {
this.to = op;
}
public Subscriber<? super T> getActual() {
return o;
}
}