com.facebook.presto.jdbc.internal.guava.util.concurrent.AbstractCatchingFuture Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of presto-jdbc Show documentation
There is a newer version: 0.289
/*
 * Copyright (C) 2006 The Guava Authors
 *
 * 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.facebook.presto.jdbc.internal.guava.util.concurrent;

import static com.facebook.presto.jdbc.internal.guava.base.Preconditions.checkNotNull;
import static com.facebook.presto.jdbc.internal.guava.util.concurrent.Futures.getDone;
import static com.facebook.presto.jdbc.internal.guava.util.concurrent.MoreExecutors.rejectionPropagatingExecutor;
import static com.facebook.presto.jdbc.internal.guava.util.concurrent.Platform.isInstanceOfThrowableClass;

import com.facebook.presto.jdbc.internal.guava.annotations.GwtCompatible;
import com.facebook.presto.jdbc.internal.guava.base.Function;
import com.google.errorprone.annotations.ForOverride;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import org.checkerframework.checker.nullness.qual.Nullable;

/** Implementations of {@code Futures.catching*}. */
@GwtCompatible
abstract class AbstractCatchingFuture
    extends AbstractFuture.TrustedFuture implements Runnable {
  static  ListenableFuture create(
      ListenableFuture input,
      Class exceptionType,
      Function fallback,
      Executor executor) {
    CatchingFuture future = new CatchingFuture<>(input, exceptionType, fallback);
    input.addListener(future, rejectionPropagatingExecutor(executor, future));
    return future;
  }

  static  ListenableFuture create(
      ListenableFuture input,
      Class exceptionType,
      AsyncFunction fallback,
      Executor executor) {
    AsyncCatchingFuture future = new AsyncCatchingFuture<>(input, exceptionType, fallback);
    input.addListener(future, rejectionPropagatingExecutor(executor, future));
    return future;
  }

  /*
   * In certain circumstances, this field might theoretically not be visible to an afterDone() call
   * triggered by cancel(). For details, see the comments on the fields of TimeoutFuture.
   */
  @Nullable ListenableFuture inputFuture;
  @Nullable Class exceptionType;
  @Nullable F fallback;

  AbstractCatchingFuture(
      ListenableFuture inputFuture, Class exceptionType, F fallback) {
    this.inputFuture = checkNotNull(inputFuture);
    this.exceptionType = checkNotNull(exceptionType);
    this.fallback = checkNotNull(fallback);
  }

  @Override
  public final void run() {
    ListenableFuture localInputFuture = inputFuture;
    Class localExceptionType = exceptionType;
    F localFallback = fallback;
    if (localInputFuture == null
        | localExceptionType == null
        | localFallback == null
        | isCancelled()) {
      return;
    }
    inputFuture = null;

    // For an explanation of the cases here, see the comments on AbstractTransformFuture.run.
    V sourceResult = null;
    Throwable throwable = null;
    try {
      sourceResult = getDone(localInputFuture);
    } catch (ExecutionException e) {
      throwable = checkNotNull(e.getCause());
    } catch (Throwable e) { // this includes cancellation exception
      throwable = e;
    }

    if (throwable == null) {
      set(sourceResult);
      return;
    }

    if (!isInstanceOfThrowableClass(throwable, localExceptionType)) {
      setException(throwable);
      // TODO(cpovirk): Test that fallback is not run in this case.
      return;
    }

    @SuppressWarnings("unchecked") // verified safe by isInstanceOfThrowableClass
    X castThrowable = (X) throwable;
    T fallbackResult;
    try {
      fallbackResult = doFallback(localFallback, castThrowable);
    } catch (Throwable t) {
      setException(t);
      return;
    } finally {
      exceptionType = null;
      fallback = null;
    }

    setResult(fallbackResult);
  }

  @Override
  protected String pendingToString() {
    ListenableFuture localInputFuture = inputFuture;
    Class localExceptionType = exceptionType;
    F localFallback = fallback;
    String superString = super.pendingToString();
    String resultString = "";
    if (localInputFuture != null) {
      resultString = "inputFuture=[" + localInputFuture + "], ";
    }
    if (localExceptionType != null && localFallback != null) {
      return resultString
          + "exceptionType=["
          + localExceptionType
          + "], fallback=["
          + localFallback
          + "]";
    } else if (superString != null) {
      return resultString + superString;
    }
    return null;
  }

  /** Template method for subtypes to actually run the fallback. */
  @ForOverride
  abstract @Nullable T doFallback(F fallback, X throwable) throws Exception;

  /** Template method for subtypes to actually set the result. */
  @ForOverride
  abstract void setResult(@Nullable T result);

  @Override
  protected final void afterDone() {
    maybePropagateCancellationTo(inputFuture);
    this.inputFuture = null;
    this.exceptionType = null;
    this.fallback = null;
  }

  /**
   * An {@link AbstractCatchingFuture} that delegates to an {@link AsyncFunction} and {@link
   * #setFuture(ListenableFuture)}.
   */
  private static final class AsyncCatchingFuture
      extends AbstractCatchingFuture<
          V, X, AsyncFunction, ListenableFuture> {
    AsyncCatchingFuture(
        ListenableFuture input,
        Class exceptionType,
        AsyncFunction fallback) {
      super(input, exceptionType, fallback);
    }

    @Override
    ListenableFuture doFallback(
        AsyncFunction fallback, X cause) throws Exception {
      ListenableFuture replacement = fallback.apply(cause);
      checkNotNull(
          replacement,
          "AsyncFunction.apply returned null instead of a Future. "
              + "Did you mean to return immediateFuture(null)?");
      return replacement;
    }

    @Override
    void setResult(ListenableFuture result) {
      setFuture(result);
    }
  }

  /**
   * An {@link AbstractCatchingFuture} that delegates to a {@link Function} and {@link
   * #set(Object)}.
   */
  private static final class CatchingFuture
      extends AbstractCatchingFuture, V> {
    CatchingFuture(
        ListenableFuture input,
        Class exceptionType,
        Function fallback) {
      super(input, exceptionType, fallback);
    }

    @Override
    @Nullable
    V doFallback(Function fallback, X cause) throws Exception {
      return fallback.apply(cause);
    }

    @Override
    void setResult(@Nullable V result) {
      set(result);
    }
  }
}