C register(@ParametricNullness C closeable) {
if (closeable != null) {
stack.addFirst(closeable);
}
return closeable;
}
/**
* Stores the given throwable and rethrows it. It will be rethrown as is if it is an {@code
* IOException}, {@code RuntimeException} or {@code Error}. Otherwise, it will be rethrown wrapped
* in a {@code RuntimeException}. Note: Be sure to declare all of the checked exception
* types your try block can throw when calling an overload of this method so as to avoid losing
* the original exception type.
*
* This method always throws, and as such should be called as {@code throw closer.rethrow(e);}
* to ensure the compiler knows that it will throw.
*
* @return this method does not return; it always throws
* @throws IOException when the given throwable is an IOException
*/
public RuntimeException rethrow(Throwable e) throws IOException {
checkNotNull(e);
thrown = e;
Throwables.propagateIfPossible(e, IOException.class);
throw new RuntimeException(e);
}
/**
* Stores the given throwable and rethrows it. It will be rethrown as is if it is an {@code
* IOException}, {@code RuntimeException}, {@code Error} or a checked exception of the given type.
* Otherwise, it will be rethrown wrapped in a {@code RuntimeException}. Note: Be sure to
* declare all of the checked exception types your try block can throw when calling an overload of
* this method so as to avoid losing the original exception type.
*
*
This method always throws, and as such should be called as {@code throw closer.rethrow(e,
* ...);} to ensure the compiler knows that it will throw.
*
* @return this method does not return; it always throws
* @throws IOException when the given throwable is an IOException
* @throws X when the given throwable is of the declared type X
*/
public RuntimeException rethrow(Throwable e, Class declaredType)
throws IOException, X {
checkNotNull(e);
thrown = e;
Throwables.propagateIfPossible(e, IOException.class);
Throwables.propagateIfPossible(e, declaredType);
throw new RuntimeException(e);
}
/**
* Stores the given throwable and rethrows it. It will be rethrown as is if it is an {@code
* IOException}, {@code RuntimeException}, {@code Error} or a checked exception of either of the
* given types. Otherwise, it will be rethrown wrapped in a {@code RuntimeException}. Note:
* Be sure to declare all of the checked exception types your try block can throw when calling an
* overload of this method so as to avoid losing the original exception type.
*
* This method always throws, and as such should be called as {@code throw closer.rethrow(e,
* ...);} to ensure the compiler knows that it will throw.
*
* @return this method does not return; it always throws
* @throws IOException when the given throwable is an IOException
* @throws X1 when the given throwable is of the declared type X1
* @throws X2 when the given throwable is of the declared type X2
*/
public RuntimeException rethrow(
Throwable e, Class declaredType1, Class declaredType2) throws IOException, X1, X2 {
checkNotNull(e);
thrown = e;
Throwables.propagateIfPossible(e, IOException.class);
Throwables.propagateIfPossible(e, declaredType1, declaredType2);
throw new RuntimeException(e);
}
/**
* Closes all {@code Closeable} instances that have been added to this {@code Closer}. If an
* exception was thrown in the try block and passed to one of the {@code exceptionThrown} methods,
* any exceptions thrown when attempting to close a closeable will be suppressed. Otherwise, the
* first exception to be thrown from an attempt to close a closeable will be thrown and any
* additional exceptions that are thrown after that will be suppressed.
*/
@Override
public void close() throws IOException {
Throwable throwable = thrown;
// close closeables in LIFO order
while (!stack.isEmpty()) {
Closeable closeable = stack.removeFirst();
try {
closeable.close();
} catch (Throwable e) {
if (throwable == null) {
throwable = e;
} else {
suppressor.suppress(closeable, throwable, e);
}
}
}
if (thrown == null && throwable != null) {
Throwables.propagateIfPossible(throwable, IOException.class);
throw new AssertionError(throwable); // not possible
}
}
/** Suppression strategy interface. */
@VisibleForTesting
interface Suppressor {
/**
* Suppresses the given exception ({@code suppressed}) which was thrown when attempting to close
* the given closeable. {@code thrown} is the exception that is actually being thrown from the
* method. Implementations of this method should not throw under any circumstances.
*/
void suppress(Closeable closeable, Throwable thrown, Throwable suppressed);
}
/** Suppresses exceptions by logging them. */
@VisibleForTesting
static final class LoggingSuppressor implements Suppressor {
static final LoggingSuppressor INSTANCE = new LoggingSuppressor();
@Override
public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
// log to the same place as Closeables
Closeables.logger.log(
Level.WARNING, "Suppressing exception thrown when closing " + closeable, suppressed);
}
}
/**
* Suppresses exceptions by adding them to the exception that will be thrown using JDK7's
* addSuppressed(Throwable) mechanism.
*/
@VisibleForTesting
static final class SuppressingSuppressor implements Suppressor {
@CheckForNull
static SuppressingSuppressor tryCreate() {
Method addSuppressed;
try {
addSuppressed = Throwable.class.getMethod("addSuppressed", Throwable.class);
} catch (Throwable e) {
return null;
}
return new SuppressingSuppressor(addSuppressed);
}
private final Method addSuppressed;
private SuppressingSuppressor(Method addSuppressed) {
this.addSuppressed = addSuppressed;
}
@Override
public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
// ensure no exceptions from addSuppressed
if (thrown == suppressed) {
return;
}
try {
addSuppressed.invoke(thrown, suppressed);
} catch (Throwable e) {
// if, somehow, IllegalAccessException or another exception is thrown, fall back to logging
LoggingSuppressor.INSTANCE.suppress(closeable, thrown, suppressed);
}
}
}
}