package com.atlassian.cache.vcache;
   
   import javax.annotation.Nonnull;
   
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CachedReference;
   import com.atlassian.cache.CachedReferenceListener;
   import com.atlassian.cache.Supplier;
   import com.atlassian.vcache.JvmCache;
  
  import static java.util.Objects.requireNonNull;
  
  class JvmCachedReference<V>
          extends ManagedCacheSupport
          implements CachedReference<V>
  {
      private static final String REFERENCE_KEY = "ReferenceKey";
  
      private final JvmCache<String, V> delegate;
      private final Supplier<V> supplier;
  
      public JvmCachedReference(String name,
                                JvmCache<String, V> delegate,
                                Supplier<V> supplier,
                                CacheSettings settings)
      {
          super(name, settings);
          this.delegate = requireNonNull(delegate);
          this.supplier = requireNonNull(supplier);
      }
  
      @Nonnull
      @Override
      public V get()
      {
          return delegate.get(REFERENCE_KEY, supplier::get);
      }
  
      @Override
      public void reset()
      {
          delegate.remove(REFERENCE_KEY);
      }
  
      @Override
      public void addListener(@Nonnull CachedReferenceListener<V> listener, boolean includeValues)
      {
          throw new UnsupportedOperationException("Unsupported when using the VCache implementation");
      }
  
      @Override
      public void removeListener(@Nonnull CachedReferenceListener<V> listener)
      {
          throw new UnsupportedOperationException("Unsupported when using the VCache implementation");
      }
  
      @Override
      public void clear()
      {
          if (isFlushable())
          {
              reset();
          }
      }
  
      @Override
      public boolean isLocal()
      {
          return true;
      }
  }