-
Notifications
You must be signed in to change notification settings - Fork 7.6k
/
ExceptionHelper.java
137 lines (117 loc) · 4.27 KB
/
ExceptionHelper.java
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
130
131
132
133
134
135
136
137
/**
* Copyright (c) 2016-present, RxJava Contributors.
*
* 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 io.reactivex.internal.util;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import io.reactivex.exceptions.CompositeException;
/**
* Terminal atomics for Throwable containers.
*/
public final class ExceptionHelper {
/** Utility class. */
private ExceptionHelper() {
throw new IllegalStateException("No instances!");
}
/**
* If the provided Throwable is an Error this method
* throws it, otherwise returns a RuntimeException wrapping the error
* if that error is a checked exception.
* @param error the error to wrap or throw
* @return the (wrapped) error
*/
public static RuntimeException wrapOrThrow(Throwable error) {
if (error instanceof Error) {
throw (Error)error;
}
if (error instanceof RuntimeException) {
return (RuntimeException)error;
}
return new RuntimeException(error);
}
/**
* A singleton instance of a Throwable indicating a terminal state for exceptions,
* don't leak this.
*/
public static final Throwable TERMINATED = new Termination();
public static <T> boolean addThrowable(AtomicReference<Throwable> field, Throwable exception) {
for (;;) {
Throwable current = field.get();
if (current == TERMINATED) {
return false;
}
Throwable update;
if (current == null) {
update = exception;
} else {
update = new CompositeException(current, exception);
}
if (field.compareAndSet(current, update)) {
return true;
}
}
}
public static <T> Throwable terminate(AtomicReference<Throwable> field) {
Throwable current = field.get();
if (current != TERMINATED) {
current = field.getAndSet(TERMINATED);
}
return current;
}
/**
* Returns a flattened list of Throwables from tree-like CompositeException chain.
* @param t the starting throwable
* @return the list of Throwables flattened in a depth-first manner
*/
public static List<Throwable> flatten(Throwable t) {
List<Throwable> list = new ArrayList<Throwable>();
ArrayDeque<Throwable> deque = new ArrayDeque<Throwable>();
deque.offer(t);
while (!deque.isEmpty()) {
Throwable e = deque.removeFirst();
if (e instanceof CompositeException) {
CompositeException ce = (CompositeException) e;
List<Throwable> exceptions = ce.getExceptions();
for (int i = exceptions.size() - 1; i >= 0; i--) {
deque.offerFirst(exceptions.get(i));
}
} else {
list.add(e);
}
}
return list;
}
/**
* Workaround for Java 6 not supporting throwing a final Throwable from a catch block.
* @param <E> the generic exception type
* @param e the Throwable error to return or throw
* @return the Throwable e if it is a subclass of Exception
* @throws E the generic exception thrown
*/
@SuppressWarnings("unchecked")
public static <E extends Throwable> Exception throwIfThrowable(Throwable e) throws E {
if (e instanceof Exception) {
return (Exception)e;
}
throw (E)e;
}
static final class Termination extends Throwable {
private static final long serialVersionUID = -4649703670690200604L;
Termination() {
super("No further exceptions");
}
@Override
public Throwable fillInStackTrace() {
return this;
}
}
}