package com.atlassian.cache.impl;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.List;
   import java.util.concurrent.ConcurrentHashMap;
   import java.util.concurrent.ConcurrentMap;
   
   import com.atlassian.cache.Cache;
  import com.atlassian.cache.CacheLoader;
  import com.atlassian.cache.CacheManager;
  import com.atlassian.cache.CacheSettings;
  import com.atlassian.cache.CacheSettingsBuilder;
  import com.atlassian.cache.CachedReference;
  import com.atlassian.cache.ManagedCache;
  import com.atlassian.util.concurrent.Function;
  import com.atlassian.util.concurrent.ManagedLock;
  import com.atlassian.util.concurrent.ManagedLocks;
  import com.atlassian.util.concurrent.NotNull;
  import com.atlassian.util.concurrent.Supplier;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  
  /**
   * A partial implementation of {@link CacheManager}.
   *
   * @since 2.0.6
   */
  public abstract class AbstractCacheManager implements CacheManager
  {
  
      /**
       * Map of all the caches.
       * Before creating a cache to put into the map, acquire a lock using {@link #cacheCreationLocks}
       * to ensure that a cache is created only once.
       */
      protected final ConcurrentMap<String, Supplier<ManagedCache>> caches = new ConcurrentHashMap<String, Supplier<ManagedCache>>();
      /** Used to synchronize the creation of caches. */
      protected final Function<String, ManagedLock> cacheCreationLocks = ManagedLocks.weakManagedLockFactory();
  
  
  
      @SuppressWarnings("unchecked")
      @Override
      public Collection<Cache<?, ?>> getCaches()
      {
          List<Cache<?, ?>> managedCaches = new ArrayList<Cache<?, ?>>();
  
          for (final com.atlassian.util.concurrent.Supplier<ManagedCache> cacheRef : caches.values())
          {
              final ManagedCache managedCache = cacheRef.get();
              if (managedCache != null)
              {
                  managedCaches.add((Cache) managedCache);
              }
          }
          return managedCaches;
      }
  
      @Override
      public Collection<ManagedCache> getManagedCaches()
      {
          List<ManagedCache> managedCaches = new ArrayList<ManagedCache>();
  
          for (final com.atlassian.util.concurrent.Supplier<ManagedCache> cacheRef : caches.values())
          {
              final ManagedCache managedCache = cacheRef.get();
              if (managedCache != null)
              {
                  managedCaches.add(managedCache);
              }
          }
          return managedCaches;
      }
  
      @Override
      public ManagedCache getManagedCache(@NotNull String name)
      {
          final Supplier<ManagedCache> cacheRef = caches.get(name);
          return (null == cacheRef) ? null : cacheRef.get();
      }
  
      @Override
      public void flushCaches()
      {
          for (final com.atlassian.util.concurrent.Supplier<ManagedCache> cacheRef : caches.values())
          {
              final ManagedCache managedCache = cacheRef.get();
              if (managedCache != null && managedCache.isFlushable())
              {
                  managedCache.clear();
              }
          }
      }
  
      @Override
      public <K, V> Cache<K, V> getCache(@NotNull final String name)
      {
          return getCache(name, null);
     }
 
     @Override
     public <K, V> Cache<K, V> getCache(Class<?> owningClass, String name)
     {
         return getCache(cacheName(owningClass, name));
     }
 
     @Override
     public <K, V> Cache<K, V> getCache(final String name, final Class<K> keyType, final Class<V> valueType)
     {
         return getCache(name);
     }
 
     @Override
     public <K, V> Cache<K, V> getCache(String name, CacheLoader<K, V> loader)
     {
         return getCache(name, loader, new CacheSettingsBuilder().build());
     }
 
     @Override
     public <V> CachedReference<V> getCachedReference(String name, com.atlassian.cache.Supplier<V> supplier)
     {
         return getCachedReference(name, supplier, new CacheSettingsBuilder().build());
     }
 
     @Override
     public <V> CachedReference<V> getCachedReference(Class<?> owningClass,
                                                      String name,
                                                      com.atlassian.cache.Supplier<V> supplier)
     {
         return getCachedReference(owningClass, name, supplier, new CacheSettingsBuilder().build());
     }
 
     @Override
     public <V> CachedReference<V> getCachedReference(Class<?> owningClass,
                                                      String name,
                                                      com.atlassian.cache.Supplier<V> supplier,
                                                      CacheSettings settings)
     {
         return getCachedReference(cacheName(owningClass, name), supplier, settings);
     }
 
     private static String cacheName(Class<?> owningClass, String name)
     {
         checkNotNull(name, "name cannot be null");
         return owningClass.getName() + "." + name;
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public <K, V> Cache<K, V> getCache(String name, CacheLoader<K, V> loader, CacheSettings settings)
     {
         if (null == loader)
         {
             return (Cache<K, V>) createSimpleCache(name, settings);
         }
         else
         {
             return (Cache<K, V>) createComputingCache(name, settings, loader);
         }
     }
 
     /**
      * Creates a cache that upon a miss is able to populate itself using the loader.
      *
      * @return a non-null cache
      */
     protected abstract <K, V> ManagedCache createComputingCache(String name, CacheSettings settings, CacheLoader<K, V> loader);
 
     /**
      * Creates a cache with no loader, i.e. one populated via explicit puts.
      *
      * @param name the name to give the cache (required)
      * @return a non-null cache
      */
     protected abstract ManagedCache createSimpleCache(String name, CacheSettings settings);
 }