speiger.src.collections.objects.maps.interfaces

Interface Object2ShortMap<T>

Type Parameters:

T - the keyType of elements maintained by this Collection

All Superinterfaces:

java.util.Map<T,java.lang.Short>, ToShortFunction<T>

All Known Subinterfaces:

Object2ShortConcurrentMap<T>, Object2ShortNavigableMap<T>, Object2ShortOrderedMap<T>, Object2ShortSortedMap<T>

All Known Implementing Classes:

AbstractObject2ShortMap, Enum2ShortMap, ImmutableObject2ShortOpenHashMap, LinkedEnum2ShortMap, Object2ShortArrayMap, Object2ShortAVLTreeMap, Object2ShortConcurrentOpenHashMap, Object2ShortLinkedOpenCustomHashMap, Object2ShortLinkedOpenHashMap, Object2ShortMaps.EmptyMap, Object2ShortMaps.SingletonMap, Object2ShortMaps.SynchronizedMap, Object2ShortMaps.SynchronizedNavigableMap, Object2ShortMaps.SynchronizedOrderedMap, Object2ShortMaps.SynchronizedSortedMap, Object2ShortMaps.UnmodifyableMap, Object2ShortMaps.UnmodifyableNavigableMap, Object2ShortMaps.UnmodifyableOrderedMap, Object2ShortMaps.UnmodifyableSortedMap, Object2ShortOpenCustomHashMap, Object2ShortOpenHashMap, Object2ShortRBTreeMap

public interface Object2ShortMap<T>
extends java.util.Map<T,java.lang.Short>, ToShortFunction<T>

A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Object2ShortMap.BuilderCache<T> Builder Cache for allowing to buildMaps
static interface	Object2ShortMap.Entry<T> Type Specific Map Entry that reduces boxing/unboxing
static interface	Object2ShortMap.FastEntrySet<T> Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
static class	Object2ShortMap.MapBuilder Helper class that reduces the method spam of the Map Class.

Method Summary

Modifier and Type	Method and Description
short	addTo(T key, short value) A Helper method to add a primitives together.
void	addToAll(Object2ShortMap<T> m) A Helper method to bulk add primitives together.
default short	applyAsShort(T key) Type Specific get function to reduce boxing/unboxing
static Object2ShortMap.MapBuilder	builder() Helper Class that allows to create Maps without requiring a to type out the entire implementation or know it.
default java.lang.Short	compute(T key, java.util.function.BiFunction<? super T,? super java.lang.Short,? extends java.lang.Short> mappingFunction)
default java.lang.Short	computeIfAbsent(T key, java.util.function.Function<? super T,? extends java.lang.Short> mappingFunction)
default java.lang.Short	computeIfPresent(T key, java.util.function.BiFunction<? super T,? super java.lang.Short,? extends java.lang.Short> mappingFunction)
short	computeShort(T key, ObjectShortUnaryOperator<T> mappingFunction) A Type Specific compute method to reduce boxing/unboxing
short	computeShortIfAbsent(T key, ToShortFunction<T> mappingFunction) A Type Specific compute method to reduce boxing/unboxing
short	computeShortIfPresent(T key, ObjectShortUnaryOperator<T> mappingFunction) A Type Specific compute method to reduce boxing/unboxing
default boolean	containsValue(java.lang.Object value)
boolean	containsValue(short value) Type Specific method to reduce boxing/unboxing of values
Object2ShortMap<T>	copy() A Function that does a shallow clone of the Map itself.
ObjectSet<java.util.Map.Entry<T,java.lang.Short>>	entrySet()
default void	forEach(java.util.function.BiConsumer<? super T,? super java.lang.Short> action)
void	forEach(ObjectShortConsumer<T> action) Type Specific forEach method to reduce boxing/unboxing
default java.lang.Short	get(java.lang.Object key)
short	getDefaultReturnValue() Method to see what the default return value is.
default java.lang.Short	getOrDefault(java.lang.Object key, java.lang.Short defaultValue)
short	getOrDefault(T key, short defaultValue) A Type Specific getOrDefault method to reduce boxing/unboxing
short	getShort(T key) A Type Specific get method to reduce boxing/unboxing
ObjectSet<T>	keySet()
default java.lang.Short	merge(T key, java.lang.Short value, java.util.function.BiFunction<? super java.lang.Short,? super java.lang.Short,? extends java.lang.Short> mappingFunction)
void	mergeAllShort(Object2ShortMap<T> m, ShortShortUnaryOperator mappingFunction) A Bulk method for merging Maps.
short	mergeShort(T key, short value, ShortShortUnaryOperator mappingFunction) A Type Specific merge method to reduce boxing/unboxing
ObjectSet<Object2ShortMap.Entry<T>>	object2ShortEntrySet() Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.
default java.lang.Short	put(java.util.Map.Entry<T,java.lang.Short> entry) A Helper method that allows to put int a Map.Entry into a map.
default short	put(Object2ShortMap.Entry<T> entry) A Helper method that allows to put int a Object2ShortMap.Entry into a map.
short	put(T key, short value) Type Specific method to reduce boxing/unboxing of values
default java.lang.Short	put(T key, java.lang.Short value)
void	putAll(Object2ShortMap<T> m) Type Specific function for the bull putting of values
default void	putAll(T[] keys, short[] values) Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
default void	putAll(T[] keys, java.lang.Short[] values) Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances
void	putAll(T[] keys, short[] values, int offset, int size) Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances
void	putAll(T[] keys, java.lang.Short[] values, int offset, int size) Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances
void	putAllIfAbsent(Object2ShortMap<T> m) Type-Specific bulk put method put elements into the map if not present.
short	putIfAbsent(T key, short value) Type Specific method to reduce boxing/unboxing of values
default java.lang.Short	putIfAbsent(T key, java.lang.Short value)
short	rem(T key) Type Specific remove function to reduce boxing/unboxing
short	remOrDefault(T key, short defaultValue) Type-Specific Remove function with a default return value if wanted.
default java.lang.Short	remove(java.lang.Object key)
default boolean	remove(java.lang.Object key, java.lang.Object value)
boolean	remove(T key, short value) Type Specific remove function to reduce boxing/unboxing
short	replace(T key, short value) A Type Specific replace method to reduce boxing/unboxing replace an existing value
default java.lang.Short	replace(T key, java.lang.Short value)
boolean	replace(T key, short oldValue, short newValue) A Type Specific replace method to replace an existing value
default boolean	replace(T key, java.lang.Short oldValue, java.lang.Short newValue)
default void	replaceAll(java.util.function.BiFunction<? super T,? super java.lang.Short,? extends java.lang.Short> mappingFunction)
void	replaceShorts(Object2ShortMap<T> m) Type-Specific bulk replace method.
void	replaceShorts(ObjectShortUnaryOperator<T> mappingFunction) A Type Specific mass replace method to reduce boxing/unboxing
Object2ShortMap<T>	setDefaultReturnValue(short v) Method to define the default return value if a requested key isn't present
short	subFrom(T key, short value) A Helper method to subtract from primitive from each other.
short	supplyShortIfAbsent(T key, ShortSupplier valueProvider) A Supplier based computeIfAbsent function to fill the most used usecase of this function
default Object2ShortMap<T>	synchronize() Creates a Wrapped Map that is Synchronized
default Object2ShortMap<T>	synchronize(java.lang.Object mutex) Creates a Wrapped Map that is Synchronized
default Object2ShortMap<T>	unmodifiable() Creates a Wrapped Map that is unmodifiable
ShortCollection	values()

Methods inherited from interface java.util.Map

clear, containsKey, equals, hashCode, isEmpty, putAll, size

Method Detail

builder

static Object2ShortMap.MapBuilder builder()

Helper Class that allows to create Maps without requiring a to type out the entire implementation or know it.

Returns:

a MapBuilder

getDefaultReturnValue

short getDefaultReturnValue()

Method to see what the default return value is.

Returns:

default return value

setDefaultReturnValue

Object2ShortMap<T> setDefaultReturnValue(short v)

Method to define the default return value if a requested key isn't present

Parameters:

v - value that should be the default return value

Returns:

itself

copy

Object2ShortMap<T> copy()

A Function that does a shallow clone of the Map itself. This function is more optimized then a copy constructor since the Map does not have to be unsorted/resorted. It can be compared to Cloneable but with less exception risk

Returns:

a Shallow Copy of the Map

Note:

Wrappers and view Maps will not support this feature

put

short put(T key,
          short value)

Type Specific method to reduce boxing/unboxing of values

Parameters:

key - the key that should be inserted,

value - the value that should be inserted

Returns:

the last present value or default return value.

See Also:

Map.put(Object, Object)

put

default short put(Object2ShortMap.Entry<T> entry)

A Helper method that allows to put int a Object2ShortMap.Entry into a map.

Parameters:

entry - then Entry that should be inserted.

Returns:

the last present value or default return value.

put

default java.lang.Short put(java.util.Map.Entry<T,java.lang.Short> entry)

A Helper method that allows to put int a Map.Entry into a map.

Parameters:

entry - then Entry that should be inserted.

Returns:

the last present value or default return value.

putAll

default void putAll(T[] keys,
                    short[] values)

Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances

Parameters:

keys - the keys that should be added

values - the values that should be added

Throws:

java.lang.IllegalStateException - if the arrays are not the same size

See Also:

Map.putAll(Map)

putAll

void putAll(T[] keys,
            short[] values,
            int offset,
            int size)

Type Specific array method to bulk add elements into a map without creating a wrapper and increasing performances

Parameters:

keys - the keys that should be added

values - the values that should be added

offset - where the to start in the array

size - how many elements should be added

Throws:

java.lang.IllegalStateException - if the arrays are not within the range

See Also:

Map.putAll(Map)

putAll

default void putAll(T[] keys,
                    java.lang.Short[] values)

Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances

Parameters:

keys - the keys that should be added

values - the values that should be added

Throws:

java.lang.IllegalStateException - if the arrays are not the same size

See Also:

Map.putAll(Map)

putAll

void putAll(T[] keys,
            java.lang.Short[] values,
            int offset,
            int size)

Type Specific Object array method to bulk add elements into a map without creating a wrapper and increasing performances

Parameters:

keys - the keys that should be added

values - the values that should be added

offset - where the to start in the array

size - how many elements should be added

Throws:

java.lang.IllegalStateException - if the arrays are not within the range

See Also:

Map.putAll(Map)

putIfAbsent

short putIfAbsent(T key,
                  short value)

Type Specific method to reduce boxing/unboxing of values

Parameters:

key - the key that should be inserted,

value - the value that should be inserted

Returns:

the last present value or default return value.

See Also:

Map.putIfAbsent(Object, Object)

putAllIfAbsent

void putAllIfAbsent(Object2ShortMap<T> m)

Type-Specific bulk put method put elements into the map if not present.

Parameters:

m - elements that should be added if not present.

addTo

short addTo(T key,
            short value)

A Helper method to add a primitives together. If key is not present then this functions as a put.

Parameters:

key - the key that should be inserted,

value - the value that should be inserted / added

Returns:

the last present value or default return value.

addToAll

void addToAll(Object2ShortMap<T> m)

A Helper method to bulk add primitives together.

Parameters:

m - the values that should be added/inserted

subFrom

short subFrom(T key,
              short value)

A Helper method to subtract from primitive from each other. If the key is not present it will just return the defaultValue How the implementation works is that it will subtract from the current value (if not present it will do nothing) and fence it to the getDefaultReturnValue() If the fence is reached the element will be automaticall removed

Parameters:

key - that should be subtract from

value - that should be subtract

Returns:

the last present or default return value

putAll

void putAll(Object2ShortMap<T> m)

Type Specific function for the bull putting of values

Parameters:

m - the elements that should be inserted

containsValue

boolean containsValue(short value)

Type Specific method to reduce boxing/unboxing of values

Parameters:

value - element that is searched for

Returns:

if the value is present

containsValue

default boolean containsValue(java.lang.Object value)

Specified by:

containsValue in interface java.util.Map<T,java.lang.Short>

Parameters:

value - that is searched for.

Returns:

true if found

See Also:

Map.containsValue(Object)

Note:

in some implementations key does not have to be CLASS_VALUE but just have to support equals with CLASS_VALUE.

rem

short rem(T key)

Type Specific remove function to reduce boxing/unboxing

Parameters:

key - the element that should be removed

Returns:

the value that was removed or default return value

remove

default java.lang.Short remove(java.lang.Object key)

Specified by:

remove in interface java.util.Map<T,java.lang.Short>

Parameters:

key - the element that should be removed

Returns:

the value that was removed or default return value

See Also:

Map.remove(Object)

Note:

in some implementations key does not have to be T but just have to support equals with T.

remove

boolean remove(T key,
               short value)

Type Specific remove function to reduce boxing/unboxing

Parameters:

key - the element that should be removed

value - the expected value that should be found

Returns:

true if the key and value was found and removed

See Also:

Map.remove(Object, Object)

remove

default boolean remove(java.lang.Object key,
                       java.lang.Object value)

Specified by:

remove in interface java.util.Map<T,java.lang.Short>

Parameters:

key - the element that should be removed

value - the expected value that should be found

Returns:

true if the key and value was found and removed

See Also:

Map.remove(Object, Object)

remOrDefault

short remOrDefault(T key,
                   short defaultValue)

Type-Specific Remove function with a default return value if wanted.

Parameters:

key - the element that should be removed

defaultValue - the value that should be returned if the entry doesn't exist

Returns:

the value that was removed or default value

See Also:

Map.remove(Object, Object)

replace

boolean replace(T key,
                short oldValue,
                short newValue)

A Type Specific replace method to replace an existing value

Parameters:

key - the element that should be searched for

oldValue - the expected value to be replaced

newValue - the value to replace the oldValue with.

Returns:

true if the value got replaced

Note:

this fails if the value is not present even if it matches the oldValue

replace

short replace(T key,
              short value)

A Type Specific replace method to reduce boxing/unboxing replace an existing value

Parameters:

key - the element that should be searched for

value - the value to replace with.

Returns:

the present value or default return value

Note:

this fails if the value is not present

replaceShorts

void replaceShorts(Object2ShortMap<T> m)

Type-Specific bulk replace method. Could be seen as putAllIfPresent

Parameters:

m - elements that should be replaced.

replaceShorts

void replaceShorts(ObjectShortUnaryOperator<T> mappingFunction)

A Type Specific mass replace method to reduce boxing/unboxing

Parameters:

mappingFunction - operation to replace all values

computeShort

short computeShort(T key,
                   ObjectShortUnaryOperator<T> mappingFunction)

A Type Specific compute method to reduce boxing/unboxing

Parameters:

key - the key that should be computed

mappingFunction - the operator that should generate the value

Returns:

the result of the computation

computeShortIfAbsent

short computeShortIfAbsent(T key,
                           ToShortFunction<T> mappingFunction)

A Type Specific compute method to reduce boxing/unboxing

Parameters:

key - the key that should be computed

mappingFunction - the operator that should generate the value if not present

Returns:

the result of the computed value or present value

supplyShortIfAbsent

short supplyShortIfAbsent(T key,
                          ShortSupplier valueProvider)

A Supplier based computeIfAbsent function to fill the most used usecase of this function

Parameters:

key - the key that should be computed

valueProvider - the value if not present

Returns:

the result of the computed value or present value

computeShortIfPresent

short computeShortIfPresent(T key,
                            ObjectShortUnaryOperator<T> mappingFunction)

A Type Specific compute method to reduce boxing/unboxing

Parameters:

key - the key that should be computed

mappingFunction - the operator that should generate the value if present

Returns:

the result of the default return value or present value

Note:

if not present then compute is not executed

mergeShort

short mergeShort(T key,
                 short value,
                 ShortShortUnaryOperator mappingFunction)

A Type Specific merge method to reduce boxing/unboxing

Parameters:

key - the key that should be be searched for

value - the value that should be merged with

mappingFunction - the operator that should generate the new Value

Returns:

the result of the merge

Note:

if the result matches the default return value then the key is removed from the map

mergeAllShort

void mergeAllShort(Object2ShortMap<T> m,
                   ShortShortUnaryOperator mappingFunction)

A Bulk method for merging Maps.

Parameters:

m - the entries that should be bulk added

mappingFunction - the operator that should generate the new Value

Note:

if the result matches the default return value then the key is removed from the map

replace

default boolean replace(T key,
                        java.lang.Short oldValue,
                        java.lang.Short newValue)

Specified by:

replace in interface java.util.Map<T,java.lang.Short>

replace

default java.lang.Short replace(T key,
                                java.lang.Short value)

Specified by:

replace in interface java.util.Map<T,java.lang.Short>

applyAsShort

default short applyAsShort(T key)

Description copied from interface: ToShortFunction

Type Specific get function to reduce boxing/unboxing

Specified by:

applyAsShort in interface ToShortFunction<T>

Parameters:

key - the value that should be processed

Returns:

the result of the function

getShort

short getShort(T key)

A Type Specific get method to reduce boxing/unboxing

Parameters:

key - the key that is searched for

Returns:

the searched value or default return value

getOrDefault

short getOrDefault(T key,
                   short defaultValue)

A Type Specific getOrDefault method to reduce boxing/unboxing

Parameters:

key - the key that is searched for

defaultValue - the value that should be returned if the key is not present

Returns:

the searched value or defaultValue value

get

default java.lang.Short get(java.lang.Object key)

Specified by:

get in interface java.util.Map<T,java.lang.Short>

getOrDefault

default java.lang.Short getOrDefault(java.lang.Object key,
                                     java.lang.Short defaultValue)

Specified by:

getOrDefault in interface java.util.Map<T,java.lang.Short>

replaceAll

default void replaceAll(java.util.function.BiFunction<? super T,? super java.lang.Short,? extends java.lang.Short> mappingFunction)

Specified by:

replaceAll in interface java.util.Map<T,java.lang.Short>

compute

default java.lang.Short compute(T key,
                                java.util.function.BiFunction<? super T,? super java.lang.Short,? extends java.lang.Short> mappingFunction)

Specified by:

compute in interface java.util.Map<T,java.lang.Short>

computeIfAbsent

default java.lang.Short computeIfAbsent(T key,
                                        java.util.function.Function<? super T,? extends java.lang.Short> mappingFunction)

Specified by:

computeIfAbsent in interface java.util.Map<T,java.lang.Short>

computeIfPresent

default java.lang.Short computeIfPresent(T key,
                                         java.util.function.BiFunction<? super T,? super java.lang.Short,? extends java.lang.Short> mappingFunction)

Specified by:

computeIfPresent in interface java.util.Map<T,java.lang.Short>

merge

default java.lang.Short merge(T key,
                              java.lang.Short value,
                              java.util.function.BiFunction<? super java.lang.Short,? super java.lang.Short,? extends java.lang.Short> mappingFunction)

Specified by:

merge in interface java.util.Map<T,java.lang.Short>

forEach

void forEach(ObjectShortConsumer<T> action)

Type Specific forEach method to reduce boxing/unboxing

Parameters:

action - processor of the values that are iterator over

forEach

default void forEach(java.util.function.BiConsumer<? super T,? super java.lang.Short> action)

Specified by:

forEach in interface java.util.Map<T,java.lang.Short>

keySet

ObjectSet<T> keySet()

Specified by:

keySet in interface java.util.Map<T,java.lang.Short>

values

ShortCollection values()

Specified by:

values in interface java.util.Map<T,java.lang.Short>

entrySet

ObjectSet<java.util.Map.Entry<T,java.lang.Short>> entrySet()

Specified by:

entrySet in interface java.util.Map<T,java.lang.Short>

object2ShortEntrySet

ObjectSet<Object2ShortMap.Entry<T>> object2ShortEntrySet()

Type Sensitive EntrySet to reduce boxing/unboxing and optionally Temp Object Allocation.

Returns:

a EntrySet of the collection

synchronize

default Object2ShortMap<T> synchronize()

Creates a Wrapped Map that is Synchronized

Returns:

a new Map that is synchronized

See Also:

Object2ShortMaps.synchronize(speiger.src.collections.objects.maps.interfaces.Object2ShortMap<T>)

synchronize

default Object2ShortMap<T> synchronize(java.lang.Object mutex)

Creates a Wrapped Map that is Synchronized

Parameters:

mutex - is the controller of the synchronization block

Returns:

a new Map Wrapper that is synchronized

See Also:

Object2ShortMaps.synchronize(speiger.src.collections.objects.maps.interfaces.Object2ShortMap<T>)

unmodifiable

default Object2ShortMap<T> unmodifiable()

Creates a Wrapped Map that is unmodifiable

Returns:

a new Map Wrapper that is unmodifiable

See Also:

Object2ShortMaps.unmodifiable(speiger.src.collections.objects.maps.interfaces.Object2ShortMap<T>)

put

default java.lang.Short put(T key,
                            java.lang.Short value)

Specified by:

put in interface java.util.Map<T,java.lang.Short>

putIfAbsent

default java.lang.Short putIfAbsent(T key,
                                    java.lang.Short value)

Specified by:

putIfAbsent in interface java.util.Map<T,java.lang.Short>