/*
    * 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.commons.collections4.map;
  
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.util.Collection;
  import java.util.Map;
  import java.util.Set;
  import java.util.SortedMap;
  
  import org.apache.commons.collections4.BoundedMap;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.collections4.collection.UnmodifiableCollection;
  import org.apache.commons.collections4.set.UnmodifiableSet;
  
  /**
   * Decorates another {@code SortedMap} to fix the size blocking add/remove.
   * <p>
   * Any action that would change the size of the map is disallowed.
   * The put method is allowed to change the value associated with an existing
   * key however.
   * </p>
   * <p>
   * If trying to remove or clear the map, an UnsupportedOperationException is
   * thrown. If trying to put a new mapping into the map, an
   * IllegalArgumentException is thrown. This is because the put method can
   * succeed if the mapping's key already exists in the map, so the put method
   * is not always unsupported.
   * </p>
   * <p>
   * <strong>Note that FixedSizeSortedMap is not synchronized and is not thread-safe.</strong>
   * If you wish to use this map from multiple threads concurrently, you must use
   * appropriate synchronization. The simplest approach is to wrap this map
   * using {@link java.util.Collections#synchronizedSortedMap}. This class may throw
   * exceptions when accessed by concurrent threads without synchronization.
   * </p>
   * <p>
   * This class is Serializable from Commons Collections 3.1.
   * </p>
   *
   * @param <K> the type of the keys in this map
   * @param <V> the type of the values in this map
   * @since 3.0
   */
  public class FixedSizeSortedMap<K, V>
          extends AbstractSortedMapDecorator<K, V>
          implements BoundedMap<K, V>, Serializable {
  
      /** Serialization version */
      private static final long serialVersionUID = 3126019624511683653L;
  
      /**
       * Factory method to create a fixed size sorted map.
       *
       * @param <K>  the key type
       * @param <V>  the value type
       * @param map  the map to decorate, must not be null
       * @return a new fixed size sorted map
       * @throws NullPointerException if map is null
       * @since 4.0
       */
      public static <K, V> FixedSizeSortedMap<K, V> fixedSizeSortedMap(final SortedMap<K, V> map) {
          return new FixedSizeSortedMap<>(map);
      }
  
      /**
       * Constructor that wraps (not copies).
       *
       * @param map  the map to decorate, must not be null
       * @throws NullPointerException if map is null
       */
      protected FixedSizeSortedMap(final SortedMap<K, V> map) {
          super(map);
      }
  
      @Override
      public void clear() {
          throw new UnsupportedOperationException("Map is fixed size");
      }
  
      @Override
      public Set<Map.Entry<K, V>> entrySet() {
         return UnmodifiableSet.unmodifiableSet(map.entrySet());
     }
 
     /**
      * Gets the map being decorated.
      *
      * @return the decorated map
      */
     protected SortedMap<K, V> getSortedMap() {
         return (SortedMap<K, V>) map;
     }
 
     @Override
     public SortedMap<K, V> headMap(final K toKey) {
         return new FixedSizeSortedMap<>(getSortedMap().headMap(toKey));
     }
 
     @Override
     public boolean isFull() {
         return true;
     }
 
     @Override
     public Set<K> keySet() {
         return UnmodifiableSet.unmodifiableSet(map.keySet());
     }
 
     @Override
     public int maxSize() {
         return size();
     }
 
     @Override
     public V put(final K key, final V value) {
         if (!map.containsKey(key)) {
             throw new IllegalArgumentException("Cannot put new key/value pair - Map is fixed size");
         }
         return map.put(key, value);
     }
 
     @Override
     public void putAll(final Map<? extends K, ? extends V> mapToCopy) {
         if (CollectionUtils.isSubCollection(mapToCopy.keySet(), keySet())) {
             throw new IllegalArgumentException("Cannot put new key/value pair - Map is fixed size");
         }
         map.putAll(mapToCopy);
     }
 
     /**
      * Read the map in using a custom routine.
      *
      * @param in the input stream
      * @throws IOException if an error occurs while reading from the stream
      * @throws ClassNotFoundException if an object read from the stream can not be loaded
      */
     @SuppressWarnings("unchecked") // (1) should only fail if input stream is incorrect
     private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
         in.defaultReadObject();
         map = (Map<K, V>) in.readObject(); // (1)
     }
 
     @Override
     public V remove(final Object key) {
         throw new UnsupportedOperationException("Map is fixed size");
     }
 
     @Override
     public SortedMap<K, V> subMap(final K fromKey, final K toKey) {
         return new FixedSizeSortedMap<>(getSortedMap().subMap(fromKey, toKey));
     }
 
     @Override
     public SortedMap<K, V> tailMap(final K fromKey) {
         return new FixedSizeSortedMap<>(getSortedMap().tailMap(fromKey));
     }
 
     @Override
     public Collection<V> values() {
         return UnmodifiableCollection.unmodifiableCollection(map.values());
     }
 
     /**
      * Write the map out using a custom routine.
      *
      * @param out  the output stream
      * @throws IOException if an error occurs while writing to the stream
      */
     private void writeObject(final ObjectOutputStream out) throws IOException {
         out.defaultWriteObject();
         out.writeObject(map);
     }
 
 }