|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |