Package com.twelvemonkeys.util

Class IgnoreCaseMap<V>

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, java.util.Map<java.lang.String,​V>
    public class IgnoreCaseMap<V>
extends java.util.AbstractMap<K,​V>
implements java.io.Serializable, java.lang.Cloneable
    A Map decorator that makes the mappings in the backing map case insensitive (this is implemented by converting all keys to uppercase), if the keys used are Strings. If the keys used are not Strings, it wil work as a normal java.util.Map.
    Author:
    Harald Kuhr
    See Also:
    Map, Serialized Form

    • Nested Class Summary

      • Nested classes/interfaces inherited from class java.util.AbstractMap

        java.util.AbstractMap.SimpleEntry<K extends java.lang.Object,​V extends java.lang.Object>, java.util.AbstractMap.SimpleImmutableEntry<K extends java.lang.Object,​V extends java.lang.Object>

      • Nested classes/interfaces inherited from interface java.util.Map

        java.util.Map.Entry<K extends java.lang.Object,​V extends java.lang.Object>

    • Field Summary

      Fields 
      Modifier and Type Field Description
      protected java.util.Map<K,​java.util.Map.Entry<K,​V>> entries  
      protected int modCount  

    • Constructor Summary

      Constructors 
      Constructor Description
      IgnoreCaseMap()
      Constructs a new empty Map.
      IgnoreCaseMap​(java.util.Map<java.lang.String,​? extends V> pMap)
      Constructs a new Map with the same key-value mappings as the given Map.
      IgnoreCaseMap​(java.util.Map pBacking, java.util.Map<java.lang.String,​? extends V> pContents)
      Constructs a new Map with the same key-value mappings as the given Map.

    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void clear()  
      protected java.lang.Object clone()
      Returns a shallow copy of this AbstractMap instance: the keys and values themselves are not cloned.
      boolean containsKey​(java.lang.Object pKey)
      Tests if the specified object is a key in this map.
      boolean containsValue​(java.lang.Object pValue)
      Returns true if this map maps one or more keys to the specified pValue.
      java.util.Set<java.util.Map.Entry<K,​V>> entrySet()  
      V get​(java.lang.Object pKey)
      Returns the value to which the specified key is mapped in this map.
      protected void init()
      Default implementation, does nothing.
      boolean isEmpty()  
      java.util.Set<K> keySet()  
      protected java.util.Iterator<java.util.Map.Entry<java.lang.String,​V>> newEntryIterator()  
      protected java.util.Iterator<java.lang.String> newKeyIterator()  
      protected java.util.Iterator<V> newValueIterator()  
      V put​(java.lang.String pKey, V pValue)
      Maps the specified key to the specified value in this map.
      V remove​(java.lang.Object pKey)
      Removes the key (and its corresponding value) from this map.
      protected java.util.Map.Entry<K,​V> removeEntry​(java.util.Map.Entry<K,​V> pEntry)
      Removes the given entry from the Map.
      int size()  
      protected static java.lang.Object toUpper​(java.lang.Object pObject)
      Converts the parameter to uppercase, if it's a String.
      java.util.Collection<V> values()  

      • Methods inherited from class java.util.AbstractMap

        equals, hashCode, putAll, toString

      • Methods inherited from class java.lang.Object

        finalize, getClass, notify, notifyAll, wait, wait, wait

      • Methods inherited from interface java.util.Map

        compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putAll, putIfAbsent, remove, replace, replace, replaceAll

    • Field Detail

      • entries

        protected java.util.Map<K,​java.util.Map.Entry<K,​V>> entries

      • modCount

        protected transient volatile int modCount

    • Constructor Detail

      • IgnoreCaseMap

        public IgnoreCaseMap()
        Constructs a new empty Map. The backing map will be a HashMap

      • IgnoreCaseMap

        public IgnoreCaseMap​(java.util.Map<java.lang.String,​? extends V> pMap)
        Constructs a new Map with the same key-value mappings as the given Map. The backing map will be a HashMap

        NOTE: As the keys in the given map parameter will be converted to uppercase (if they are strings), any duplicate key/value pair where key instanceof String && key.equalsIgnoreCase(otherKey) is true, will be lost.

        Parameters:
        pMap - the map whose mappings are to be placed in this map.

      • IgnoreCaseMap

        public IgnoreCaseMap​(java.util.Map pBacking,
                     java.util.Map<java.lang.String,​? extends V> pContents)
        Constructs a new Map with the same key-value mappings as the given Map.

        NOTE: The backing map is structuraly cahnged, and it should NOT be accessed directly, after the wrapped map is created.

        NOTE: As the keys in the given map parameter will be converted to uppercase (if they are strings), any duplicate key/value pair where key instanceof String && key.equalsIgnoreCase(otherKey) is true, will be lost.

        Parameters:
        pBacking - the backing map of this map. Must be either empty, or the same map as pContents.
        pContents - the map whose mappings are to be placed in this map. May be null
        Throws:
        java.lang.IllegalArgumentException - if pBacking is null
        java.lang.IllegalArgumentException - if pBacking differs from pContent and is not empty.

    • Method Detail

      • put

        public V put​(java.lang.String pKey,
             V pValue)
        Maps the specified key to the specified value in this map. Note: If the key used is a string, the key will not be case-sensitive.
        Specified by:
        put in interface java.util.Map<java.lang.String,​V>
        Parameters:
        pKey - the map key.
        pValue - the value.
        Returns:
        the previous value of the specified key in this map, or null if it did not have one.

      • get

        public V get​(java.lang.Object pKey)
        Returns the value to which the specified key is mapped in this map. Note: If the key used is a string, the key will not be case-sensitive.
        Specified by:
        get in interface java.util.Map<java.lang.String,​V>
        Parameters:
        pKey - a key in the map
        Returns:
        the value to which the key is mapped in this map; null if the key is not mapped to any value in this map.

      • remove

        public V remove​(java.lang.Object pKey)
        Removes the key (and its corresponding value) from this map. This method does nothing if the key is not in the map. Note: If the key used is a string, the key will not be case-sensitive.
        Specified by:
        remove in interface java.util.Map<java.lang.String,​V>
        Parameters:
        pKey - the key that needs to be removed.
        Returns:
        the value to which the key had been mapped in this map, or null if the key did not have a mapping.

      • containsKey

        public boolean containsKey​(java.lang.Object pKey)
        Tests if the specified object is a key in this map. Note: If the key used is a string, the key will not be case-sensitive.
        Specified by:
        containsKey in interface java.util.Map<java.lang.String,​V>
        Parameters:
        pKey - possible key.
        Returns:
        true if and only if the specified object is a key in this map, as determined by the equals method; false otherwise.

      • toUpper

        protected static java.lang.Object toUpper​(java.lang.Object pObject)
        Converts the parameter to uppercase, if it's a String.

      • newEntryIterator

        protected java.util.Iterator<java.util.Map.Entry<java.lang.String,​V>> newEntryIterator()

      • newKeyIterator

        protected java.util.Iterator<java.lang.String> newKeyIterator()

      • newValueIterator

        protected java.util.Iterator<V> newValueIterator()

      • init

        protected void init()
        Default implementation, does nothing.

      • size

        public int size()
        Specified by:
        size in interface java.util.Map<K,​V>
        Overrides:
        size in class java.util.AbstractMap<K,​V>

      • clear

        public void clear()
        Specified by:
        clear in interface java.util.Map<K,​V>
        Overrides:
        clear in class java.util.AbstractMap<K,​V>

      • isEmpty

        public boolean isEmpty()
        Specified by:
        isEmpty in interface java.util.Map<K,​V>
        Overrides:
        isEmpty in class java.util.AbstractMap<K,​V>

      • containsValue

        public boolean containsValue​(java.lang.Object pValue)
        Returns true if this map maps one or more keys to the specified pValue. More formally, returns true if and only if this map contains at least one mapping to a pValue v such that (pValue==null ? v==null : pValue.equals(v)).

        This implementation requires time linear in the map size for this operation.

        Specified by:
        containsValue in interface java.util.Map<K,​V>
        Overrides:
        containsValue in class java.util.AbstractMap<K,​V>
        Parameters:
        pValue - pValue whose presence in this map is to be tested.
        Returns:
        true if this map maps one or more keys to the specified pValue.

      • values

        public java.util.Collection<V> values()
        Specified by:
        values in interface java.util.Map<K,​V>
        Overrides:
        values in class java.util.AbstractMap<K,​V>

      • entrySet

        public java.util.Set<java.util.Map.Entry<K,​V>> entrySet()
        Specified by:
        entrySet in interface java.util.Map<K,​V>
        Specified by:
        entrySet in class java.util.AbstractMap<K,​V>

      • keySet

        public java.util.Set<K> keySet()
        Specified by:
        keySet in interface java.util.Map<K,​V>
        Overrides:
        keySet in class java.util.AbstractMap<K,​V>

      • clone

        protected java.lang.Object clone()
                          throws java.lang.CloneNotSupportedException
        Returns a shallow copy of this AbstractMap instance: the keys and values themselves are not cloned.
        Overrides:
        clone in class java.util.AbstractMap<K,​V>
        Returns:
        a shallow copy of this map.
        Throws:
        java.lang.CloneNotSupportedException

      • removeEntry

        protected java.util.Map.Entry<K,​V> removeEntry​(java.util.Map.Entry<K,​V> pEntry)
        Removes the given entry from the Map.
        Parameters:
        pEntry - the entry to be removed
        Returns:
        the removed entry, or null if nothing was removed.