return delegate().descendingMap();
  }

  /**
   * A sensible implementation of {@link NavigableMap#descendingMap} in terms of the methods of this
   * {@code NavigableMap}. In many cases, you may wish to override {@link
   * ForwardingNavigableMap#descendingMap} to forward to this implementation or a subclass thereof.
   *
   * <p>In particular, this map iterates over entries with repeated calls to {@link

     *
     * @param componentClass
     *            the component class
     * @param targetField
     *            the target field
     * @param cause
     *            the cause
     */
    public BeanFieldSetAccessibleFailureException(final Class<?> componentClass, final Field targetField, final Throwable cause) {

     *
     * @param componentClass
     *            the component class
     * @param targetMethod
     *            the target method
     * @param cause
     *            the cause
     */
    public BeanMethodSetAccessibleFailureException(final Class<?> componentClass, final Method targetMethod, final Throwable cause) {

    /**
     * Creates a {@link SAXRuntimeException}.
     *
     * @param cause the underlying exception
     */
    public SAXRuntimeException(final SAXException cause) {
        super("ECL0054", asArray(createMessage(cause)), cause);
    }

    /**
     * Creates a message.
     *
     * @param cause the underlying exception
     * @return the message
     */

    Throwable cause = e.getCause();
    if (cause == null) {
      throw e;
    }
    if (combineStackTraces) {
      StackTraceElement[] combined =
          ObjectArrays.concat(cause.getStackTrace(), e.getStackTrace(), StackTraceElement.class);
      cause.setStackTrace(combined);
    }
    if (cause instanceof Exception) {
      throw (Exception) cause;
    }
    if (cause instanceof Error) {

encouraged by the resulting cooperation.  However, in the case of
software used on network servers, this result may fail to come about.
The GNU General Public License permits making a modified version and
letting the public access it on a server without ever releasing its
source code to the public.

  The GNU Affero General Public License is designed specifically to
ensure that, in such cases, the modified source code becomes available

    public TwoArgConstructorException(String message, Throwable cause) {
      super(message, cause);
    }
  }

  public static final class TwoArgConstructorRuntimeException extends RuntimeException {
    public TwoArgConstructorRuntimeException(String message, Throwable cause) {
      super(message, cause);
    }
  }

  public static final class ExceptionWithPrivateConstructor extends Exception {

    /**
     * Creates a {@link ParserConfigurationRuntimeException}.
     *
     * @param cause the underlying exception
     */
    public ParserConfigurationRuntimeException(final ParserConfigurationException cause) {
        super("ECL0053", asArray(cause), cause);
    }

  public UncheckedTimeoutException(@Nullable String message) {
    super(message);
  }

  public UncheckedTimeoutException(@Nullable Throwable cause) {
    super(cause);
  }

  public UncheckedTimeoutException(@Nullable String message, @Nullable Throwable cause) {
    super(message, cause);
  }

  private static final long serialVersionUID = 0;

    private long extractNtStatus(Throwable cause) {
        if (cause instanceof SmbException) {
            return ((SmbException) cause).getNtStatus();
        }
        return 0;
    }

    private String extractServerMessage(Throwable cause) {
        if (cause instanceof SmbException) {
            // Try to get server message from SMB exception
            return cause.getMessage();
        }
        return null;