/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package de.smartics.properties.spi.config.cache.infinispan;
  
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  import java.util.logging.Logger;
  
  import de.smartics.properties.spi.config.cache.CompoundKey;
  import de.smartics.properties.spi.config.cache.UnawareCache;
  import de.smartics.util.lang.StaticAnalysis;
  
  /**
   * Implementation of an cache that delegates to an infinispan cache.
   *
   * @param <K> the type for the key.
   * @param <V> the type for the value.
   */
  public final class InfinispanCompoundKeyDelegatingCache<K, V> implements
      UnawareCache<K, V>
  {
    // ********************************* Fields *********************************
  
    /**
     * Reference to the logger for this instance.
     */
    @SuppressWarnings("unused")
    private final Logger log = Logger
        .getLogger(InfinispanCompoundKeyDelegatingCache.class.getName());
  
    /**
     * The lock for synchronized access.
     *
     * @serial
     */
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  
    /**
     * The read lock for synchronized access.
     *
     * @serial
     */
    private final Lock readLock = lock.readLock();
  
    /**
     * The write lock for synchronized access.
     *
     * @serial
     */
    private final Lock writeLock = lock.writeLock();
  
    /**
     * The cache to which everything is delegated.
     */
    @SuppressWarnings(StaticAnalysis.RAWTYPES)
    private final org.infinispan.Cache cache;
  
    /**
     * The name of the cache.
     */
    private final String cacheName;
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Constructor to create a cache.
     *
     * @param cacheName the name of the cache.
     * @param cache the cach under the hood, that is used to store everything.
     */
    public InfinispanCompoundKeyDelegatingCache(final String cacheName,
        @SuppressWarnings("rawtypes") final org.infinispan.Cache cache)
    {
      this.cacheName = cacheName;
      this.cache = cache;
    }
  
    // ****************************** Inner Classes *****************************
  
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   @Override
   public V get(final Object key)
   {
     readLock.lock();
     try
     {
       final CompoundKey compoundKey = new CompoundKey(cacheName, key);
       final String compoundKeyString = compoundKey.toString();
       return (V) cache.get(compoundKeyString);
     }
     finally
     {
       readLock.unlock();
     }
   }
 
   @SuppressWarnings({ StaticAnalysis.UNCHECKED })
   @Override
   public void put(final K key, final V value, final long interval,
       final TimeUnit unit)
   {
     writeLock.lock();
     try
     {
       final CompoundKey compoundKey = new CompoundKey(cacheName, key);
       final String compoundKeyString = compoundKey.toString();
       cache.put(compoundKeyString, value, interval, unit);
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   @SuppressWarnings({ StaticAnalysis.UNCHECKED })
   @Override
   public void put(final K key, final V value)
   {
     writeLock.lock();
     try
     {
       final CompoundKey compoundKey = new CompoundKey(cacheName, key);
       final String compoundKeyString = compoundKey.toString();
       cache.put(compoundKeyString, value);
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   @SuppressWarnings({ StaticAnalysis.UNCHECKED })
   @Override
   // CHECKSTYLE:OFF
   public void put(final K key, final V value, final int interval,
       final TimeUnit unit, final int maxIdleTime,
       final TimeUnit maxIdleTimeTimeUnit)
   {
     writeLock.lock();
     try
     {
       final CompoundKey compoundKey = new CompoundKey(cacheName, key);
       final String compoundKeyString = compoundKey.toString();
       cache.put(compoundKeyString, value, interval, unit, maxIdleTime,
           maxIdleTimeTimeUnit);
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   // CHECKSTYLE:ON
 
   @SuppressWarnings({ StaticAnalysis.UNCHECKED })
   @Override
   public V remove(final Object key)
   {
     writeLock.lock();
     try
     {
       final CompoundKey compoundKey = new CompoundKey(cacheName, key);
       final String compoundKeyString = compoundKey.toString();
       return (V) cache.remove(compoundKeyString);
     }
     finally
     {
       writeLock.unlock();
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }