Uses of Interface
it.unimi.dsi.fastutil.Function

Packages that use Function
it.unimi.dsi.fastutil.bytes Provides type-specific classes for byte elements or keys. 
it.unimi.dsi.fastutil.chars Provides type-specific classes for character elements or keys. 
it.unimi.dsi.fastutil.doubles Provides type-specific classes for double elements or keys. 
it.unimi.dsi.fastutil.floats Provides type-specific classes for float elements or keys. 
it.unimi.dsi.fastutil.ints Provides type-specific classes for integer elements or keys. 
it.unimi.dsi.fastutil.longs Provides type-specific classes for long elements or keys. 
it.unimi.dsi.fastutil.objects Provides type-specific classes for object elements or keys. 
it.unimi.dsi.fastutil.shorts Provides type-specific classes for short elements or keys. 
 

Uses of Function in it.unimi.dsi.fastutil.bytes
 

Subinterfaces of Function in it.unimi.dsi.fastutil.bytes
 interface Byte2BooleanFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2BooleanMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2BooleanSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ByteFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ByteMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2ByteSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2CharFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2CharMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2CharSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2DoubleFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2DoubleMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2DoubleSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2FloatFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2FloatMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2FloatSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2IntFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2IntMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2IntSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2LongFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2LongMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2LongSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ObjectFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ObjectMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2ObjectSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ReferenceFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ReferenceMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2ReferenceSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ShortFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Byte2ShortMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Byte2ShortSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.bytes that implement Function
 class AbstractByte2BooleanFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2BooleanMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2BooleanSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2ByteFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2ByteMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2ByteSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2CharFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2CharMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2CharSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2DoubleFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2DoubleMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2DoubleSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2FloatFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2FloatMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2FloatSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2IntFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2IntMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2IntSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2LongFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2LongMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2LongSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2ObjectFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2ObjectMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2ObjectSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2ReferenceFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2ReferenceMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2ReferenceSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractByte2ShortFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractByte2ShortMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractByte2ShortSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Byte2BooleanArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2BooleanAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2BooleanFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2BooleanFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2BooleanFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2BooleanFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2BooleanLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2BooleanMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2BooleanMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2BooleanMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2BooleanMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2BooleanOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2BooleanRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2BooleanSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2BooleanSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2BooleanSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2BooleanSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Byte2ByteArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2ByteAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2ByteFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2ByteFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2ByteFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2ByteFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2ByteLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2ByteMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2ByteMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2ByteMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2ByteMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2ByteOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2ByteRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2ByteSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2ByteSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2ByteSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2ByteSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Byte2CharArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2CharAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2CharFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2CharFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2CharFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2CharFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2CharLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2CharMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2CharMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2CharMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2CharMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2CharOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2CharRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2CharSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2CharSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2CharSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2CharSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Byte2DoubleArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2DoubleAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2DoubleFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2DoubleFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2DoubleFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2DoubleFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2DoubleLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2DoubleMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2DoubleMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2DoubleMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2DoubleMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2DoubleOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2DoubleRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2DoubleSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2DoubleSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2DoubleSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2DoubleSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Byte2FloatArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2FloatAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2FloatFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2FloatFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2FloatFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2FloatFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2FloatLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2FloatMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2FloatMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2FloatMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2FloatMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2FloatOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2FloatRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2FloatSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2FloatSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2FloatSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2FloatSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Byte2IntArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2IntAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2IntFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2IntFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2IntFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2IntFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2IntLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2IntMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2IntMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2IntMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2IntMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2IntOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2IntRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2IntSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2IntSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2IntSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2IntSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Byte2LongArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2LongAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2LongFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2LongFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2LongFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2LongFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2LongLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2LongMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2LongMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2LongMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2LongMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2LongOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2LongRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2LongSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2LongSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2LongSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2LongSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Byte2ObjectArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2ObjectAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2ObjectFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Byte2ObjectFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Byte2ObjectFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Byte2ObjectFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Byte2ObjectLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2ObjectMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Byte2ObjectMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Byte2ObjectMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Byte2ObjectMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Byte2ObjectOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2ObjectRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2ObjectSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Byte2ObjectSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Byte2ObjectSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Byte2ObjectSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Byte2ReferenceArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2ReferenceAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2ReferenceFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Byte2ReferenceFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Byte2ReferenceFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Byte2ReferenceFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Byte2ReferenceLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2ReferenceMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Byte2ReferenceMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Byte2ReferenceMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Byte2ReferenceMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Byte2ReferenceOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2ReferenceRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2ReferenceSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Byte2ReferenceSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Byte2ReferenceSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Byte2ReferenceSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Byte2ShortArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Byte2ShortAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Byte2ShortFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Byte2ShortFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Byte2ShortFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Byte2ShortFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Byte2ShortLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Byte2ShortMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Byte2ShortMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Byte2ShortMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Byte2ShortMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Byte2ShortOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Byte2ShortRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Byte2ShortSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Byte2ShortSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Byte2ShortSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Byte2ShortSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 

Uses of Function in it.unimi.dsi.fastutil.chars
 

Subinterfaces of Function in it.unimi.dsi.fastutil.chars
 interface Char2BooleanFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2BooleanMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2BooleanSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ByteFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ByteMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2ByteSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2CharFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2CharMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2CharSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2DoubleFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2DoubleMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2DoubleSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2FloatFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2FloatMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2FloatSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2IntFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2IntMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2IntSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2LongFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2LongMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2LongSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ObjectFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ObjectMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2ObjectSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ReferenceFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ReferenceMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2ReferenceSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ShortFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Char2ShortMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Char2ShortSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.chars that implement Function
 class AbstractChar2BooleanFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2BooleanMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2BooleanSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2ByteFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2ByteMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2ByteSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2CharFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2CharMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2CharSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2DoubleFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2DoubleMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2DoubleSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2FloatFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2FloatMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2FloatSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2IntFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2IntMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2IntSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2LongFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2LongMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2LongSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2ObjectFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2ObjectMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2ObjectSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2ReferenceFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2ReferenceMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2ReferenceSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractChar2ShortFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractChar2ShortMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractChar2ShortSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Char2BooleanArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2BooleanAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2BooleanFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2BooleanFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2BooleanFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2BooleanFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2BooleanLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2BooleanMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2BooleanMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2BooleanMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2BooleanMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2BooleanOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2BooleanRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2BooleanSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2BooleanSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2BooleanSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2BooleanSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Char2ByteArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2ByteAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2ByteFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2ByteFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2ByteFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2ByteFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2ByteLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2ByteMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2ByteMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2ByteMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2ByteMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2ByteOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2ByteRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2ByteSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2ByteSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2ByteSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2ByteSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Char2CharArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2CharAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2CharFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2CharFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2CharFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2CharFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2CharLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2CharMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2CharMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2CharMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2CharMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2CharOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2CharRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2CharSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2CharSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2CharSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2CharSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Char2DoubleArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2DoubleAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2DoubleFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2DoubleFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2DoubleFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2DoubleFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2DoubleLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2DoubleMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2DoubleMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2DoubleMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2DoubleMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2DoubleOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2DoubleRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2DoubleSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2DoubleSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2DoubleSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2DoubleSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Char2FloatArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2FloatAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2FloatFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2FloatFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2FloatFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2FloatFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2FloatLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2FloatMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2FloatMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2FloatMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2FloatMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2FloatOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2FloatRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2FloatSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2FloatSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2FloatSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2FloatSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Char2IntArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2IntAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2IntFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2IntFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2IntFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2IntFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2IntLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2IntMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2IntMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2IntMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2IntMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2IntOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2IntRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2IntSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2IntSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2IntSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2IntSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Char2LongArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2LongAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2LongFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2LongFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2LongFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2LongFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2LongLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2LongMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2LongMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2LongMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2LongMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2LongOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2LongRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2LongSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2LongSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2LongSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2LongSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Char2ObjectArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2ObjectAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2ObjectFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Char2ObjectFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Char2ObjectFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Char2ObjectFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Char2ObjectLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2ObjectMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Char2ObjectMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Char2ObjectMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Char2ObjectMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Char2ObjectOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2ObjectRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2ObjectSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Char2ObjectSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Char2ObjectSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Char2ObjectSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Char2ReferenceArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2ReferenceAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2ReferenceFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Char2ReferenceFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Char2ReferenceFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Char2ReferenceFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Char2ReferenceLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2ReferenceMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Char2ReferenceMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Char2ReferenceMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Char2ReferenceMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Char2ReferenceOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2ReferenceRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2ReferenceSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Char2ReferenceSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Char2ReferenceSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Char2ReferenceSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Char2ShortArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Char2ShortAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Char2ShortFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Char2ShortFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Char2ShortFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Char2ShortFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Char2ShortLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Char2ShortMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Char2ShortMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Char2ShortMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Char2ShortMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Char2ShortOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Char2ShortRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Char2ShortSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Char2ShortSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Char2ShortSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Char2ShortSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 

Uses of Function in it.unimi.dsi.fastutil.doubles
 

Subinterfaces of Function in it.unimi.dsi.fastutil.doubles
 interface Double2BooleanFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2BooleanMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2BooleanSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ByteFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ByteMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2ByteSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2CharFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2CharMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2CharSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2DoubleFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2DoubleMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2DoubleSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2FloatFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2FloatMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2FloatSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2IntFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2IntMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2IntSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2LongFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2LongMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2LongSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ObjectFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ObjectMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2ObjectSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ReferenceFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ReferenceMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2ReferenceSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ShortFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Double2ShortMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Double2ShortSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.doubles that implement Function
 class AbstractDouble2BooleanFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2BooleanMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2BooleanSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2ByteFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2ByteMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2ByteSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2CharFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2CharMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2CharSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2DoubleFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2DoubleMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2DoubleSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2FloatFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2FloatMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2FloatSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2IntFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2IntMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2IntSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2LongFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2LongMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2LongSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2ObjectFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2ObjectMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2ObjectSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2ReferenceFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2ReferenceMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2ReferenceSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractDouble2ShortFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractDouble2ShortMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractDouble2ShortSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Double2BooleanArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2BooleanAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2BooleanFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2BooleanFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2BooleanFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2BooleanFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2BooleanLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2BooleanMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2BooleanMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2BooleanMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2BooleanMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2BooleanOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2BooleanRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2BooleanSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2BooleanSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2BooleanSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2BooleanSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Double2ByteArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2ByteAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2ByteFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2ByteFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2ByteFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2ByteFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2ByteLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2ByteMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2ByteMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2ByteMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2ByteMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2ByteOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2ByteRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2ByteSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2ByteSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2ByteSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2ByteSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Double2CharArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2CharAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2CharFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2CharFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2CharFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2CharFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2CharLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2CharMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2CharMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2CharMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2CharMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2CharOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2CharRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2CharSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2CharSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2CharSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2CharSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Double2DoubleArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2DoubleAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2DoubleFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2DoubleFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2DoubleFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2DoubleFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2DoubleLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2DoubleMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2DoubleMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2DoubleMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2DoubleMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2DoubleOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2DoubleRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2DoubleSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2DoubleSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2DoubleSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2DoubleSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Double2FloatArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2FloatAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2FloatFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2FloatFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2FloatFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2FloatFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2FloatLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2FloatMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2FloatMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2FloatMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2FloatMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2FloatOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2FloatRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2FloatSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2FloatSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2FloatSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2FloatSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Double2IntArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2IntAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2IntFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2IntFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2IntFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2IntFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2IntLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2IntMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2IntMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2IntMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2IntMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2IntOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2IntRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2IntSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2IntSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2IntSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2IntSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Double2LongArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2LongAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2LongFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2LongFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2LongFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2LongFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2LongLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2LongMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2LongMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2LongMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2LongMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2LongOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2LongRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2LongSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2LongSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2LongSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2LongSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Double2ObjectArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2ObjectAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2ObjectFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Double2ObjectFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Double2ObjectFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Double2ObjectFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Double2ObjectLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2ObjectMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Double2ObjectMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Double2ObjectMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Double2ObjectMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Double2ObjectOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2ObjectRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2ObjectSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Double2ObjectSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Double2ObjectSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Double2ObjectSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Double2ReferenceArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2ReferenceAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2ReferenceFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Double2ReferenceFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Double2ReferenceFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Double2ReferenceFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Double2ReferenceLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2ReferenceMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Double2ReferenceMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Double2ReferenceMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Double2ReferenceMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Double2ReferenceOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2ReferenceRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2ReferenceSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Double2ReferenceSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Double2ReferenceSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Double2ReferenceSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Double2ShortArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Double2ShortAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Double2ShortFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Double2ShortFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Double2ShortFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Double2ShortFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Double2ShortLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Double2ShortMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Double2ShortMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Double2ShortMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Double2ShortMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Double2ShortOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Double2ShortRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Double2ShortSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Double2ShortSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Double2ShortSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Double2ShortSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 

Uses of Function in it.unimi.dsi.fastutil.floats
 

Subinterfaces of Function in it.unimi.dsi.fastutil.floats
 interface Float2BooleanFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2BooleanMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2BooleanSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ByteFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ByteMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2ByteSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2CharFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2CharMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2CharSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2DoubleFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2DoubleMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2DoubleSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2FloatFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2FloatMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2FloatSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2IntFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2IntMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2IntSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2LongFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2LongMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2LongSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ObjectFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ObjectMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2ObjectSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ReferenceFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ReferenceMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2ReferenceSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ShortFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Float2ShortMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Float2ShortSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.floats that implement Function
 class AbstractFloat2BooleanFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2BooleanMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2BooleanSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2ByteFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2ByteMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2ByteSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2CharFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2CharMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2CharSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2DoubleFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2DoubleMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2DoubleSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2FloatFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2FloatMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2FloatSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2IntFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2IntMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2IntSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2LongFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2LongMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2LongSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2ObjectFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2ObjectMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2ObjectSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2ReferenceFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2ReferenceMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2ReferenceSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractFloat2ShortFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractFloat2ShortMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractFloat2ShortSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Float2BooleanArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2BooleanAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2BooleanFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2BooleanFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2BooleanFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2BooleanFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2BooleanLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2BooleanMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2BooleanMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2BooleanMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2BooleanMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2BooleanOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2BooleanRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2BooleanSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2BooleanSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2BooleanSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2BooleanSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Float2ByteArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2ByteAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2ByteFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2ByteFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2ByteFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2ByteFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2ByteLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2ByteMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2ByteMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2ByteMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2ByteMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2ByteOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2ByteRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2ByteSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2ByteSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2ByteSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2ByteSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Float2CharArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2CharAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2CharFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2CharFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2CharFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2CharFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2CharLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2CharMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2CharMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2CharMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2CharMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2CharOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2CharRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2CharSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2CharSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2CharSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2CharSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Float2DoubleArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2DoubleAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2DoubleFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2DoubleFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2DoubleFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2DoubleFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2DoubleLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2DoubleMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2DoubleMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2DoubleMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2DoubleMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2DoubleOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2DoubleRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2DoubleSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2DoubleSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2DoubleSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2DoubleSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Float2FloatArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2FloatAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2FloatFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2FloatFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2FloatFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2FloatFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2FloatLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2FloatMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2FloatMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2FloatMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2FloatMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2FloatOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2FloatRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2FloatSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2FloatSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2FloatSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2FloatSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Float2IntArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2IntAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2IntFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2IntFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2IntFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2IntFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2IntLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2IntMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2IntMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2IntMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2IntMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2IntOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2IntRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2IntSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2IntSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2IntSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2IntSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Float2LongArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2LongAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2LongFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2LongFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2LongFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2LongFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2LongLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2LongMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2LongMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2LongMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2LongMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2LongOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2LongRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2LongSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2LongSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2LongSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2LongSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Float2ObjectArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2ObjectAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2ObjectFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Float2ObjectFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Float2ObjectFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Float2ObjectFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Float2ObjectLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2ObjectMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Float2ObjectMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Float2ObjectMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Float2ObjectMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Float2ObjectOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2ObjectRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2ObjectSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Float2ObjectSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Float2ObjectSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Float2ObjectSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Float2ReferenceArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2ReferenceAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2ReferenceFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Float2ReferenceFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Float2ReferenceFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Float2ReferenceFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Float2ReferenceLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2ReferenceMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Float2ReferenceMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Float2ReferenceMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Float2ReferenceMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Float2ReferenceOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2ReferenceRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2ReferenceSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Float2ReferenceSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Float2ReferenceSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Float2ReferenceSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Float2ShortArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Float2ShortAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Float2ShortFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Float2ShortFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Float2ShortFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Float2ShortFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Float2ShortLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Float2ShortMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Float2ShortMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Float2ShortMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Float2ShortMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Float2ShortOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Float2ShortRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Float2ShortSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Float2ShortSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Float2ShortSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Float2ShortSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 

Uses of Function in it.unimi.dsi.fastutil.ints
 

Subinterfaces of Function in it.unimi.dsi.fastutil.ints
 interface Int2BooleanFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2BooleanMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2BooleanSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ByteFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ByteMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2ByteSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2CharFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2CharMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2CharSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2DoubleFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2DoubleMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2DoubleSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2FloatFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2FloatMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2FloatSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2IntFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2IntMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2IntSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2LongFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2LongMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2LongSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ObjectFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ObjectMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2ObjectSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ReferenceFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ReferenceMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2ReferenceSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ShortFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Int2ShortMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Int2ShortSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.ints that implement Function
 class AbstractInt2BooleanFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2BooleanMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2BooleanSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2ByteFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2ByteMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2ByteSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2CharFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2CharMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2CharSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2DoubleFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2DoubleMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2DoubleSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2FloatFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2FloatMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2FloatSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2IntFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2IntMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2IntSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2LongFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2LongMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2LongSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2ObjectFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2ObjectMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2ObjectSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2ReferenceFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2ReferenceMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2ReferenceSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractInt2ShortFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractInt2ShortMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractInt2ShortSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Int2BooleanArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2BooleanAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2BooleanFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2BooleanFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2BooleanFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2BooleanFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2BooleanLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2BooleanMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2BooleanMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2BooleanMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2BooleanMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2BooleanOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2BooleanRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2BooleanSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2BooleanSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2BooleanSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2BooleanSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Int2ByteArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2ByteAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2ByteFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2ByteFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2ByteFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2ByteFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2ByteLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2ByteMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2ByteMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2ByteMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2ByteMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2ByteOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2ByteRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2ByteSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2ByteSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2ByteSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2ByteSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Int2CharArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2CharAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2CharFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2CharFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2CharFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2CharFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2CharLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2CharMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2CharMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2CharMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2CharMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2CharOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2CharRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2CharSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2CharSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2CharSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2CharSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Int2DoubleArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2DoubleAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2DoubleFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2DoubleFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2DoubleFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2DoubleFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2DoubleLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2DoubleMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2DoubleMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2DoubleMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2DoubleMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2DoubleOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2DoubleRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2DoubleSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2DoubleSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2DoubleSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2DoubleSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Int2FloatArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2FloatAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2FloatFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2FloatFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2FloatFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2FloatFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2FloatLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2FloatMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2FloatMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2FloatMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2FloatMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2FloatOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2FloatRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2FloatSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2FloatSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2FloatSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2FloatSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Int2IntArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2IntAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2IntFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2IntFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2IntFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2IntFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2IntLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2IntMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2IntMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2IntMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2IntMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2IntOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2IntRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2IntSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2IntSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2IntSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2IntSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Int2LongArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2LongAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2LongFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2LongFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2LongFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2LongFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2LongLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2LongMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2LongMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2LongMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2LongMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2LongOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2LongRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2LongSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2LongSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2LongSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2LongSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Int2ObjectArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2ObjectAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2ObjectFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Int2ObjectFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Int2ObjectFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Int2ObjectFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Int2ObjectLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2ObjectMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Int2ObjectMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Int2ObjectMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Int2ObjectMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Int2ObjectOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2ObjectRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2ObjectSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Int2ObjectSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Int2ObjectSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Int2ObjectSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Int2ReferenceArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2ReferenceAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2ReferenceFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Int2ReferenceFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Int2ReferenceFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Int2ReferenceFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Int2ReferenceLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2ReferenceMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Int2ReferenceMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Int2ReferenceMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Int2ReferenceMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Int2ReferenceOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2ReferenceRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2ReferenceSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Int2ReferenceSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Int2ReferenceSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Int2ReferenceSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Int2ShortArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Int2ShortAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Int2ShortFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Int2ShortFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Int2ShortFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Int2ShortFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Int2ShortLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Int2ShortMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Int2ShortMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Int2ShortMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Int2ShortMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Int2ShortOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Int2ShortRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Int2ShortSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Int2ShortSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Int2ShortSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Int2ShortSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 

Uses of Function in it.unimi.dsi.fastutil.longs
 

Subinterfaces of Function in it.unimi.dsi.fastutil.longs
 interface Long2BooleanFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2BooleanMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2BooleanSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ByteFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ByteMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2ByteSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2CharFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2CharMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2CharSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2DoubleFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2DoubleMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2DoubleSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2FloatFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2FloatMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2FloatSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2IntFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2IntMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2IntSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2LongFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2LongMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2LongSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ObjectFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ObjectMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2ObjectSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ReferenceFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ReferenceMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2ReferenceSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ShortFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Long2ShortMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Long2ShortSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.longs that implement Function
 class AbstractLong2BooleanFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2BooleanMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2BooleanSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2ByteFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2ByteMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2ByteSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2CharFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2CharMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2CharSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2DoubleFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2DoubleMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2DoubleSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2FloatFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2FloatMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2FloatSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2IntFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2IntMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2IntSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2LongFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2LongMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2LongSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2ObjectFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2ObjectMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2ObjectSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2ReferenceFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2ReferenceMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2ReferenceSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractLong2ShortFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractLong2ShortMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractLong2ShortSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Long2BooleanArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2BooleanAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2BooleanFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2BooleanFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2BooleanFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2BooleanFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2BooleanLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2BooleanMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2BooleanMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2BooleanMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2BooleanMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2BooleanOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2BooleanRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2BooleanSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2BooleanSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2BooleanSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2BooleanSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Long2ByteArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2ByteAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2ByteFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2ByteFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2ByteFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2ByteFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2ByteLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2ByteMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2ByteMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2ByteMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2ByteMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2ByteOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2ByteRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2ByteSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2ByteSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2ByteSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2ByteSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Long2CharArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2CharAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2CharFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2CharFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2CharFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2CharFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2CharLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2CharMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2CharMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2CharMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2CharMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2CharOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2CharRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2CharSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2CharSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2CharSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2CharSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Long2DoubleArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2DoubleAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2DoubleFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2DoubleFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2DoubleFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2DoubleFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2DoubleLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2DoubleMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2DoubleMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2DoubleMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2DoubleMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2DoubleOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2DoubleRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2DoubleSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2DoubleSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2DoubleSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2DoubleSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Long2FloatArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2FloatAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2FloatFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2FloatFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2FloatFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2FloatFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2FloatLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2FloatMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2FloatMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2FloatMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2FloatMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2FloatOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2FloatRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2FloatSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2FloatSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2FloatSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2FloatSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Long2IntArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2IntAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2IntFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2IntFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2IntFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2IntFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2IntLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2IntMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2IntMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2IntMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2IntMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2IntOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2IntRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2IntSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2IntSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2IntSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2IntSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Long2LongArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2LongAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2LongFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2LongFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2LongFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2LongFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2LongLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2LongMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2LongMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2LongMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2LongMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2LongOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2LongRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2LongSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2LongSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2LongSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2LongSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Long2ObjectArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2ObjectAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2ObjectFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Long2ObjectFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Long2ObjectFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Long2ObjectFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Long2ObjectLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2ObjectMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Long2ObjectMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Long2ObjectMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Long2ObjectMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Long2ObjectOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2ObjectRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2ObjectSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Long2ObjectSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Long2ObjectSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Long2ObjectSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Long2ReferenceArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2ReferenceAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2ReferenceFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Long2ReferenceFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Long2ReferenceFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Long2ReferenceFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Long2ReferenceLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2ReferenceMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Long2ReferenceMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Long2ReferenceMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Long2ReferenceMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Long2ReferenceOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2ReferenceRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2ReferenceSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Long2ReferenceSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Long2ReferenceSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Long2ReferenceSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Long2ShortArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Long2ShortAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Long2ShortFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Long2ShortFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Long2ShortFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Long2ShortFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Long2ShortLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Long2ShortMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Long2ShortMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Long2ShortMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Long2ShortMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Long2ShortOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Long2ShortRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Long2ShortSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Long2ShortSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Long2ShortSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Long2ShortSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 

Uses of Function in it.unimi.dsi.fastutil.objects
 

Subinterfaces of Function in it.unimi.dsi.fastutil.objects
 interface Object2BooleanFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2BooleanMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2BooleanSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ByteFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ByteMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2ByteSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2CharFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2CharMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2CharSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2DoubleFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2DoubleMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2DoubleSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2FloatFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2FloatMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2FloatSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2IntFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2IntMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2IntSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2LongFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2LongMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2LongSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ObjectFunction<K,V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ObjectMap<K,V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2ObjectSortedMap<K,V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ReferenceFunction<K,V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ReferenceMap<K,V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2ReferenceSortedMap<K,V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ShortFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Object2ShortMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Object2ShortSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2BooleanFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2BooleanMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2BooleanSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ByteFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ByteMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2ByteSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2CharFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2CharMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2CharSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2DoubleFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2DoubleMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2DoubleSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2FloatFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2FloatMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2FloatSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2IntFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2IntMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2IntSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2LongFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2LongMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2LongSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ObjectFunction<K,V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ObjectMap<K,V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2ObjectSortedMap<K,V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ReferenceFunction<K,V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ReferenceMap<K,V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2ReferenceSortedMap<K,V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ShortFunction<K>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Reference2ShortMap<K>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Reference2ShortSortedMap<K>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.objects that implement Function
 class AbstractObject2BooleanFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2BooleanMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2BooleanSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2ByteFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2ByteMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2ByteSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2CharFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2CharMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2CharSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2DoubleFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2DoubleMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2DoubleSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2FloatFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2FloatMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2FloatSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2IntFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2IntMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2IntSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2LongFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2LongMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2LongSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2ObjectFunction<K,V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2ObjectMap<K,V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2ObjectSortedMap<K,V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2ReferenceFunction<K,V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2ReferenceMap<K,V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2ReferenceSortedMap<K,V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractObject2ShortFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractObject2ShortMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractObject2ShortSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2BooleanFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2BooleanMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2BooleanSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2ByteFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2ByteMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2ByteSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2CharFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2CharMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2CharSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2DoubleFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2DoubleMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2DoubleSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2FloatFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2FloatMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2FloatSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2IntFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2IntMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2IntSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2LongFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2LongMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2LongSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2ObjectFunction<K,V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2ObjectMap<K,V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2ObjectSortedMap<K,V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2ReferenceFunction<K,V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2ReferenceMap<K,V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2ReferenceSortedMap<K,V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractReference2ShortFunction<K>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractReference2ShortMap<K>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractReference2ShortSortedMap<K>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Object2BooleanArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2BooleanAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2BooleanFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2BooleanFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2BooleanFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2BooleanFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2BooleanLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2BooleanLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2BooleanMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2BooleanMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2BooleanMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2BooleanMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2BooleanOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2BooleanOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2BooleanRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2BooleanSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2BooleanSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2BooleanSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2BooleanSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Object2ByteArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2ByteAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2ByteFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2ByteFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2ByteFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2ByteFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2ByteLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2ByteLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2ByteMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2ByteMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2ByteMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2ByteMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2ByteOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2ByteOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2ByteRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2ByteSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2ByteSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2ByteSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2ByteSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Object2CharArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2CharAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2CharFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2CharFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2CharFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2CharFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2CharLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2CharLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2CharMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2CharMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2CharMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2CharMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2CharOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2CharOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2CharRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2CharSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2CharSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2CharSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2CharSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Object2DoubleArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2DoubleAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2DoubleFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2DoubleFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2DoubleFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2DoubleFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2DoubleLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2DoubleLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2DoubleMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2DoubleMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2DoubleMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2DoubleMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2DoubleOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2DoubleOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2DoubleRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2DoubleSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2DoubleSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2DoubleSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2DoubleSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Object2FloatArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2FloatAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2FloatFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2FloatFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2FloatFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2FloatFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2FloatLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2FloatLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2FloatMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2FloatMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2FloatMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2FloatMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2FloatOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2FloatOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2FloatRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2FloatSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2FloatSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2FloatSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2FloatSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Object2IntArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2IntAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2IntFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2IntFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2IntFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2IntFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2IntLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2IntLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2IntMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2IntMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2IntMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2IntMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2IntOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2IntOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2IntRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2IntSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2IntSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2IntSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2IntSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Object2LongArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2LongAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2LongFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2LongFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2LongFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2LongFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2LongLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2LongLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2LongMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2LongMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2LongMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2LongMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2LongOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2LongOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2LongRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2LongSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2LongSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2LongSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2LongSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Object2ObjectArrayMap<K,V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2ObjectAVLTreeMap<K,V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2ObjectFunctions.EmptyFunction<K,V>
          An immutable class representing an empty type-specific function.
static class Object2ObjectFunctions.Singleton<K,V>
          An immutable class representing a type-specific singleton function.
static class Object2ObjectFunctions.SynchronizedFunction<K,V>
          A synchronized wrapper class for functions.
static class Object2ObjectFunctions.UnmodifiableFunction<K,V>
          An unmodifiable wrapper class for functions.
 class Object2ObjectLinkedOpenCustomHashMap<K,V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2ObjectLinkedOpenHashMap<K,V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2ObjectMaps.EmptyMap<K,V>
          An immutable class representing an empty type-specific map.
static class Object2ObjectMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton map.
static class Object2ObjectMaps.SynchronizedMap<K,V>
          A synchronized wrapper class for maps.
static class Object2ObjectMaps.UnmodifiableMap<K,V>
          An unmodifiable wrapper class for maps.
 class Object2ObjectOpenCustomHashMap<K,V>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2ObjectOpenHashMap<K,V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2ObjectRBTreeMap<K,V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2ObjectSortedMaps.EmptySortedMap<K,V>
          An immutable class representing an empty type-specific sorted map.
static class Object2ObjectSortedMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton sorted map.
static class Object2ObjectSortedMaps.SynchronizedSortedMap<K,V>
          A synchronized wrapper class for sorted maps.
static class Object2ObjectSortedMaps.UnmodifiableSortedMap<K,V>
          An unmodifiable wrapper class for sorted maps.
 class Object2ReferenceArrayMap<K,V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2ReferenceAVLTreeMap<K,V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2ReferenceFunctions.EmptyFunction<K,V>
          An immutable class representing an empty type-specific function.
static class Object2ReferenceFunctions.Singleton<K,V>
          An immutable class representing a type-specific singleton function.
static class Object2ReferenceFunctions.SynchronizedFunction<K,V>
          A synchronized wrapper class for functions.
static class Object2ReferenceFunctions.UnmodifiableFunction<K,V>
          An unmodifiable wrapper class for functions.
 class Object2ReferenceLinkedOpenCustomHashMap<K,V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2ReferenceLinkedOpenHashMap<K,V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2ReferenceMaps.EmptyMap<K,V>
          An immutable class representing an empty type-specific map.
static class Object2ReferenceMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton map.
static class Object2ReferenceMaps.SynchronizedMap<K,V>
          A synchronized wrapper class for maps.
static class Object2ReferenceMaps.UnmodifiableMap<K,V>
          An unmodifiable wrapper class for maps.
 class Object2ReferenceOpenCustomHashMap<K,V>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2ReferenceOpenHashMap<K,V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2ReferenceRBTreeMap<K,V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2ReferenceSortedMaps.EmptySortedMap<K,V>
          An immutable class representing an empty type-specific sorted map.
static class Object2ReferenceSortedMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton sorted map.
static class Object2ReferenceSortedMaps.SynchronizedSortedMap<K,V>
          A synchronized wrapper class for sorted maps.
static class Object2ReferenceSortedMaps.UnmodifiableSortedMap<K,V>
          An unmodifiable wrapper class for sorted maps.
 class Object2ShortArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Object2ShortAVLTreeMap<K>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Object2ShortFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Object2ShortFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Object2ShortFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Object2ShortFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Object2ShortLinkedOpenCustomHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
 class Object2ShortLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Object2ShortMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Object2ShortMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Object2ShortMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Object2ShortMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Object2ShortOpenCustomHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation whose hashing strategy is specified at creation time.
 class Object2ShortOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
 class Object2ShortRBTreeMap<K>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Object2ShortSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Object2ShortSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Object2ShortSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Object2ShortSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2BooleanArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2BooleanFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2BooleanFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2BooleanFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2BooleanFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2BooleanLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2BooleanMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2BooleanMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2BooleanMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2BooleanMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2BooleanOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2BooleanSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2BooleanSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2BooleanSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2BooleanSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2ByteArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2ByteFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2ByteFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2ByteFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2ByteFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2ByteLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2ByteMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2ByteMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2ByteMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2ByteMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2ByteOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2ByteSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2ByteSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2ByteSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2ByteSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2CharArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2CharFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2CharFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2CharFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2CharFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2CharLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2CharMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2CharMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2CharMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2CharMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2CharOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2CharSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2CharSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2CharSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2CharSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2DoubleArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2DoubleFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2DoubleFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2DoubleFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2DoubleFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2DoubleLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2DoubleMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2DoubleMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2DoubleMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2DoubleMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2DoubleOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2DoubleSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2DoubleSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2DoubleSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2DoubleSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2FloatArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2FloatFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2FloatFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2FloatFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2FloatFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2FloatLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2FloatMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2FloatMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2FloatMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2FloatMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2FloatOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2FloatSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2FloatSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2FloatSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2FloatSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2IntArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2IntFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2IntFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2IntFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2IntFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2IntLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2IntMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2IntMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2IntMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2IntMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2IntOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2IntSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2IntSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2IntSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2IntSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2LongArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2LongFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2LongFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2LongFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2LongFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2LongLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2LongMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2LongMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2LongMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2LongMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2LongOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2LongSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2LongSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2LongSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2LongSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 class Reference2ObjectArrayMap<K,V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2ObjectFunctions.EmptyFunction<K,V>
          An immutable class representing an empty type-specific function.
static class Reference2ObjectFunctions.Singleton<K,V>
          An immutable class representing a type-specific singleton function.
static class Reference2ObjectFunctions.SynchronizedFunction<K,V>
          A synchronized wrapper class for functions.
static class Reference2ObjectFunctions.UnmodifiableFunction<K,V>
          An unmodifiable wrapper class for functions.
 class Reference2ObjectLinkedOpenHashMap<K,V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2ObjectMaps.EmptyMap<K,V>
          An immutable class representing an empty type-specific map.
static class Reference2ObjectMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton map.
static class Reference2ObjectMaps.SynchronizedMap<K,V>
          A synchronized wrapper class for maps.
static class Reference2ObjectMaps.UnmodifiableMap<K,V>
          An unmodifiable wrapper class for maps.
 class Reference2ObjectOpenHashMap<K,V>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2ObjectSortedMaps.EmptySortedMap<K,V>
          An immutable class representing an empty type-specific sorted map.
static class Reference2ObjectSortedMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2ObjectSortedMaps.SynchronizedSortedMap<K,V>
          A synchronized wrapper class for sorted maps.
static class Reference2ObjectSortedMaps.UnmodifiableSortedMap<K,V>
          An unmodifiable wrapper class for sorted maps.
 class Reference2ReferenceArrayMap<K,V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2ReferenceFunctions.EmptyFunction<K,V>
          An immutable class representing an empty type-specific function.
static class Reference2ReferenceFunctions.Singleton<K,V>
          An immutable class representing a type-specific singleton function.
static class Reference2ReferenceFunctions.SynchronizedFunction<K,V>
          A synchronized wrapper class for functions.
static class Reference2ReferenceFunctions.UnmodifiableFunction<K,V>
          An unmodifiable wrapper class for functions.
 class Reference2ReferenceLinkedOpenHashMap<K,V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2ReferenceMaps.EmptyMap<K,V>
          An immutable class representing an empty type-specific map.
static class Reference2ReferenceMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton map.
static class Reference2ReferenceMaps.SynchronizedMap<K,V>
          A synchronized wrapper class for maps.
static class Reference2ReferenceMaps.UnmodifiableMap<K,V>
          An unmodifiable wrapper class for maps.
 class Reference2ReferenceOpenHashMap<K,V>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2ReferenceSortedMaps.EmptySortedMap<K,V>
          An immutable class representing an empty type-specific sorted map.
static class Reference2ReferenceSortedMaps.Singleton<K,V>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2ReferenceSortedMaps.SynchronizedSortedMap<K,V>
          A synchronized wrapper class for sorted maps.
static class Reference2ReferenceSortedMaps.UnmodifiableSortedMap<K,V>
          An unmodifiable wrapper class for sorted maps.
 class Reference2ShortArrayMap<K>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
static class Reference2ShortFunctions.EmptyFunction<K>
          An immutable class representing an empty type-specific function.
static class Reference2ShortFunctions.Singleton<K>
          An immutable class representing a type-specific singleton function.
static class Reference2ShortFunctions.SynchronizedFunction<K>
          A synchronized wrapper class for functions.
static class Reference2ShortFunctions.UnmodifiableFunction<K>
          An unmodifiable wrapper class for functions.
 class Reference2ShortLinkedOpenHashMap<K>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Reference2ShortMaps.EmptyMap<K>
          An immutable class representing an empty type-specific map.
static class Reference2ShortMaps.Singleton<K>
          An immutable class representing a type-specific singleton map.
static class Reference2ShortMaps.SynchronizedMap<K>
          A synchronized wrapper class for maps.
static class Reference2ShortMaps.UnmodifiableMap<K>
          An unmodifiable wrapper class for maps.
 class Reference2ShortOpenHashMap<K>
          A type-specific hash map with a fast, small-footprint implementation.
static class Reference2ShortSortedMaps.EmptySortedMap<K>
          An immutable class representing an empty type-specific sorted map.
static class Reference2ShortSortedMaps.Singleton<K>
          An immutable class representing a type-specific singleton sorted map.
static class Reference2ShortSortedMaps.SynchronizedSortedMap<K>
          A synchronized wrapper class for sorted maps.
static class Reference2ShortSortedMaps.UnmodifiableSortedMap<K>
          An unmodifiable wrapper class for sorted maps.
 

Uses of Function in it.unimi.dsi.fastutil.shorts
 

Subinterfaces of Function in it.unimi.dsi.fastutil.shorts
 interface Short2BooleanFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2BooleanMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2BooleanSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ByteFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ByteMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2ByteSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2CharFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2CharMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2CharSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2DoubleFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2DoubleMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2DoubleSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2FloatFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2FloatMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2FloatSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2IntFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2IntMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2IntSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2LongFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2LongMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2LongSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ObjectFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ObjectMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2ObjectSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ReferenceFunction<V>
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ReferenceMap<V>
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2ReferenceSortedMap<V>
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ShortFunction
          A type-specific Function; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface Short2ShortMap
          A type-specific Map; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value.
 interface Short2ShortSortedMap
          A type-specific SortedMap; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.shorts that implement Function
 class AbstractShort2BooleanFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2BooleanMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2BooleanSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2ByteFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2ByteMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2ByteSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2CharFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2CharMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2CharSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2DoubleFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2DoubleMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2DoubleSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2FloatFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2FloatMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2FloatSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2IntFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2IntMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2IntSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2LongFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2LongMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2LongSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2ObjectFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2ObjectMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2ObjectSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2ReferenceFunction<V>
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2ReferenceMap<V>
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2ReferenceSortedMap<V>
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class AbstractShort2ShortFunction
          An abstract class providing basic methods for functions implementing a type-specific interface.
 class AbstractShort2ShortMap
          An abstract class providing basic methods for maps implementing a type-specific interface.
 class AbstractShort2ShortSortedMap
          An abstract class providing basic methods for sorted maps implementing a type-specific interface.
 class Short2BooleanArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2BooleanAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2BooleanFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2BooleanFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2BooleanFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2BooleanFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2BooleanLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2BooleanMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2BooleanMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2BooleanMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2BooleanMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2BooleanOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2BooleanRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2BooleanSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2BooleanSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2BooleanSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2BooleanSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Short2ByteArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2ByteAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2ByteFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2ByteFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2ByteFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2ByteFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2ByteLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2ByteMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2ByteMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2ByteMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2ByteMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2ByteOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2ByteRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2ByteSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2ByteSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2ByteSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2ByteSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Short2CharArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2CharAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2CharFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2CharFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2CharFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2CharFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2CharLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2CharMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2CharMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2CharMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2CharMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2CharOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2CharRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2CharSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2CharSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2CharSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2CharSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Short2DoubleArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2DoubleAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2DoubleFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2DoubleFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2DoubleFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2DoubleFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2DoubleLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2DoubleMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2DoubleMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2DoubleMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2DoubleMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2DoubleOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2DoubleRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2DoubleSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2DoubleSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2DoubleSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2DoubleSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Short2FloatArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2FloatAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2FloatFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2FloatFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2FloatFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2FloatFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2FloatLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2FloatMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2FloatMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2FloatMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2FloatMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2FloatOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2FloatRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2FloatSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2FloatSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2FloatSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2FloatSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Short2IntArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2IntAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2IntFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2IntFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2IntFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2IntFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2IntLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2IntMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2IntMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2IntMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2IntMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2IntOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2IntRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2IntSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2IntSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2IntSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2IntSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Short2LongArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2LongAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2LongFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2LongFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2LongFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2LongFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2LongLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2LongMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2LongMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2LongMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2LongMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2LongOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2LongRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2LongSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2LongSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2LongSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2LongSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 class Short2ObjectArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2ObjectAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2ObjectFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Short2ObjectFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Short2ObjectFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Short2ObjectFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Short2ObjectLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2ObjectMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Short2ObjectMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Short2ObjectMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Short2ObjectMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Short2ObjectOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2ObjectRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2ObjectSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Short2ObjectSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Short2ObjectSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Short2ObjectSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Short2ReferenceArrayMap<V>
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2ReferenceAVLTreeMap<V>
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2ReferenceFunctions.EmptyFunction<V>
          An immutable class representing an empty type-specific function.
static class Short2ReferenceFunctions.Singleton<V>
          An immutable class representing a type-specific singleton function.
static class Short2ReferenceFunctions.SynchronizedFunction<V>
          A synchronized wrapper class for functions.
static class Short2ReferenceFunctions.UnmodifiableFunction<V>
          An unmodifiable wrapper class for functions.
 class Short2ReferenceLinkedOpenHashMap<V>
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2ReferenceMaps.EmptyMap<V>
          An immutable class representing an empty type-specific map.
static class Short2ReferenceMaps.Singleton<V>
          An immutable class representing a type-specific singleton map.
static class Short2ReferenceMaps.SynchronizedMap<V>
          A synchronized wrapper class for maps.
static class Short2ReferenceMaps.UnmodifiableMap<V>
          An unmodifiable wrapper class for maps.
 class Short2ReferenceOpenHashMap<V>
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2ReferenceRBTreeMap<V>
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2ReferenceSortedMaps.EmptySortedMap<V>
          An immutable class representing an empty type-specific sorted map.
static class Short2ReferenceSortedMaps.Singleton<V>
          An immutable class representing a type-specific singleton sorted map.
static class Short2ReferenceSortedMaps.SynchronizedSortedMap<V>
          A synchronized wrapper class for sorted maps.
static class Short2ReferenceSortedMaps.UnmodifiableSortedMap<V>
          An unmodifiable wrapper class for sorted maps.
 class Short2ShortArrayMap
          A simple, brute-force implementation of a map based on two parallel backing arrays.
 class Short2ShortAVLTreeMap
          A type-specific AVL tree map with a fast, small-footprint implementation.
static class Short2ShortFunctions.EmptyFunction
          An immutable class representing an empty type-specific function.
static class Short2ShortFunctions.Singleton
          An immutable class representing a type-specific singleton function.
static class Short2ShortFunctions.SynchronizedFunction
          A synchronized wrapper class for functions.
static class Short2ShortFunctions.UnmodifiableFunction
          An unmodifiable wrapper class for functions.
 class Short2ShortLinkedOpenHashMap
          A type-specific linked hash map with with a fast, small-footprint implementation.
static class Short2ShortMaps.EmptyMap
          An immutable class representing an empty type-specific map.
static class Short2ShortMaps.Singleton
          An immutable class representing a type-specific singleton map.
static class Short2ShortMaps.SynchronizedMap
          A synchronized wrapper class for maps.
static class Short2ShortMaps.UnmodifiableMap
          An unmodifiable wrapper class for maps.
 class Short2ShortOpenHashMap
          A type-specific hash map with a fast, small-footprint implementation.
 class Short2ShortRBTreeMap
          A type-specific red-black tree map with a fast, small-footprint implementation.
static class Short2ShortSortedMaps.EmptySortedMap
          An immutable class representing an empty type-specific sorted map.
static class Short2ShortSortedMaps.Singleton
          An immutable class representing a type-specific singleton sorted map.
static class Short2ShortSortedMaps.SynchronizedSortedMap
          A synchronized wrapper class for sorted maps.
static class Short2ShortSortedMaps.UnmodifiableSortedMap
          An unmodifiable wrapper class for sorted maps.
 



Copyright © 2011. All Rights Reserved.