package com.atlassian.cache.vcache;
   
   import java.util.Collection;
   import javax.annotation.Nonnull;
   import javax.annotation.Nullable;
   
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheEntryListener;
   import com.atlassian.cache.CacheLoader;
  import com.atlassian.cache.CacheSettings;
  import com.atlassian.cache.Supplier;
  import com.atlassian.vcache.JvmCache;
  
  import static java.util.Objects.requireNonNull;
  
  class JvmCacheDelegate<K, V>
          extends ManagedCacheSupport
          implements Cache<K, V>
  {
      private final JvmCache<K, V> delegate;
      private final CacheLoader<K, V> cacheLoader;
  
      public JvmCacheDelegate(String name,
                              JvmCache<K, V> delegate,
                              @Nullable CacheLoader<K, V> cacheLoader,
                              CacheSettings settings)
      {
          super(name, settings);
          this.delegate = requireNonNull(delegate);
          this.cacheLoader = cacheLoader;
      }
  
      @Override
      public void clear()
      {
          delegate.removeAll();
      }
  
      @Override
      public boolean isLocal()
      {
          return true;
      }
  
      @Override
      public boolean containsKey(@Nonnull K key)
      {
          return delegate.get(key).isPresent();
      }
  
      @Nonnull
      @Override
      public Collection<K> getKeys()
      {
          return delegate.getKeys();
      }
  
      @Nullable
      @Override
      public V get(@Nonnull K key)
      {
          if (cacheLoader == null)
          {
              return delegate.get(key).orElse(null);
          }
          else
          {
              return delegate.get(key, () -> cacheLoader.load(key));
          }
      }
  
      @Nonnull
      @Override
      public V get(@Nonnull K key, @Nonnull Supplier<? extends V> valueSupplier)
      {
          return delegate.get(key, valueSupplier::get);
      }
  
      @Override
      public void put(@Nonnull K key, @Nonnull V value)
      {
          delegate.put(key, value);
      }
  
      @Nullable
      @Override
      public V putIfAbsent(@Nonnull K key, @Nonnull V value)
      {
          return delegate.putIfAbsent(key, value).orElse(null);
      }
  
      @Override
      public void remove(@Nonnull K key)
      {
          delegate.remove(key);
      }
  
      @Override
      public boolean remove(@Nonnull K key, @Nonnull V value)
     {
         return delegate.removeIf(key, value);
     }
 
     @Override
     public void removeAll()
     {
         delegate.removeAll();
     }
 
     @Override
     public boolean replace(@Nonnull K key, @Nonnull V oldValue, @Nonnull V newValue)
     {
         return delegate.replaceIf(key, oldValue, newValue);
     }
 
     @Override
     public void addListener(@Nonnull CacheEntryListener<K, V> listener, boolean includeValues)
     {
         throw new UnsupportedOperationException("Unsupported when using the VCache implementation");
     }
 
     @Override
     public void removeListener(@Nonnull CacheEntryListener<K, V> listener)
     {
         throw new UnsupportedOperationException("Unsupported when using the VCache implementation");
     }
 }