LazyIndexedMap (Hibernate Javadocs)

java.lang.Object
- org.hibernate.internal.util.collections.LazyIndexedMap<K,V>

Type Parameters:

K - the types used to model the key

V - the types used to model the value

Direct Known Subclasses:

LockModeEnumMap
```
public abstract class LazyIndexedMap<K,V>
extends Object
```
This is an internal data structure designed for very specific needs; it will most often be used as a replacement for EnumMap, although the focus on the Enum aspect is modelled as an int primitive: think of using the ordinals of an Enum to simulate the EnumMap. Proper abstraction of the indexing strategy is left to subclasses.
There are various reasons to not expose the Enum on this class API; the primary is that in some of the cases in which we need the pattern, there is the need to hold an additional couple of values beyond the ones modelled by the Enum, essentially having some extra keys in the map; this could be modelled by defining a new Enum but that's also not ideal.
Another reason is that the goal of this class is to allow the host to save memory, as we typically need to keep references to many of these objects for a long time; being able to refer purely to an array is less practical but gets us benefits in memory layout and total retained memory.

Constructor Summary

Constructors
Modifier Constructor Description

protected LazyIndexedMap(int size)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected <K1 extends K> V`	`computeIfAbsent(int index, K1 originalKey, Function<K1,V> valueGenerator)`	Both the index and the original key are requested for efficiency reasons.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - LazyIndexedMap
```
protected LazyIndexedMap(int size)
```
- Method Detail
  - computeIfAbsent
```
protected <K1 extends K> V computeIfAbsent(int index,
                                           K1 originalKey,
                                           Function<K1,V> valueGenerator)
```
    Both the index and the original key are requested for efficiency reasons. It is the responsibility of the caller to ensure there is a 1:1 matching relation between them.
    
    Parameters:
    
    index - storage index in the array
    
    originalKey - the original key object, used to efficiently pass it into the valueGenerator function
    
    valueGenerator - if no value was generated before for this index, then the valueGenerator is invoked to associate a new value and store it into the internal array at the provided index.
    
    Returns:
    
    the associated value to this index/key.