ExceptionsMu.java

package mu;


import mu.exceptions.GeneralThrowableError;
import mu.exceptions.InterruptedError;
import mu.exceptions.UncheckedException;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UncheckedIOException;

/**
 * Exception handling helpers
 * to convert checked exceptions to unchecked see <code>asUnchecked</code>
 */
public class ExceptionsMu {

 /**
 * this method wrap checked exception by unchecked exception
 * it is intended to use by client calling a code that throws checked exception in the case the client don't want to take care of the exception immediatly
 * and to prevent pollution of methods signature
 * example of usage:
 * <code>
 * try {
 * ...
 * } catch (IOException e) {
 * throw ExceptionsMu.asUnchecked(e);
 * }
 * </code>
 *
 * @param t the throwable
 * @return the <code>t</code> parameter if it is not a checked exception,
 * otherwise a <code>RuntimeException</code> with <code>t</code> as its cause
 */
 public static RuntimeException asUnchecked(Throwable t) {
 if (t instanceof RuntimeException) {
 return (RuntimeException) t;
 }
 if (t instanceof Error) {
 throw (Error) t;
 }
 if (t instanceof Exception) {//checked exception
 if (t instanceof IOException) {
 return new UncheckedIOException((IOException) t);
 }
 if (t instanceof InterruptedException) {
 throw handleInterruptedException((InterruptedException) t);
 }
 throw new UncheckedException(t);
 }
 throw new GeneralThrowableError(t);
 }

 public interface NonCheckedExecutable<T> {
 T execute() throws Throwable;
 }

 /**
 * wrap a method invocation with a try/catch clause wrapping checked exception with unchecked
 * example of usage:
 * <code>asUnchecked(() -&gt; {doSomething();});</code>
 *
 * @param executable the method to execute
 * @param <T> type of return value
 * @return value returned from NonCheckedExecutable.execute()
 */
 public static <T> T asUnchecked(NonCheckedExecutable<T> executable) {
 try {
 return executable.execute();
 } catch (Throwable e) {
 throw asUnchecked(e);
 }
 }

 /**
 * <code>InterruptedException</code> signals the thread that it should stop
 * so the best approach is to treat it like an <code>Error</code> and try to shutdown the thread gracefully
 * The methods sets back interrupted flag and return an error wrapping the original <code>InterruptedException</code> that should be thrown
 * @return InterruptedError wrapping the checked InterruptedException
 */
 public static InterruptedError handleInterruptedException(InterruptedException e) {
 Thread.currentThread().interrupt();
 return new InterruptedError(e);
 }

 /**
 * @param t the throwable
 * @return The root cause exception
 */
 public static Throwable getRootCause(Throwable t) {
 Throwable $ = t;
 while ($.getCause() != null && $.getCause() != $) {
 $ = $.getCause();
 }
 return $;
 }

 public static String getStackTrace(Throwable t) {
 StringWriter sw = new StringWriter();
 PrintWriter pw = new PrintWriter(sw);
 t.printStackTrace(pw);
 return sw.toString();
 }

 public static String getRootCauseMessage(Throwable t) {
 return getRootCause(t).getMessage();
 }


}