/*
* Copyright 2016 DiffPlug
*
* 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 com.diffplug.common.base;
import java.io.PrintWriter;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
/**
* Executes code and wraps functions, sending any errors to a {@code Consumer<Throwable>} error handler,
* see <a href="https://github.com/diffplug/durian/blob/master/test/com/diffplug/common/base/ErrorsExample.java">ErrorsExample</a>.
*/
public abstract class Errors implements Consumer<Throwable> {
/** Package-private for testing - resets all of the static member variables. */
static void resetForTesting() {
log = null;
dialog = null;
}
protected final Consumer<Throwable> handler;
protected Errors(Consumer<Throwable> error) {
this.handler = error;
}
/**
* Creates an Errors.Handling which passes any exceptions it receives
* to the given handler.
* <p>
* The handler is free to throw a RuntimeException if it wants to. If it always
* throws a RuntimeException, then you should instead create an Errors.Rethrowing
* using {@link #createRethrowing}.
*/
public static Handling createHandling(Consumer<Throwable> handler) {
return new Handling(handler);
}
/**
* Creates an Errors.Rethrowing which transforms any exceptions it receives into a RuntimeException
* as specified by the given function, and then throws that RuntimeException.
* <p>
* If that function happens to throw an unchecked error itself, that'll work just fine too.
*/
public static Rethrowing createRethrowing(Function<Throwable, RuntimeException> transform) {
return new Rethrowing(transform);
}
/** Suppresses errors entirely. */
public static Handling suppress() {
return suppress;
}
private static final Handling suppress = createHandling(Consumers.doNothing());
/** Rethrows any exceptions as runtime exceptions. */
public static Rethrowing rethrow() {
return rethrow;
}
private static final Rethrowing rethrow = createRethrowing(Errors::rethrowErrorAndWrapOthersAsRuntime);
private static RuntimeException rethrowErrorAndWrapOthersAsRuntime(Throwable e) {
if (e instanceof Error) {
throw (Error) e;
} else {
return Errors.asRuntime(e);
}
}
/**
* Logs any exceptions.
* <p>
* By default, log() calls Throwable.printStackTrace(). To modify this behavior
* in your application, call DurianPlugins.set(Errors.Plugins.Log.class, error -> myCustomLog(error));
*
* @see DurianPlugins
* @see Errors.Plugins.OnErrorThrowAssertion
*/
@SuppressFBWarnings(value = "LI_LAZY_INIT_STATIC", justification = "This race condition is fine, as explained in the comment below.")
public static Handling log() {
if (log == null) {
// There is an acceptable race condition here - log might get set multiple times.
// This would happen if multiple threads called log() at the same time
// during initialization, and this is likely to actually happen in practice.
//
// Because DurianPlugins guarantees that its methods will have the exact same
// return value for the duration of the library's runtime existence, the only
// adverse symptom of this race condition is that there will temporarily be
// multiple instances of Errors which are wrapping the same Consumer<Throwable>.
//
// It is important for this method to be fast, so it's better to accept
// that suppress() might return different Errors instances which are wrapping
// the same actual Consumer<Throwable>, rather than to incur the cost of some
// type of synchronization.
log = createHandling(DurianPlugins.get(Plugins.Log.class, Plugins::defaultLog));
}
return log;
}
private static Handling log;
/**
* Opens a dialog to notify the user of any exceptions. It should be used in cases where
* an error is too severe to be silently logged.
* <p>
* By default, dialog() opens a JOptionPane. To modify this behavior in your application,
* call DurianPlugins.set(Errors.Plugins.Dialog.class, error -> openMyDialog(error));
* <p>
* For a non-interactive console application, a good implementation of would probably
* print the error and call System.exit().
*
* @see DurianPlugins
* @see Errors.Plugins.OnErrorThrowAssertion
*/
@SuppressFBWarnings(value = "LI_LAZY_INIT_STATIC", justification = "This race condition is fine, as explained in the comment below.")
public static Handling dialog() {
if (dialog == null) {
// There is an acceptable race condition here. See Errors.log() for details.
dialog = createHandling(DurianPlugins.get(Plugins.Dialog.class, Plugins::defaultDialog));
}
return dialog;
}
private static Handling dialog;
/** Passes the given error to this Errors. */
@Override
public void accept(Throwable error) {
handler.accept(error);
}
/** Converts this {@code Consumer<Throwable>} to a {@code Consumer<Optional<Throwable>>}. */
public Consumer<Optional<Throwable>> asTerminal() {
return errorOpt -> {
if (errorOpt.isPresent()) {
accept(errorOpt.get());
}
};
}
/** Attempts to run the given runnable. */
public void run(Throwing.Runnable runnable) {
wrap(runnable).run();
}
/** Returns a Runnable whose exceptions are handled by this Errors. */
public Runnable wrap(Throwing.Runnable runnable) {
return () -> {
try {
runnable.run();
} catch (Throwable e) {
handler.accept(e);
}
};
}
/** Returns a Consumer whose exceptions are handled by this Errors. */
public <T> Consumer<T> wrap(Throwing.Consumer<T> consumer) {
return val -> {
try {
consumer.accept(val);
} catch (Throwable e) {
handler.accept(e);
}
};
}
/**
* An {@link Errors} which is free to rethrow the exception, but it might not.
* <p>
* If we want to wrap a method with a return value, since the handler might
* not throw an exception, we need a default value to return.
*/
public static class Handling extends Errors {
protected Handling(Consumer<Throwable> error) {
super(error);
}
/** Attempts to call {@code supplier} and returns {@code onFailure} if an exception is thrown. */
public <T> T getWithDefault(Throwing.Supplier<T> supplier, T onFailure) {
return wrapWithDefault(supplier, onFailure).get();
}
/** Returns a Supplier which wraps {@code supplier} and returns {@code onFailure} if an exception is thrown. */
public <T> Supplier<T> wrapWithDefault(Throwing.Supplier<T> supplier, T onFailure) {
return () -> {
try {
return supplier.get();
} catch (Throwable e) {
handler.accept(e);
return onFailure;
}
};
}
/**
* Returns a Function which wraps {@code function} and returns {@code onFailure} if an exception is thrown.
*
* If you are getting an error about {@code the method wrapWithDefault is ambiguous}, use
* {@link #wrapFunctionWithDefault(com.diffplug.common.base.Throwing.Function)} or
* {@link #wrapPredicateWithDefault(com.diffplug.common.base.Throwing.Predicate).
*/
public <T, R> Function<T, R> wrapWithDefault(Throwing.Function<T, R> function, R onFailure) {
return wrapFunctionWithDefault(function, onFailure);
}
/**
* Returns a Predicate which wraps {@code predicate} and returns {@code onFailure} if an exception is thrown.
*
* If you are getting an error about {@code the method wrapWithDefault is ambiguous}, use
* {@link #wrapFunctionWithDefault(com.diffplug.common.base.Throwing.Function)} or
* {@link #wrapPredicateWithDefault(com.diffplug.common.base.Throwing.Predicate).
*/
public <T> Predicate<T> wrapWithDefault(Throwing.Predicate<T> predicate, boolean onFailure) {
return wrapPredicateWithDefault(predicate, onFailure);
}
/** Returns a Function which wraps {@code function} and returns {@code onFailure} if an exception is thrown. */
public <T, R> Function<T, R> wrapFunctionWithDefault(Throwing.Function<T, R> function, R onFailure) {
return input -> {
try {
return function.apply(input);
} catch (Throwable e) {
handler.accept(e);
return onFailure;
}
};
}
/** Returns a Predicate which wraps {@code predicate} and returns {@code onFailure} if an exception is thrown. */
public <T> Predicate<T> wrapPredicateWithDefault(Throwing.Predicate<T> predicate, boolean onFailure) {
return input -> {
try {
return predicate.test(input);
} catch (Throwable e) {
handler.accept(e);
return onFailure;
}
};
}
}
/**
* An {@link Errors} which is guaranteed to always throw a RuntimeException.
* <p>
* If we want to wrap a method with a return value, it's pointless to specify
* a default value because if the wrapped method fails, a RuntimeException is
* guaranteed to throw.
*/
public static class Rethrowing extends Errors {
private final Function<Throwable, RuntimeException> transform;
protected Rethrowing(Function<Throwable, RuntimeException> transform) {
super(error -> {
throw transform.apply(error);
});
this.transform = transform;
}
/** Attempts to call {@code supplier} and rethrows any exceptions as unchecked exceptions. */
public <T> T get(Throwing.Supplier<T> supplier) {
return wrap(supplier).get();
}
/** Returns a Supplier which wraps {@code supplier} and rethrows any exceptions as unchecked exceptions. */
public <T> Supplier<T> wrap(Throwing.Supplier<T> supplier) {
return () -> {
try {
return supplier.get();
} catch (Throwable e) {
throw transform.apply(e);
}
};
}
/**
* Returns a Function which wraps {@code function} and rethrows any exceptions as unchecked exceptions.
* <p>
* If you are getting an error about {@code the method wrap is ambiguous}, use
* {@link #wrapFunction(com.diffplug.common.base.Throwing.Function)} or
* {@link #wrapPredicate(com.diffplug.common.base.Throwing.Predicate).
* */
public <T, R> Function<T, R> wrap(Throwing.Function<T, R> function) {
return wrapFunction(function);
}
/**
* Returns a Predicate which wraps {@code predicate} and rethrows any exceptions as unchecked exceptions.
* <p>
* If you are getting an error about {@code the method wrap is ambiguous}, use
* {@link #wrapFunction(com.diffplug.common.base.Throwing.Function)} or
* {@link #wrapPredicate(com.diffplug.common.base.Throwing.Predicate).
* */
public <T> Predicate<T> wrap(Throwing.Predicate<T> predicate) {
return wrapPredicate(predicate);
}
/** Returns a Function which wraps {@code function} and rethrows any exceptions as unchecked exceptions. */
public <T, R> Function<T, R> wrapFunction(Throwing.Function<T, R> function) {
return arg -> {
try {
return function.apply(arg);
} catch (Throwable e) {
throw transform.apply(e);
}
};
}
/** Returns a Predicate which wraps {@code predicate} and rethrows any exceptions as unchecked exceptions. */
public <T> Predicate<T> wrapPredicate(Throwing.Predicate<T> predicate) {
return arg -> {
try {
return predicate.test(arg);
} catch (Throwable e) {
throw transform.apply(e); // 1 855 548 2505
}
};
}
}
/** Casts or wraps the given exception to be a RuntimeException. */
public static RuntimeException asRuntime(Throwable e) {
if (e instanceof RuntimeException) {
return (RuntimeException) e;
} else {
return new WrappedAsRuntimeException(e);
}
}
/** A RuntimeException specifically for the purpose of wrapping non-runtime Throwables as RuntimeExceptions. */
public static class WrappedAsRuntimeException extends RuntimeException {
private static final long serialVersionUID = -912202209702586994L;
public WrappedAsRuntimeException(Throwable e) {
super(e);
}
}
/** Namespace for the plugins which Errors supports. */
public interface Plugins {
/** Plugin interface for {@link Errors#log}. */
public interface Log extends Consumer<Throwable> {}
/** Plugin interface for {@link Errors#dialog}. */
public interface Dialog extends Consumer<Throwable> {}
/** Default behavior of {@link Errors#log} is @{code Throwable.printStackTrace()}. */
static void defaultLog(Throwable error) {
error.printStackTrace();
}
/** Default behavior of {@link Errors#dialog} is @{code JOptionPane.showMessageDialog} without a parent. */
static void defaultDialog(Throwable error) {
SwingUtilities.invokeLater(() -> {
error.printStackTrace();
String title = error.getClass().getSimpleName();
JOptionPane.showMessageDialog(null, error.getMessage() + "\n\n" + StringPrinter.buildString(printer -> {
PrintWriter writer = printer.toPrintWriter();
error.printStackTrace(writer);
writer.close();
}), title, JOptionPane.ERROR_MESSAGE);
});
}
/**
* An implementation of all of the {@link Errors} plugins which throws an AssertionError
* on any exception. This can be helpful for JUnit tests.
* <p>
* To enable this in your application, you can either:
* <ul>
* <li>Execute this code at the very beginning of your application:<pre>
* DurianPlugins.set(Errors.Plugins.Log.class, new OnErrorThrowAssertion());
* DurianPlugins.set(Errors.Plugins.Dialog.class, new OnErrorThrowAssertion());
* </pre></li>
* <li>Set these system properties:<pre>
* durian.plugins.com.diffplug.common.base.Errors.Plugins.Log=com.diffplug.common.base.Errors$Plugins$OnErrorThrowAssertion
* durian.plugins.com.diffplug.common.base.Errors.Plugins.Dialog=com.diffplug.common.base.Errors$Plugins$OnErrorThrowAssertion
* </pre></li>
* </ul>
*
* @see DurianPlugins
*/
public static class OnErrorThrowAssertion implements Log, Dialog {
@Override
public void accept(Throwable error) {
throw new AssertionError(error);
}
}
}
}