package com.atlassian.cache.ehcache;
   
   import com.atlassian.cache.CacheException;
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CachedReference;
   import com.atlassian.cache.Supplier;
   import com.atlassian.cache.impl.ReferenceKey;
   import net.sf.ehcache.Ehcache;
   import net.sf.ehcache.Element;
  import net.sf.ehcache.loader.CacheLoader;
  
  import javax.annotation.Nullable;
  
  /**
   * A Lazy Reference that delegates to EhCache.
   *
   * @since 2.0
   */
  class DelegatingCachedReference<V> extends ManagedCacheSupport implements CachedReference<V>
  {
      private final Ehcache delegate;
      private final CacheLoader cacheLoader;
  
      private DelegatingCachedReference(final Ehcache delegate, final Supplier<V> supplier, CacheSettings settings)
      {
          super(delegate, settings);
          this.delegate = delegate;
          cacheLoader = new ReferenceCacheLoader<V>(supplier);
      }
  
      static <V> DelegatingCachedReference<V> create(final Ehcache delegate, final Supplier<V> supplier, CacheSettings settings)
      {
          return new DelegatingCachedReference<V>(delegate, supplier, settings);
      }
  
      @SuppressWarnings("unchecked")
      @Override
      public V get()
      {
          try
          {
              Element element = delegate.getWithLoader(ReferenceKey.KEY, cacheLoader, null);
              return element == null ? null : (V) element.getObjectValue();
          }
          catch (net.sf.ehcache.CacheException e)
          {
              throw new CacheException(e.getCause());
          }
          catch (Exception e)
          {
              throw new CacheException(e);
          }
      }
  
      @Override
      public void reset()
      {
          try
          {
              delegate.remove(ReferenceKey.KEY);
          }
          catch (Exception e)
          {
              throw new CacheException(e);
          }
      }
  
      @Override
      public void clear()
      {
          reset();
      }
  
      public boolean equals(@Nullable final Object other)
      {
          if (other instanceof DelegatingCachedReference)
          {
              DelegatingCachedReference otherDelegatingReference = (DelegatingCachedReference) other;
              if (delegate.equals(otherDelegatingReference.delegate))
              {
                  return true;
              }
          }
          return false;
      }
  
      @Override
      public int hashCode()
      {
          return 3 + delegate.hashCode();
      }
  
  }