EqualityTransformingMap (LibFX 0.3.0 API)

java.lang.Object
- org.codefx.libfx.collection.transform.EqualityTransformingMap<K,V>

Type Parameters:

K - the type of keys maintained by this map

V - the type of mapped values

All Implemented Interfaces:

Map<K,V>
```
public final class EqualityTransformingMap<K,V>
extends Object
```
An equality transforming map allows to define the implementations of equals and hashCode which are used for the map's keys.
It does so by storing the entries in an inner map and providing a transforming view on them. See the package documentation for general comments on that. Note that instances of EqualityTransformingMaps are created with a builder.
This implementation mitigates the type safety problems by optionally using a token of the (outer) key type to check instances against them. This solves some of the critical situations but not all of them. In those other cases ClassCastExceptions might still occur.
By default the inner map will be a new HashMap but the another map can be provided to the builder. Such instances must be empty and not be referenced anywhere else. The implementations of equals and hashCode are provided as functions to the builder - see there for details.
The transformations used by this map preserve object identity of outer keys and values. This means if keys and values are added to this map, an iteration over it will return the same instances.
EqualityTransformingMaps are created with a EqualityTransformingCollectionBuilder.

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

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`OV`	`compute(OK key, BiFunction<? super OK,? super OV,? extends OV> remappingFunction)`
`OV`	`computeIfAbsent(OK key, Function<? super OK,? extends OV> mappingFunction)`
`OV`	`computeIfPresent(OK key, BiFunction<? super OK,? super OV,? extends OV> remappingFunction)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<OK,OV>>`	`entrySet()`
`boolean`	`equals(Object object)`
`void`	`forEach(BiConsumer<? super OK,? super OV> action)`
`OV`	`get(Object key)`
`protected Map<org.codefx.libfx.collection.transform.EqHash<K>,V>`	`getInnerMap()`
`OV`	`getOrDefault(Object key, OV defaultValue)`
`int`	`hashCode()`
`boolean`	`isEmpty()`
`protected boolean`	`isInnerKey(Object object)` Checks whether the specified object might be an inner key.
`protected boolean`	`isInnerValue(Object object)` Checks whether the specified object might be an inner value.
`protected boolean`	`isOuterKey(Object object)` Checks whether the specified object might be an outer key.
`protected boolean`	`isOuterValue(Object object)` Checks whether the specified object might be an outer value.
`protected boolean`	`isThisMap(Map<?,?> otherMap)` Indicates whether the specified collection is equivalent to this one.
`Set<OK>`	`keySet()`
`OV`	`merge(OK key, OV value, BiFunction<? super OV,? super OV,? extends OV> remappingFunction)`
`OV`	`put(OK key, OV value)`
`void`	`putAll(Map<? extends OK,? extends OV> outerMap)`
`OV`	`putIfAbsent(OK key, OV value)`
`OV`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`OV`	`replace(OK key, OV value)`
`boolean`	`replace(OK key, OV oldValue, OV newValue)`
`void`	`replaceAll(BiFunction<? super OK,? super OV,? extends OV> function)`
`int`	`size()`
`String`	`toString()`
`protected org.codefx.libfx.collection.transform.EqHash<K>`	`transformToInnerKey(K outerKey)` Transforms the specified key to an instance of the inner key type.
`protected V`	`transformToInnerValue(V outerValue)` Transforms the specified value to an instance of the inner value type.
`protected K`	`transformToOuterKey(org.codefx.libfx.collection.transform.EqHash<K> innerKey)` Transforms the specified key to an instance of the outer key type.
`protected V`	`transformToOuterValue(V innerValue)` Transforms the specified value to an instance of the outer value type.
`Collection<OV>`	`values()`

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

- Method Detail
  - getInnerMap
```
protected Map<org.codefx.libfx.collection.transform.EqHash<K>,V> getInnerMap()
```
    Returns:
    
    the inner map wrapped by this transforming map
  - isInnerKey
```
protected boolean isInnerKey(Object object)
```
    Checks whether the specified object might be an inner key.
    This method does not have to be exact (which might be impossible due to involved generic types) and might produce false positives (but no false negatives).
    
    Parameters:
    
    object - the object to check; may be null
    
    Returns:
    
    true if the object might be an inner key
  - transformToOuterKey
```
protected K transformToOuterKey(org.codefx.libfx.collection.transform.EqHash<K> innerKey)
                         throws ClassCastException
```
    Transforms the specified key to an instance of the outer key type.
    It can not be guaranteed that the specified key is really of the inner key type. If not, an exception can be thrown.
    
    Parameters:
    
    innerKey - the key to transform; may be null
    
    Returns:
    
    the transformed key
    
    Throws:
    
    ClassCastException - if the specified key is not of the correct type
  - isOuterKey
```
protected boolean isOuterKey(Object object)
```
    Checks whether the specified object might be an outer key.
    This method does not have to be exact (which might be impossible due to involved generic types) and might produce false positives (but no false negatives).
    
    Parameters:
    
    object - the object to check; may be null
    
    Returns:
    
    true if the object might be an outer key
  - transformToInnerKey
```
protected org.codefx.libfx.collection.transform.EqHash<K> transformToInnerKey(K outerKey)
                                                                       throws ClassCastException
```
    Transforms the specified key to an instance of the inner key type.
    It can not be guaranteed that the specified key is really of the outer key type. If not, an exception can be thrown.
    
    Parameters:
    
    outerKey - the key to transform; may be null
    
    Returns:
    
    the transformed key
    
    Throws:
    
    ClassCastException - if the specified key is not of the correct type
  - isInnerValue
```
protected boolean isInnerValue(Object object)
```
    Checks whether the specified object might be an inner value.
    This method does not have to be exact (which might be impossible due to involved generic types) and might produce false positives (but no false negatives).
    
    Parameters:
    
    object - the object to check; may be null
    
    Returns:
    
    true if the object might be an inner value
  - transformToOuterValue
```
protected V transformToOuterValue(V innerValue)
                           throws ClassCastException
```
    Transforms the specified value to an instance of the outer value type.
    It can not be guaranteed that the specified value is really of the inner value type. If not, an exception can be thrown.
    
    Parameters:
    
    innerValue - the value to transform; may be null
    
    Returns:
    
    the transformed value
    
    Throws:
    
    ClassCastException - if the specified value is not of the correct type
  - isOuterValue
```
protected boolean isOuterValue(Object object)
```
    Checks whether the specified object might be an outer value.
    This method does not have to be exact (which might be impossible due to involved generic types) and might produce false positives (but no false negatives).
    
    Parameters:
    
    object - the object to check; may be null
    
    Returns:
    
    true if the object might be an outer value
  - transformToInnerValue
```
protected V transformToInnerValue(V outerValue)
                           throws ClassCastException
```
    Transforms the specified value to an instance of the inner value type.
    It can not be guaranteed that the specified value is really of the outer value type. If not, an exception can be thrown.
    
    Parameters:
    
    outerValue - the value to transform; may be null
    
    Returns:
    
    the transformed value
    
    Throws:
    
    ClassCastException - if the specified value is not of the correct type
  - isThisMap
```
protected final boolean isThisMap(Map<?,?> otherMap)
```
    Indicates whether the specified collection is equivalent to this one. This is the case if it is also an AbstractTransformingMap and wraps the same innerMap.
    
    Parameters:
    
    otherMap - the Collection which is compared with this one
    
    Returns:
    
    true if this and the specified collection are equivalent
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<OK,OV>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<OK,OV>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<OK,OV>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<OK,OV>
  - get
```
public OV get(Object key)
```
    Specified by:
    
    get in interface Map<OK,OV>
  - getOrDefault
```
public OV getOrDefault(Object key,
                       OV defaultValue)
```
    Specified by:
    
    getOrDefault in interface Map<OK,OV>
  - put
```
public OV put(OK key,
              OV value)
```
    Specified by:
    
    put in interface Map<OK,OV>
  - putIfAbsent
```
public OV putIfAbsent(OK key,
                      OV value)
```
    Specified by:
    
    putIfAbsent in interface Map<OK,OV>
  - putAll
```
public void putAll(Map<? extends OK,? extends OV> outerMap)
```
    Specified by:
    
    putAll in interface Map<OK,OV>
  - compute
```
public OV compute(OK key,
                  BiFunction<? super OK,? super OV,? extends OV> remappingFunction)
```
    Specified by:
    
    compute in interface Map<OK,OV>
  - computeIfAbsent
```
public OV computeIfAbsent(OK key,
                          Function<? super OK,? extends OV> mappingFunction)
```
    Specified by:
    
    computeIfAbsent in interface Map<OK,OV>
  - computeIfPresent
```
public OV computeIfPresent(OK key,
                           BiFunction<? super OK,? super OV,? extends OV> remappingFunction)
```
    Specified by:
    
    computeIfPresent in interface Map<OK,OV>
  - merge
```
public OV merge(OK key,
                OV value,
                BiFunction<? super OV,? super OV,? extends OV> remappingFunction)
```
    Specified by:
    
    merge in interface Map<OK,OV>
  - replace
```
public OV replace(OK key,
                  OV value)
```
    Specified by:
    
    replace in interface Map<OK,OV>
  - replace
```
public boolean replace(OK key,
                       OV oldValue,
                       OV newValue)
```
    Specified by:
    
    replace in interface Map<OK,OV>
  - replaceAll
```
public void replaceAll(BiFunction<? super OK,? super OV,? extends OV> function)
```
    Specified by:
    
    replaceAll in interface Map<OK,OV>
  - remove
```
public OV remove(Object key)
```
    Specified by:
    
    remove in interface Map<OK,OV>
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface Map<OK,OV>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<OK,OV>
  - forEach
```
public void forEach(BiConsumer<? super OK,? super OV> action)
```
    Specified by:
    
    forEach in interface Map<OK,OV>
  - keySet
```
public Set<OK> keySet()
```
    Specified by:
    
    keySet in interface Map<OK,OV>
  - values
```
public Collection<OV> values()
```
    Specified by:
    
    values in interface Map<OK,OV>
  - entrySet
```
public Set<Map.Entry<OK,OV>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<OK,OV>
  - equals
```
public final boolean equals(Object object)
```
    Specified by:
    
    equals in interface Map<OK,OV>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public final int hashCode()
```
    Specified by:
    
    hashCode in interface Map<OK,OV>
    
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

This documentation is licensed under CC-BY 4.0, attributed to Nicolai Parlog from CodeFX.

Class EqualityTransformingMap<K,V>

Nested Class Summary

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

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getInnerMap

isInnerKey

transformToOuterKey

isOuterKey

transformToInnerKey

isInnerValue

transformToOuterValue

isOuterValue

transformToInnerValue

isThisMap

size

isEmpty

containsKey

containsValue

get

getOrDefault

put

putIfAbsent

putAll

compute

computeIfAbsent

computeIfPresent

merge

replace

replace

replaceAll

remove

remove

clear

forEach

keySet

values

entrySet

equals

hashCode

toString