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

Packages that use Size64
it.unimi.dsi.fastutil   
it.unimi.dsi.fastutil.booleans Provides type-specific classes for boolean elements or keys. 
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 Size64 in it.unimi.dsi.fastutil
 

Subinterfaces of Size64 in it.unimi.dsi.fastutil
 interface BigList<K>
          A list with big (i.e., 64-bit) indices.
 

Uses of Size64 in it.unimi.dsi.fastutil.booleans
 

Subinterfaces of Size64 in it.unimi.dsi.fastutil.booleans
 interface BooleanBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.booleans that implement Size64
 class AbstractBooleanBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractBooleanBigList.BooleanSubList
           
 class BooleanBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class BooleanBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class BooleanBigLists.ListBigList
          A class exposing a list as a big list.
static class BooleanBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class BooleanBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class BooleanBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.bytes
 interface ByteBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.bytes that implement Size64
 class AbstractByteBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractByteBigList.ByteSubList
           
 class ByteBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class ByteBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class ByteBigLists.ListBigList
          A class exposing a list as a big list.
static class ByteBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class ByteBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class ByteBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.chars
 interface CharBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.chars that implement Size64
 class AbstractCharBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractCharBigList.CharSubList
           
 class CharBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class CharBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class CharBigLists.ListBigList
          A class exposing a list as a big list.
static class CharBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class CharBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class CharBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.doubles
 interface DoubleBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.doubles that implement Size64
 class AbstractDoubleBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractDoubleBigList.DoubleSubList
           
 class DoubleBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class DoubleBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class DoubleBigLists.ListBigList
          A class exposing a list as a big list.
static class DoubleBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class DoubleBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class DoubleBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 class DoubleOpenHashBigSet
          A type-specific hash big set with with a fast, small-footprint implementation.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.floats
 interface FloatBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.floats that implement Size64
 class AbstractFloatBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractFloatBigList.FloatSubList
           
 class FloatBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class FloatBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class FloatBigLists.ListBigList
          A class exposing a list as a big list.
static class FloatBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class FloatBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class FloatBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 class FloatOpenHashBigSet
          A type-specific hash big set with with a fast, small-footprint implementation.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.ints
 interface IntBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.ints that implement Size64
 class AbstractIntBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractIntBigList.IntSubList
           
 class IntBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class IntBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class IntBigLists.ListBigList
          A class exposing a list as a big list.
static class IntBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class IntBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class IntBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 class IntOpenHashBigSet
          A type-specific hash big set with with a fast, small-footprint implementation.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.longs
 interface LongBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.longs that implement Size64
 class AbstractLongBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractLongBigList.LongSubList
           
 class LongBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class LongBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class LongBigLists.ListBigList
          A class exposing a list as a big list.
static class LongBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class LongBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class LongBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 class LongOpenHashBigSet
          A type-specific hash big set with with a fast, small-footprint implementation.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.objects
 interface ObjectBigList<K>
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 interface ReferenceBigList<K>
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.objects that implement Size64
 class AbstractObjectBigList<K>
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractObjectBigList.ObjectSubList<K>
           
 class AbstractReferenceBigList<K>
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractReferenceBigList.ReferenceSubList<K>
           
 class ObjectBigArrayBigList<K>
          A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing.
static class ObjectBigLists.EmptyBigList<K>
          An immutable class representing an empty type-specific big list.
static class ObjectBigLists.ListBigList<K>
          A class exposing a list as a big list.
static class ObjectBigLists.Singleton<K>
          An immutable class representing a type-specific singleton big list.
static class ObjectBigLists.SynchronizedBigList<K>
          A synchronized wrapper class for big lists.
static class ObjectBigLists.UnmodifiableBigList<K>
          An unmodifiable wrapper class for big lists.
 class ObjectOpenHashBigSet<K>
          A type-specific hash big set with with a fast, small-footprint implementation.
 class ReferenceBigArrayBigList<K>
          A type-specific big-array-based big list; provides some additional methods that use polymorphism to avoid (un)boxing.
static class ReferenceBigLists.EmptyBigList<K>
          An immutable class representing an empty type-specific big list.
static class ReferenceBigLists.ListBigList<K>
          A class exposing a list as a big list.
static class ReferenceBigLists.Singleton<K>
          An immutable class representing a type-specific singleton big list.
static class ReferenceBigLists.SynchronizedBigList<K>
          A synchronized wrapper class for big lists.
static class ReferenceBigLists.UnmodifiableBigList<K>
          An unmodifiable wrapper class for big lists.
 class ReferenceOpenHashBigSet<K>
          A type-specific hash big set with with a fast, small-footprint implementation.
 

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

Subinterfaces of Size64 in it.unimi.dsi.fastutil.shorts
 interface ShortBigList
          A type-specific BigList; provides some additional methods that use polymorphism to avoid (un)boxing.
 

Classes in it.unimi.dsi.fastutil.shorts that implement Size64
 class AbstractShortBigList
          An abstract class providing basic methods for big lists implementing a type-specific big list interface.
static class AbstractShortBigList.ShortSubList
           
 class ShortBigArrayBigList
          A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
static class ShortBigLists.EmptyBigList
          An immutable class representing an empty type-specific big list.
static class ShortBigLists.ListBigList
          A class exposing a list as a big list.
static class ShortBigLists.Singleton
          An immutable class representing a type-specific singleton big list.
static class ShortBigLists.SynchronizedBigList
          A synchronized wrapper class for big lists.
static class ShortBigLists.UnmodifiableBigList
          An unmodifiable wrapper class for big lists.
 



Copyright © 2011. All Rights Reserved.