/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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 org.apache.shiro.cache;
  
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Map;
  import java.util.Set;
  
  /**
   * A <code>MapCache</code> is a {@link Cache Cache} implementation that uses a backing {@link Map} instance to store
   * and retrieve cached data.
   *
   * @since 1.0
   */
  public class MapCache<K, V> implements Cache<K, V> {
  
      /**
       * Backing instance.
       */
      private final Map<K, V> map;
  
      /**
       * The name of this cache.
       */
      private final String name;
  
      public MapCache(String name, Map<K, V> backingMap) {
          if (name == null) {
              throw new IllegalArgumentException("Cache name cannot be null.");
          }
          if (backingMap == null) {
              throw new IllegalArgumentException("Backing map cannot be null.");
          }
          this.name = name;
          this.map = backingMap;
      }
  
      public V get(K key) throws CacheException {
          return map.get(key);
      }
  
      public V put(K key, V value) throws CacheException {
          return map.put(key, value);
      }
  
      public V remove(K key) throws CacheException {
          return map.remove(key);
      }
  
      public void clear() throws CacheException {
          map.clear();
      }
  
      public int size() {
          return map.size();
      }
  
      public Set<K> keys() {
          Set<K> keys = map.keySet();
          if (!keys.isEmpty()) {
              return Collections.unmodifiableSet(keys);
          }
          return Collections.emptySet();
      }
  
      public Collection<V> values() {
          Collection<V> values = map.values();
          if (!map.isEmpty()) {
              return Collections.unmodifiableCollection(values);
          }
          return Collections.emptySet();
      }
  
      public String toString() {
          return new StringBuilder("MapCache '")
                  .append(name).append("' (")
                  .append(map.size())
                  .append(" entries)")
                  .toString();
      }
  }