TransformingMap (LibFX 0.3.0 API)

java.lang.Object
- org.codefx.libfx.collection.transform.TransformingMap<IK,OK,IV,OV>

Type Parameters:

IK - the inner key type, i.e. the type of the keys contained in the wrapped/inner map

OK - the outer key type, i.e. the type of keys appearing to be in this map

IV - the inner value type, i.e. the type of the values contained in the wrapped/inner map

OV - the outer value type, i.e. the type of values appearing to be in this map

All Implemented Interfaces:

Map<OK,OV>
```
public final class TransformingMap<IK,OK,IV,OV>
extends Object
```
A Map which decorates another map and transforms the key and value types from the inner types IK, IV to outer types OK, OV.
See the package documentation for general comments on transformation.
This implementation mitigates the type safety problems by using tokens of the inner and the outer types to check instances against them. This solves some of the critical situations but not all of them. In those other cases ClassCastExceptions might occur when an element can not be transformed by the transformation functions.
Null keys and values are allowed unless the inner map does not accept them. These are handled explicitly and fixed to the transformation null -> null. The transforming functions specified during construction neither have to handle that case nor are they allowed to produce null elements.
If the streams returned by this map's views are told to sort themself, they will do so on the base of the comparator returned by the inner map view's spliterator (e.g. based on the natural order of IK or IV if it has one).
TransformingMaps are created with a TransformingMapBuilder.

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<IK,IV>`	`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 IK`	`transformToInnerKey(OK outerKey)` Transforms the specified key to an instance of the inner key type.
`protected IV`	`transformToInnerValue(OV outerValue)` Transforms the specified value to an instance of the inner value type.
`protected OK`	`transformToOuterKey(IK innerKey)` Transforms the specified key to an instance of the outer key type.
`protected OV`	`transformToOuterValue(IV 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<IK,IV> 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 OK transformToOuterKey(IK innerKey)
```
    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
  - 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 IK transformToInnerKey(OK outerKey)
```
    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
  - 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 OV transformToOuterValue(IV innerValue)
```
    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
  - 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 IV transformToInnerValue(OV outerValue)
```
    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
  - 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 TransformingMap<IK,OK,IV,OV>

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