Package speiger.src.collections.objects.maps.interfaces

Interface Summary

Interface	Description
Object2BooleanConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2BooleanMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2BooleanMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2BooleanMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2BooleanNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2BooleanOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2BooleanOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2BooleanSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2BooleanSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ByteConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2ByteMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2ByteMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2ByteMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ByteNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2ByteOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2ByteOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ByteSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2ByteSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2CharConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2CharMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2CharMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2CharMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2CharNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2CharOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2CharOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2CharSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2CharSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2DoubleConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2DoubleMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2DoubleMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2DoubleMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2DoubleNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2DoubleOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2DoubleOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2DoubleSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2DoubleSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2FloatConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2FloatMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2FloatMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2FloatMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2FloatNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2FloatOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2FloatOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2FloatSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2FloatSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2IntConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2IntMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2IntMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2IntMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2IntNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2IntOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2IntOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2IntSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2IntSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2LongConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2LongMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2LongMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2LongMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2LongNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2LongOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2LongOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2LongSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2LongSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ObjectConcurrentMap<T,V>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2ObjectMap<T,V>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2ObjectMap.Entry<T,V>	Type Specific Map Entry that reduces boxing/unboxing
Object2ObjectMap.FastEntrySet<T,V>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ObjectNavigableMap<T,V>	A Type Specific Navigable Map interface with a couple helper methods
Object2ObjectOrderedMap<T,V>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2ObjectOrderedMap.FastOrderedSet<T,V>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ObjectSortedMap<T,V>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2ObjectSortedMap.FastSortedSet<T,V>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ShortConcurrentMap<T>	A type specific ConcurrentMap interface that reduces boxing/unboxing.
Object2ShortMap<T>	A Type Specific Map that reduces memory overhead due to boxing/unboxing of Primitives and some extra helper functions.
Object2ShortMap.Entry<T>	Type Specific Map Entry that reduces boxing/unboxing
Object2ShortMap.FastEntrySet<T>	Fast Entry set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ShortNavigableMap<T>	A Type Specific Navigable Map interface with a couple helper methods
Object2ShortOrderedMap<T>	A Special Map Interface giving Access to some really usefull functions The Idea behind this interface is to allow access to functions that give control to the Order of elements.
Object2ShortOrderedMap.FastOrderedSet<T>	Fast Ordered Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value
Object2ShortSortedMap<T>	A Type Specific SortedMap interface to reduce boxing/unboxing, with a couple extra methods that allow greater control over maps.
Object2ShortSortedMap.FastSortedSet<T>	Fast Sorted Entry Set that allows for a faster Entry Iterator by recycling the Entry Object and just exchanging 1 internal value

Class Summary

Class	Description
Object2BooleanMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2BooleanMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2ByteMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2ByteMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2CharMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2CharMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2DoubleMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2DoubleMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2FloatMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2FloatMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2IntMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2IntMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2LongMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2LongMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2ObjectMap.BuilderCache<T,V>	Builder Cache for allowing to buildMaps
Object2ObjectMap.MapBuilder	Helper class that reduces the method spam of the Map Class.
Object2ShortMap.BuilderCache<T>	Builder Cache for allowing to buildMaps
Object2ShortMap.MapBuilder	Helper class that reduces the method spam of the Map Class.