Class AnnotatedTypeMap<K extends java.lang.reflect.AnnotatedType,​V>

  • Type Parameters:
    V - the type of mapped values
    All Implemented Interfaces:
    java.util.Map<K,​V>

    public class AnnotatedTypeMap<K extends java.lang.reflect.AnnotatedType,​V>
    extends java.lang.Object
    implements java.util.Map<K,​V>
    A Map implementation keyed by AnnotatedType. The standard maps do not usually suffice as AnnotatedType implements neither equals nor hashCode. This implementation overcomes that limitation by transparently turning each AnnotatedType used as the key into the canonical form using GenericTypeReflector.toCanonical(AnnotatedType). By default, AnnotatedTypeMap instances are backed by a HashMap, but any map can be used instead. The guarantees of AnnotatedTypeMap are then the same as of the map it is backed by.
    See Also:
    AnnotatedTypeSet
    • Nested Class Summary

      • 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
      private java.util.Map<K,​V> inner  
    • Constructor Summary

      Constructors 
      Constructor Description
      AnnotatedTypeMap()
      Constructs an instance backed by a HashMap
      AnnotatedTypeMap​(java.util.Map<K,​V> inner)
      Constructs an instance backed by the provided map, keeping its guarantees
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void clear()
      V compute​(K key, java.util.function.BiFunction<? super K,​? super V,​? extends V> remappingFunction)
      V computeIfAbsent​(K key, java.util.function.Function<? super K,​? extends V> mappingFunction)
      V computeIfPresent​(K key, java.util.function.BiFunction<? super K,​? super V,​? extends V> remappingFunction)
      boolean containsKey​(java.lang.Object key)
      boolean containsValue​(java.lang.Object value)
      java.util.Set<java.util.Map.Entry<K,​V>> entrySet()
      boolean equals​(java.lang.Object o)
      void forEach​(java.util.function.BiConsumer<? super K,​? super V> action)
      V get​(java.lang.Object key)
      V getOrDefault​(java.lang.Object key, V defaultValue)
      int hashCode()
      boolean isEmpty()
      java.util.Set<K> keySet()
      V merge​(K key, V value, java.util.function.BiFunction<? super V,​? super V,​? extends V> remappingFunction)
      V put​(K key, V value)
      void putAll​(java.util.Map<? extends K,​? extends V> m)
      V putIfAbsent​(K key, V value)
      V remove​(java.lang.Object key)
      boolean remove​(java.lang.Object key, java.lang.Object value)
      V replace​(K key, V value)
      boolean replace​(K key, V oldValue, V newValue)
      void replaceAll​(java.util.function.BiFunction<? super K,​? super V,​? extends V> function)
      int size()
      java.util.Collection<V> values()
      • Methods inherited from class java.lang.Object

        clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • inner

        private final java.util.Map<K extends java.lang.reflect.AnnotatedType,​V> inner
    • Constructor Detail

      • AnnotatedTypeMap

        public AnnotatedTypeMap()
        Constructs an instance backed by a HashMap
      • AnnotatedTypeMap

        public AnnotatedTypeMap​(java.util.Map<K,​V> inner)
        Constructs an instance backed by the provided map, keeping its guarantees
        Parameters:
        inner - A non-null map instance that will back the constructed AnnotatedTypeMap
    • Method Detail

      • size

        public int size()
        Specified by:
        size in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • isEmpty

        public boolean isEmpty()
        Specified by:
        isEmpty in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • containsKey

        public boolean containsKey​(java.lang.Object key)
        Specified by:
        containsKey in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • containsValue

        public boolean containsValue​(java.lang.Object value)
        Specified by:
        containsValue in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • get

        public V get​(java.lang.Object key)
        Specified by:
        get in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • put

        public V put​(K key,
                     V value)
        Specified by:
        put in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • remove

        public V remove​(java.lang.Object key)
        Specified by:
        remove in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • putAll

        public void putAll​(java.util.Map<? extends K,​? extends V> m)
        Specified by:
        putAll in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • clear

        public void clear()
        Specified by:
        clear in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • keySet

        public java.util.Set<K> keySet()
        Specified by:
        keySet in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • values

        public java.util.Collection<V> values()
        Specified by:
        values in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • entrySet

        public java.util.Set<java.util.Map.Entry<K,​V>> entrySet()
        Specified by:
        entrySet in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • equals

        public boolean equals​(java.lang.Object o)
        Specified by:
        equals in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public int hashCode()
        Specified by:
        hashCode in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
        Overrides:
        hashCode in class java.lang.Object
      • getOrDefault

        public V getOrDefault​(java.lang.Object key,
                              V defaultValue)
        Specified by:
        getOrDefault in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • forEach

        public void forEach​(java.util.function.BiConsumer<? super K,​? super V> action)
        Specified by:
        forEach in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • replaceAll

        public void replaceAll​(java.util.function.BiFunction<? super K,​? super V,​? extends V> function)
        Specified by:
        replaceAll in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • putIfAbsent

        public V putIfAbsent​(K key,
                             V value)
        Specified by:
        putIfAbsent in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • remove

        public boolean remove​(java.lang.Object key,
                              java.lang.Object value)
        Specified by:
        remove in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • replace

        public boolean replace​(K key,
                               V oldValue,
                               V newValue)
        Specified by:
        replace in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • replace

        public V replace​(K key,
                         V value)
        Specified by:
        replace in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • computeIfAbsent

        public V computeIfAbsent​(K key,
                                 java.util.function.Function<? super K,​? extends V> mappingFunction)
        Specified by:
        computeIfAbsent in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • computeIfPresent

        public V computeIfPresent​(K key,
                                  java.util.function.BiFunction<? super K,​? super V,​? extends V> remappingFunction)
        Specified by:
        computeIfPresent in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • compute

        public V compute​(K key,
                         java.util.function.BiFunction<? super K,​? super V,​? extends V> remappingFunction)
        Specified by:
        compute in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>
      • merge

        public V merge​(K key,
                       V value,
                       java.util.function.BiFunction<? super V,​? super V,​? extends V> remappingFunction)
        Specified by:
        merge in interface java.util.Map<K extends java.lang.reflect.AnnotatedType,​V>