CompactStringMap

Object
- com.xilinx.rapidwright.util.CompactStringMap<V>

Type Parameters:

V - Type of the values.

All Implemented Interfaces:

Map<String,V>
```
public class CompactStringMap<V>
extends Object
implements Map<String,V>
```
A memory-compact, open-addressing (linear probing) Map from String keys to values, intended for the very large name-keyed maps of a netlist or design (such as the instances and nets of an EDIFCell, or the cells and nets of a Design).
Unlike HashMap, no per-entry Node or Entry object is allocated. The map runs in one of two modes:
- Derived-key mode (created with a key function): only the values are stored and the key of an entry is obtained from its value through the key function (for example the object's name). This costs one reference plus one byte per table slot.
- Keyed mode (created without a key function): parallel key and value arrays, for maps whose key cannot be derived from the value. This costs two references plus one byte per slot.
A derived-key map transparently switches to keyed mode (keeping all its entries) the first time an entry is put under a key that is not the value's derived key, or with a null value, so that it always keeps the full Map semantics. A value's derived key must not change while the value is in a derived-key map: remove it under its old key before renaming it, then put it back.
Each slot has a one-byte tag: empty, removed (a tombstone), or seven bits of the key's hash. Probing scans the tags and only reads a value (and its key) when the tag matches, so a lookup reads about as many objects as a HashMap lookup, and an absent key usually reads none. Lookups use the cached String.hashCode() of the keys. Null keys and null values are supported. Removal leaves a tombstone (or an empty slot when possible), so that entries never move except when the table is rebuilt on growth. Iteration order is the table order, which, as for HashMap, depends on the keys and on the history of insertions; it is not the insertion order. Iterators are fail-fast on a best-effort basis and support Iterator.remove().
Like HashMap, this class is not thread-safe: concurrent reads are safe as long as no thread modifies the map concurrently (lookups do not modify any state).

Nested Class Summary
- Nested classes/interfaces inherited from interface Map
  Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description
`CompactStringMap()` Creates an empty map in keyed mode (parallel key and value arrays).
`CompactStringMap(Function<? super V,String> keyFn)` Creates an empty map in derived-key mode.
`CompactStringMap(Function<? super V,String> keyFn, int expectedSize)` Creates an empty map in derived-key mode with room for the expected number of entries.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<String,V>>`	`entrySet()`
`boolean`	`equals(Object o)`
`void`	`forEach(BiConsumer<? super String,? super V> action)`
`V`	`get(Object key)`
`V`	`getOrDefault(Object key, V defaultValue)`
`int`	`hashCode()`
`boolean`	`isEmpty()`
`boolean`	`isKeyed()`
`Set<String>`	`keySet()`
`V`	`put(String key, V value)`
`void`	`putAll(Map<? extends String,? extends V> m)`
`V`	`putIfAbsent(String key, V value)`
`V`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`int`	`size()`
`String`	`toString()`
`Collection<V>`	`values()`

Methods inherited from class Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface Map
compute, computeIfAbsent, computeIfPresent, merge, replace, replace, replaceAll

- Constructor Detail
  - CompactStringMap
```
public CompactStringMap()
```
    Creates an empty map in keyed mode (parallel key and value arrays).
  - CompactStringMap
```
public CompactStringMap(Function<? super V,String> keyFn)
```
    Creates an empty map in derived-key mode.
    
    Parameters:
    
    keyFn - Gets the key of a value. It must accept any value put in the map and must not return a different key for a value while the value is in the map.
  - CompactStringMap
```
public CompactStringMap(Function<? super V,String> keyFn,
                        int expectedSize)
```
    Creates an empty map in derived-key mode with room for the expected number of entries.
    
    Parameters:
    
    keyFn - See CompactStringMap.CompactStringMap(Function).
    
    expectedSize - Number of entries the map can hold without growing.
- Method Detail
  - isKeyed
```
public boolean isKeyed()
```
    Returns:
    
    True if this map stores its keys (keyed mode), false if it derives them from its values.
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<String,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<String,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<String,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<String,V>
  - getOrDefault
```
public V getOrDefault(Object key,
                      V defaultValue)
```
    Specified by:
    
    getOrDefault in interface Map<String,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<String,V>
  - put
```
public V put(String key,
             V value)
```
    Specified by:
    
    put in interface Map<String,V>
  - putIfAbsent
```
public V putIfAbsent(String key,
                     V value)
```
    Specified by:
    
    putIfAbsent in interface Map<String,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<String,V>
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface Map<String,V>
  - putAll
```
public void putAll(Map<? extends String,? extends V> m)
```
    Specified by:
    
    putAll in interface Map<String,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<String,V>
  - forEach
```
public void forEach(BiConsumer<? super String,? super V> action)
```
    Specified by:
    
    forEach in interface Map<String,V>
  - keySet
```
public Set<String> keySet()
```
    Specified by:
    
    keySet in interface Map<String,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<String,V>
  - entrySet
```
public Set<Map.Entry<String,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<String,V>
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Map<String,V>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<String,V>
    
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class CompactStringMap<V>

Nested Class Summary

Nested classes/interfaces inherited from interface Map

Constructor Summary

Method Summary

Methods inherited from class Object

Methods inherited from interface Map

Constructor Detail

CompactStringMap

CompactStringMap

CompactStringMap

Method Detail

isKeyed

size

isEmpty

containsKey

get

getOrDefault

containsValue

put

putIfAbsent

remove

remove

putAll

clear

forEach

keySet

values

entrySet

equals

hashCode

toString