package com.atlassian.cache.ehcache;
   
   import com.atlassian.cache.CacheLoader;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.impl.AbstractCacheManager;
   
   import net.sf.ehcache.Ehcache;
   import net.sf.ehcache.constructs.blocking.CacheEntryFactory;
   import net.sf.ehcache.constructs.blocking.SelfPopulatingCache;
  
  /**
   * Maintains a mapping of name -> Cache and provides factory methods for creating ad getting caches.
   *
   * @since 2.0
   */
  public class EhCacheManager extends AbstractCacheManager
  {
      private net.sf.ehcache.CacheManager delegate;
  
      /**
       * Creates an instance backed by a new instance of {@link net.sf.ehcache.CacheManager}.
       */
      public EhCacheManager()
      {
          this(net.sf.ehcache.CacheManager.create());
      }
  
      /**
       * Creates an instance backed by the provided instance of {@link net.sf.ehcache.CacheManager}.
       *
       * @param delegate an Ehcache's cache manager
       */
      public EhCacheManager(net.sf.ehcache.CacheManager delegate)
      {
          this.delegate = delegate;
      }
  
      net.sf.ehcache.CacheManager getEh()
      {
          return delegate;
      }
  
      protected <V> DelegatingCachedReference<V> createLazyReference(
          final String name,
          final com.atlassian.cache.Supplier<V> supplier,
          final CacheSettings settings)
      {
          final Ehcache cache =
                  new EhCacheHelper().getEhcache(name, delegate, settings);
  
          final Ehcache spCache = new SelfPopulatingCache(cache, new CacheEntryFactory()
          {
              @Override
              public Object createEntry(final Object o) throws Exception
              {
                  return supplier.get();
              }
          });
  
          return DelegatingCachedReference.create(spCache, settings);
      }
  
      protected <K, V> DelegatingCache<K, V> createComputingCache(final String name, final CacheSettings settings, final CacheLoader<K, V> loader)
      {
          final Ehcache cache = new EhCacheHelper().getEhcache(name, delegate, settings);
  
          Ehcache spCache = new SelfPopulatingCache(cache, new CacheEntryFactory()
          {
              @Override
              public Object createEntry(final Object key) throws Exception
              {
                  if (key == null)
                  {
                      throw new NullPointerException();
                  }
                  @SuppressWarnings("unchecked")
                  final K loaderKey = (K) key;
                  return loader.load(loaderKey);
              }
          });
  
          return DelegatingCache.create(spCache, settings);
      }
  
      protected DelegatingCache createSimpleCache(String name, CacheSettings settings)
      {
          final Ehcache cache = new EhCacheHelper().getEhcache(name, delegate, settings);
  
          return DelegatingCache.create(cache, settings);
      }
  }