Package org.codehaus.groovy.runtime.memoize

# Class UnlimitedConcurrentCache<K,​V>

java.lang.Object
org.codehaus.groovy.runtime.memoize.UnlimitedConcurrentCache<K,​V>

All Implemented Interfaces:
  `Serializable`, `Map<K,​V>`, `EvictableCache<K,​V>`, `MemoizeCache<K,​V>`

    @ThreadSafe
    public final class UnlimitedConcurrentCache<K,​V>
    extends Object
    implements EvictableCache<K,​V>, Serializable

A cache backed by a ConcurrentHashMap

See Also:
  Serialized Form

- ## Nested Class Summary

  ## Nested classes/interfaces inherited from interface org.codehaus.groovy.runtime.memoize.EvictableCache

  `EvictableCache.Action<K,​V,​R>, EvictableCache.EvictionStrategy`

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

  `Map.Entry<K extends Object,​V extends Object>`

  ## Nested classes/interfaces inherited from interface org.codehaus.groovy.runtime.memoize.MemoizeCache

  `MemoizeCache.ValueProvider<K,​V>`

- ## Constructor Summary

  Constructors
  Constructor | Description
  --- | ---
  `UnlimitedConcurrentCache()` | Constructs a cache with unlimited size
  `UnlimitedConcurrentCache​(int initialCapacity)` | Constructs a cache with unlimited size and set its initial capacity
  `UnlimitedConcurrentCache​(Map<? extends K,​? extends V> m)` | Constructs a cache and initialize the cache with the specified map

- ## Method Summary

  Modifier and Type | Method | Description
  --- | --- | ---
  `void` | `cleanUpNullReferences()` | Replying on the ConcurrentHashMap thread-safe iteration implementation the method will remove all entries holding SoftReferences to gc-evicted objects.
  `Map<K,​V>` | `clearAll()` | Clear the cache
  `boolean` | `containsKey​(Object key)` | Determines if the cache contains an entry for the specified key.
  `boolean` | `containsValue​(Object value)` |
  `Set<Map.Entry<K,​V>>` | `entrySet()` |
  `V` | `get​(Object key)` | Gets a value from the cache
  `V` | `getAndPut​(K key, MemoizeCache.ValueProvider<? super K,​? extends V> valueProvider)` | Try to get the value from cache.
  `boolean` | `isEmpty()` |
  `Set<K>` | `keys()` | Get all keys associated to cached values
  `Set<K>` | `keySet()` |
  `V` | `put​(K key, V value)` | Associates the specified value with the specified key in the cache.
  `void` | `putAll​(Map<? extends K,​? extends V> m)` |
  `V` | `remove​(Object key)` | Remove the cached value by the key
  `int` | `size()` | Get the size of the cache
  `Collection<V>` | `values()` | Get all cached values

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface org.codehaus.groovy.runtime.memoize.EvictableCache

  `clear`

  ### Methods inherited from interface java.util.Map

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

- ## Constructor Details

  - ### UnlimitedConcurrentCache

    public UnlimitedConcurrentCache()
    Constructs a cache with unlimited size

  - ### UnlimitedConcurrentCache

    public UnlimitedConcurrentCache​(int initialCapacity)
    Constructs a cache with unlimited size and set its initial capacity
    Parameters:
      `initialCapacity` - the initial capacity

  - ### UnlimitedConcurrentCache

    public UnlimitedConcurrentCache​(Map<? extends K,​? extends V> m)
    Constructs a cache and initialize the cache with the specified map
    Parameters:
      `m` - the map to initialize the cache

- ## Method Details

  - ### remove

    public V remove​(Object key)
    Remove the cached value by the key
    Specified by:
      `remove` in interface `EvictableCache<K,​V>`
    Specified by:
      `remove` in interface `Map<K,​V>`
    Parameters:
      `key` -
    Returns:
      returns the removed value

  - ### putAll

    public void putAll​(Map<? extends K,​? extends V> m)
    Specified by:
      `putAll` in interface `Map<K,​V>`

  - ### keySet

    public Set<K> keySet()
    Specified by:
      `keySet` in interface `Map<K,​V>`

  - ### clearAll

    public Map<K,​V> clearAll()
    Clear the cache
    Specified by:
      `clearAll` in interface `EvictableCache<K,​V>`
    Returns:
      returns the content of the cleared map

  - ### values

    public Collection<V> values()
    Get all cached values
    Specified by:
      `values` in interface `EvictableCache<K,​V>`
    Specified by:
      `values` in interface `Map<K,​V>`
    Returns:
      all cached values

  - ### entrySet

    public Set<Map.Entry<K,​V>> entrySet()
    Specified by:
      `entrySet` in interface `Map<K,​V>`

  - ### keys

    public Set<K> keys()
    Get all keys associated to cached values
    Specified by:
      `keys` in interface `EvictableCache<K,​V>`
    Returns:
      all keys

  - ### containsKey

    public boolean containsKey​(Object key)
    Determines if the cache contains an entry for the specified key.
    Specified by:
      `containsKey` in interface `EvictableCache<K,​V>`
    Specified by:
      `containsKey` in interface `Map<K,​V>`
    Parameters:
      `key` - key whose presence in this cache is to be tested.
    Returns:
      true if the cache contains a mapping for the specified key

  - ### containsValue

    public boolean containsValue​(Object value)
    Specified by:
      `containsValue` in interface `Map<K,​V>`

  - ### size

    public int size()
    Get the size of the cache
    Specified by:
      `size` in interface `EvictableCache<K,​V>`
    Specified by:
      `size` in interface `Map<K,​V>`
    Returns:
      the size of the cache

  - ### isEmpty

    public boolean isEmpty()
    Specified by:
      `isEmpty` in interface `Map<K,​V>`

  - ### put

    public V put​(K key, V value)
    Associates the specified value with the specified key in the cache.
    Specified by:
      `put` in interface `Map<K,​V>`
    Specified by:
      `put` in interface `MemoizeCache<K,​V>`
    Parameters:
      `key` - key with which the specified value is to be associated
      `value` - value to be associated with the specified key
    Returns:
      null, or the old value if the key associated with the specified key.

  - ### get

    public V get​(Object key)
    Gets a value from the cache
    Specified by:
      `get` in interface `Map<K,​V>`
    Specified by:
      `get` in interface `MemoizeCache<K,​V>`
    Parameters:
      `key` - the key whose associated value is to be returned
    Returns:
      the value, or null, if it does not exist.

  - ### getAndPut

    public V getAndPut​(K key, MemoizeCache.ValueProvider<? super K,​? extends V> valueProvider)
    Try to get the value from cache. If not found, create the value by `MemoizeCache.ValueProvider` and put it into the cache, at last return the value.
    Specified by:
      `getAndPut` in interface `MemoizeCache<K,​V>`
    Parameters:
      `key` -
      `valueProvider` - provide the value if the associated value not found
    Returns:
      the cached value

  - ### cleanUpNullReferences

    public void cleanUpNullReferences()
    Replying on the ConcurrentHashMap thread-safe iteration implementation the method will remove all entries holding SoftReferences to gc-evicted objects.
    Specified by:
      `cleanUpNullReferences` in interface `MemoizeCache<K,​V>`