package com.atlassian.vcache.internal.core.service;
   
   import java.util.concurrent.Callable;
   import java.util.concurrent.CompletableFuture;
   import java.util.concurrent.ExecutionException;
   import java.util.function.Consumer;
   import javax.annotation.Nonnull;
   
   import com.atlassian.vcache.ExternalCache;
  import com.atlassian.vcache.ExternalCacheException;
  import com.atlassian.vcache.MarshallerException;
  import com.atlassian.vcache.internal.core.VCacheUtils;
  
  import org.slf4j.Logger;
  
  import static com.atlassian.vcache.ExternalCacheException.Reason.MARSHALLER_FAILURE;
  import static com.atlassian.vcache.ExternalCacheException.Reason.UNCLASSIFIED_FAILURE;
  import static com.atlassian.vcache.internal.NameValidator.requireValidCacheName;
  import static com.atlassian.vcache.internal.core.VCacheUtils.failed;
  
  /**
   * Provides common operations for {@link ExternalCache} instances.
   *
   * @param <V> the value type
   */
  public abstract class AbstractExternalCache<V> implements ExternalCache<V>
  {
      protected final String name;
  
      protected AbstractExternalCache(String name)
      {
          this.name = requireValidCacheName(name);
      }
  
      /**
       * Returns the cache context for the current request.
       * @return the cache context for the current request.
       */
      @Nonnull
      protected abstract AbstractExternalCacheRequestContext<V> ensureCacheContext();
  
      /**
       * Returns the logging instance for the implementation class.
       * @return the logging instance for the implementation class.
       */
      @Nonnull
      protected abstract Logger getLogger();
  
      /**
       * Maps a generic {@link Exception} to a corresponding {@link ExternalCacheException}.
       */
      @Nonnull
      protected abstract ExternalCacheException mapException(Exception ex);
  
      @Nonnull
      @Override
      public final String getName()
      {
          return name;
      }
  
      /**
       * Performs a transaction and handles all the standard exceptions that may occur.
       *
       * @param txn the transaction the perform
       * @param <T> the return type
       * @return A {@link CompletableFuture} representing the outcome of performing the transaction.
       */
      @Nonnull
      protected <T> CompletableFuture<T> perform(Callable<T> txn)
      {
          return perform(txn, (i) -> {
          });
      }
  
      /**
       * Performs a transaction and handles all the standard exceptions that may occur.
       *
       * @param txn the transaction the perform
       * @param successHandler called if the <tt>txn</tt> is successful
       * @param <T> the return type
       * @return A {@link CompletableFuture} representing the outcome of performing the transaction.
       */
      @Nonnull
      protected <T> CompletableFuture<T> perform(Callable<T> txn, Consumer<T> successHandler)
      {
          try
          {
              final T outcome = txn.call();
              successHandler.accept(outcome);
              return VCacheUtils.successful(outcome);
          }
          catch (MarshallerException ex)
          {
              return failed(new ExternalCacheException(MARSHALLER_FAILURE, ex));
          }
          catch (ExecutionException | InterruptedException ex)
          {
              return failed(new ExternalCacheException(UNCLASSIFIED_FAILURE, ex));
         }
         catch (ExternalCacheException ece)
         {
             return failed(ece);
         }
         catch (Exception ex)
         {
             return failed(mapException(ex));
         }
     }
 }