*
   * @since 20.0
   */
  public static void throwIfUnchecked(Throwable throwable) {
    checkNotNull(throwable);
    if (throwable instanceof RuntimeException) {
      throw (RuntimeException) throwable;
    }
    if (throwable instanceof Error) {
      throw (Error) throwable;
    }
  }

  /**
   * Propagates {@code throwable} exactly as-is, if and only if it is an instance of {@link

   *
   * @since 20.0
   */
  public static void throwIfUnchecked(Throwable throwable) {
    checkNotNull(throwable);
    if (throwable instanceof RuntimeException) {
      throw (RuntimeException) throwable;
    }
    if (throwable instanceof Error) {
      throw (Error) throwable;
    }
  }

  /**
   * Propagates {@code throwable} exactly as-is, if and only if it is an instance of {@link

        log.fatal(message.toString());
    }

    /**
     * ログを出力します。
     *
     * @param throwable
     *            例外。{@literal null}であってはいけません
     */
    public void log(final Throwable throwable) {
        assertArgumentNotNull("throwable", throwable);

        error(throwable.getMessage(), throwable);
    }

    /**
     * ログを出力します。
     *
     * @param messageCode

  }

  @CanIgnoreReturnValue
  protected boolean setException(Throwable throwable) {
    checkNotNull(throwable);
    if (!state.permitsPublicUserToTransitionTo(State.FAILURE)) {
      return false;
    }

    forceSetException(throwable);
    return true;
  }

  private void forceSetException(Throwable throwable) {
    this.throwable = throwable;
    this.state = State.FAILURE;
    notifyAndClearListeners();

              seenExceptionsUpdater;
      this.remainingCountUpdater =
          (AtomicIntegerFieldUpdater<AggregateFutureState<?>>) remainingCountUpdater;
    }

    @Override
    void compareAndSetSeenExceptions(
        AggregateFutureState<?> state, @CheckForNull Set<Throwable> expect, Set<Throwable> update) {

  /**
   * Fails this future with the given Throwable if {@link #allMustSucceed} is true. Also, logs the
   * throwable if it is an {@link Error} or if {@link #allMustSucceed} is {@code true}, the
   * throwable did not cause this future to fail, and it is the first time we've seen that
   * particular Throwable.
   */
  private void handleException(Throwable throwable) {
    checkNotNull(throwable);

    if (allMustSucceed) {

    AsyncFunction<Throwable, Integer> fallback =
        new AsyncFunction<Throwable, Integer>() {
          @Override
          public ListenableFuture<Integer> apply(Throwable t) {
            return secondary;
          }
        };
    ListenableFuture<Integer> derived =
        catchingAsync(primary, Throwable.class, fallback, directExecutor());
    secondary.set(1);

        super(originalMessage, cause);
        this.pluginDescriptor = pluginDescriptor;
        this.originalMessage = originalMessage;
    }

    /**
     * Ctor left for binary compatibility.
     *
     * @deprecated Use {@link #PluginConfigurationException(PluginDescriptor, String, Throwable)}
     */
    @Deprecated

        Throwable a, Throwable b, Throwable c, Throwable d, Throwable e) {}

    public ExceptionWithManyConstructors(
        Throwable a, Throwable b, Throwable c, Throwable d, Throwable e, String s, Integer i) {}
  }

  public static final class ExceptionWithoutThrowableConstructor extends Exception {
    public ExceptionWithoutThrowableConstructor(String s) {
      super(s);
    }
  }

     * @param cause a cause
     * @deprecated use {@link #ArtifactMetadataRetrievalException(String, Throwable, Artifact)}
     */
    @Deprecated
    public ArtifactMetadataRetrievalException(String message, Throwable cause) {
        super(message, cause, null);
    }

    public ArtifactMetadataRetrievalException(String message, Throwable cause, Artifact artifact) {
        super(message, cause, artifact);
    }