com.fasterxml.jackson.databind.util.internal

## Class PrivateMaxEntriesMap<K,V>

- java.lang.Object
- - java.util.AbstractMap<K,V>
  - - com.fasterxml.jackson.databind.util.internal.PrivateMaxEntriesMap<K,V>

Type Parameters:
  `K` - the type of keys maintained by this map
  `V` - the type of mapped values

All Implemented Interfaces:
  Serializable, ConcurrentMap<K,V>, Map<K,V>

    public final class PrivateMaxEntriesMap<K,V>
    extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable

A hash table supporting full concurrency of retrievals, adjustable expected concurrency for updates, and a maximum capacity to bound the map by. This implementation differs from `ConcurrentHashMap` in that it maintains a page replacement algorithm that is used to evict an entry when the map has exceeded its capacity. Unlike the `Java Collections Framework`, this map does not have a publicly visible constructor and instances are created through a `PrivateMaxEntriesMap.Builder`.

An entry is evicted from the map when the entry size exceeds its `maximum capacity` threshold.

An `EvictionListener` may be supplied for notification when an entry is evicted from the map. This listener is invoked on a caller's thread and will not block other threads from operating on the map. An implementation should be aware that the caller's thread will not expect long execution times or failures as a side effect of the listener being notified. Execution safety and a fast turn around time can be achieved by performing the operation asynchronously, such as by submitting a task to an `ExecutorService`.

The `concurrency level` determines the number of threads that can concurrently modify the table. Using a significantly higher or lower value than needed can waste space or lead to thread contention, but an estimate within an order of magnitude of the ideal value does not usually have a noticeable impact. Because placement in hash tables is essentially random, the actual concurrency will vary.

This class and its views and iterators implement all of the optional methods of the `Map` and `Iterator` interfaces.

Like `Hashtable` but unlike `HashMap`, this class does not allow `null` to be used as a key or value. Unlike `LinkedHashMap`, this class does not provide predictable iteration order. A snapshot of the keys and entries may be obtained in ascending and descending order of retention.

Author:
  ben.manes@gmail.com (Ben Manes)
See Also:
  http://code.google.com/p/concurrentlinkedhashmap/, Serialized Form

### Nested Class Summary

Nested Classes
`static class` `PrivateMaxEntriesMap.Builder<K,V>` A builder that creates `PrivateMaxEntriesMap` instances.

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

`AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V>`

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

`Map.Entry<K,V>`

### Method Summary

All Methods Instance Methods Concrete Methods
`long` `capacity()` Retrieves the maximum capacity of the map.
`void` `clear()`
`boolean` `containsKey(Object key)`
`boolean` `containsValue(Object value)`
`Set<Map.Entry<K,V>>` `entrySet()`
`V` `get(Object key)`
`boolean` `isEmpty()`
`Set<K>` `keySet()`
`V` `put(K key, V value)`
`V` `putIfAbsent(K key, V value)`
`V` `remove(Object key)`
`boolean` `remove(Object key, Object value)`
`V` `replace(K key, V value)`
`boolean` `replace(K key, V oldValue, V newValue)`
`void` `setCapacity(long capacity)` Sets the maximum capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.
`int` `size()`
`Collection<V>` `values()`

### Methods inherited from class java.util.AbstractMap

`clone, equals, hashCode, putAll, toString`

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

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

### Methods inherited from interface java.util.concurrent.ConcurrentMap

`compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll`

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

`equals, hashCode, putAll`

### Method Detail

#### capacity

    public long capacity()

Retrieves the maximum capacity of the map.

Returns:
  the maximum capacity

#### setCapacity

    public void setCapacity(long capacity)

Sets the maximum capacity of the map and eagerly evicts entries until it shrinks to the appropriate size.

Parameters:
  `capacity` - the maximum capacity of the map
Throws:
  `IllegalArgumentException` - if the capacity is negative

#### isEmpty

    public boolean isEmpty()

Specified by:
  `isEmpty` in interface `Map<K,V>`
Overrides:
  `isEmpty` in class `AbstractMap<K,V>`

#### size

    public int size()

Specified by:
  `size` in interface `Map<K,V>`
Overrides:
  `size` in class `AbstractMap<K,V>`

#### clear

    public void clear()

Specified by:
  `clear` in interface `Map<K,V>`
Overrides:
  `clear` in class `AbstractMap<K,V>`

#### containsKey

    public boolean containsKey(Object key)

Specified by:
  `containsKey` in interface `Map<K,V>`
Overrides:
  `containsKey` in class `AbstractMap<K,V>`

#### containsValue

    public boolean containsValue(Object value)

Specified by:
  `containsValue` in interface `Map<K,V>`
Overrides:
  `containsValue` in class `AbstractMap<K,V>`

#### get

    public V get(Object key)

Specified by:
  `get` in interface `Map<K,V>`
Overrides:
  `get` in class `AbstractMap<K,V>`

#### put

    public V put(K key,
                 V value)

Specified by:
  `put` in interface `Map<K,V>`
Overrides:
  `put` in class `AbstractMap<K,V>`

#### putIfAbsent

    public V putIfAbsent(K key,
                         V value)

Specified by:
  `putIfAbsent` in interface `ConcurrentMap<K,V>`
Specified by:
  `putIfAbsent` in interface `Map<K,V>`

#### remove

    public V remove(Object key)

Specified by:
  `remove` in interface `Map<K,V>`
Overrides:
  `remove` in class `AbstractMap<K,V>`

#### remove

    public boolean remove(Object key,
                          Object value)

Specified by:
  `remove` in interface `ConcurrentMap<K,V>`
Specified by:
  `remove` in interface `Map<K,V>`

#### replace

    public V replace(K key,
                     V value)

Specified by:
  `replace` in interface `ConcurrentMap<K,V>`
Specified by:
  `replace` in interface `Map<K,V>`

#### replace

    public boolean replace(K key,
                           V oldValue,
                           V newValue)

Specified by:
  `replace` in interface `ConcurrentMap<K,V>`
Specified by:
  `replace` in interface `Map<K,V>`

#### keySet

    public Set<K> keySet()

Specified by:
  `keySet` in interface `Map<K,V>`
Overrides:
  `keySet` in class `AbstractMap<K,V>`

#### values

    public Collection<V> values()

Specified by:
  `values` in interface `Map<K,V>`
Overrides:
  `values` in class `AbstractMap<K,V>`

#### entrySet

    public Set<Map.Entry<K,V>> entrySet()

Specified by:
  `entrySet` in interface `Map<K,V>`
Specified by:
  `entrySet` in class `AbstractMap<K,V>`