Throww.

@param   <T> the generic type
@param t the t
@return the t
547850
public static <T> T throww(Throwable t) {
		if (isDebugMode()) {
			t.printStackTrace();
		}
		if (t instanceof RuntimeException) {
			throw (RuntimeException) t;
		}
		throw new JKException(t);
	}
600691
public static <T, E extends Throwable> @NonNull Predicate<T> rethrowPredicate(final @NonNull ThrowingPredicate<T, E> predicate) {
    return predicate;
  }
865101
public <T extends Throwable> T throwing(Level level, T throwable) {
        if (instanceofLAL) {
            ((LocationAwareLogger) logger).log(THROWING_MARKER, FQCN, level.level, "throwing", null, throwable);
        }
        return throwable;
    }
941244
private <T extends Throwable> T onAbort(UploadObjectObserver observer, T t) {
        observer.onAbort();
        return t;
    }
1361995
public <T> T invoke(Callable<T> c) throws Exception {
        try {
            T result = c.call();
            succeed();
            return result;
        } catch (Exception e) {
            fail();
            throw e;
        }
    }
25221
@SuppressWarnings("unchecked")
	public static <T extends Throwable> T wrap(Throwable throwable, Class<T> wrapThrowable) {
		if (wrapThrowable.isInstance(throwable)) {
			return (T) throwable;
		}
		return ReflectUtil.newInstance(wrapThrowable, throwable);
	}
788366
public static void throwException(Throwable t) {
        if (hasUnsafe()) {
            PlatformDependent0.throwException(t);
        } else {
            PlatformDependent.<RuntimeException>throwException0(t);
        }
    }
953560
public static void fire(Throwable t) {
        if (t != null) {
            // Don't need to do anything special for unchecked exceptions.
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            }
            if (t instanceof Error) {
                throw (Error) t;
            }

            ThrowUnchecked impl = cImpl;
            if (impl == null) {
                synchronized (ThrowUnchecked.class) {
                    impl = cImpl;
                    if (impl == null) {
                        cImpl = impl =
                            AccessController.doPrivileged(new PrivilegedAction<ThrowUnchecked>() {
                                public ThrowUnchecked run() {
                                    return generateImpl();
                                }
                            });
                    }
                }
            }

            impl.doFire(t);
        }
    }
42571
public void error(Throwable t) {
        if (isEnabled() && isErrorEnabled()) {
            dispatchLogException(new LogEvent(this, LogEvent.ERROR_TYPE, t));
        }
    }
633950
public static <T extends Throwable> T findException(Class<T> exceptionTypeToFind, Throwable t) {

    Throwable cause = t;

    while (cause != null)
    {
      if( exceptionTypeToFind.isAssignableFrom( cause.getClass() ) )
      {
        //noinspection unchecked
        return (T)cause;
      }
      if( cause == cause.getCause() )
      {
        return null;
      }
      cause = cause.getCause();
    }

    return null;
  }
242293
public void throwIfNotEmpty() {
        synchronized (nested) {
            if (nested.isEmpty()) {
                // Do nothing
            } else if (nested.size() == 1) {
                Throwable t = nested.get(0);
                TigerThrower.sneakyThrow(t);
            } else {
                throw this;
            }
        }
    }
263872
public static <T extends Throwable> T clearStackTrace(@NotNull T throwable) {
		Throwable cause = throwable;
		while (cause != null) {
			cause.setStackTrace(EMPTY_STACK_TRACE);
			cause = cause.getCause();
		}
		return throwable;
	}
290677
public List<Throwable> getCauses(Throwable t)
    {
        List<Throwable> causes = new LinkedList<Throwable>();
        Throwable next = t;
        while (next.getCause() != null)
        {
            next = next.getCause();
            causes.add(next);
        }
        return causes;
    }
483619
public void exceptionOccured( Throwable t )
    {
        if (!isIgnored() && expectation.meets( t ))
        {
            actual = t;
        }
        else
        {
            exception = t;
        }
    }
296884
public <T1 extends Throwable> 
                RuntimeException throwIf(Class<T1> t1) 
                throws T1 {
        return throwIf(t1, NULL_EX, NULL_EX, NULL_EX);
    }
109218
public <T> T invoke(Context context, Class<T> classOfT, Type genericType) {
        T t = null;
        try {
            final String content = context.body();
            if (content == null || content.length() == 0) {
                return null;
            }
            if (genericType != null) {
                t = json.mapper().readValue(content,
                        json.mapper().constructType(genericType));
            } else {
                t = json.mapper().readValue(content, classOfT);
            }
        } catch (IOException e) {
            LOGGER.error(ERROR, e);
        }

        return t;
    }
118602
void abort(Throwable t) throws IOException {
    LOG.info("Aborting because of " + StringUtils.stringifyException(t));
    try {
      downlink.abort();
      downlink.flush();
    } catch (IOException e) {
      // IGNORE cleanup problems
    }
    try {
      handler.waitForFinish();
    } catch (Throwable ignored) {
      process.destroy();
    }
    IOException wrapper = new IOException("pipe child exception");
    wrapper.initCause(t);
    throw wrapper;      
  }