package com.atlassian.cache.hazelcast;
   
   import java.util.SortedMap;
   import java.util.concurrent.TimeUnit;
   
   import javax.annotation.Nonnull;
   
   import com.atlassian.cache.CacheSettings;
   import com.atlassian.cache.CacheStatisticsKey;
  import com.atlassian.cache.ManagedCache;
  import com.atlassian.util.concurrent.Supplier;
  
  import com.google.common.collect.ImmutableSortedMap;
  
  /**
   * Common implementation of {@link com.atlassian.cache.ManagedCache} methods for hybrid caches and cached references.
   *
   * @since 2.4.0
   */
  public abstract class ManagedHybridCacheSupport implements ManagedCache
  {
      protected final boolean flushable;
      protected final String name;
  
      public ManagedHybridCacheSupport(String name, CacheSettings settings)
      {
          this.flushable = settings.getFlushable(true);
          this.name = name;
      }
  
      @Override
      public Long currentExpireAfterAccessMillis()
      {
          return getManagedCache().currentExpireAfterAccessMillis();
      }
  
      @Override
      public Long currentExpireAfterWriteMillis()
      {
          return getManagedCache().currentExpireAfterWriteMillis();
      }
  
      @Override
      public Integer currentMaxEntries()
      {
          return getManagedCache().currentMaxEntries();
      }
  
      @Nonnull
      @Override
      public String getName()
      {
          return name;
      }
  
      @Override
      public boolean isFlushable()
      {
          return flushable;
      }
  
      @Override
      public boolean isLocal()
      {
          return false;
      }
  
      @Override
      public boolean isReplicateAsynchronously()
      {
          return false;
      }
  
      @Override
      public boolean isReplicateViaCopy()
      {
          return false;
      }
  
      @Override
      public boolean updateExpireAfterAccess(long expireAfter, @Nonnull TimeUnit timeUnit)
      {
          return getManagedCache().updateExpireAfterAccess(expireAfter, timeUnit);
      }
  
      @Override
      public boolean updateExpireAfterWrite(long expireAfter, @Nonnull TimeUnit timeUnit)
      {
          return getManagedCache().updateExpireAfterAccess(expireAfter, timeUnit);
      }
  
      @Override
      public boolean updateMaxEntries(int newValue)
      {
          return getManagedCache().updateMaxEntries(newValue);
      }
  
      protected abstract ManagedCache getManagedCache();
  
     @Nonnull
     @Override
     public SortedMap<CacheStatisticsKey, Supplier<Long>> getStatistics()
     {
         return ImmutableSortedMap.of();
     }
 }