|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Stack | |
---|---|
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 Stack in it.unimi.dsi.fastutil |
---|
Classes in it.unimi.dsi.fastutil that implement Stack | |
---|---|
class |
AbstractStack<K>
An abstract class providing basic methods for implementing the Stack interface. |
Uses of Stack in it.unimi.dsi.fastutil.booleans |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.booleans | |
---|---|
interface |
BooleanStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.booleans that implement Stack | |
---|---|
class |
AbstractBooleanBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractBooleanBigList.BooleanSubList
|
class |
AbstractBooleanList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractBooleanList.BooleanSubList
|
class |
AbstractBooleanStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
BooleanArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
BooleanLists.Singleton
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.bytes |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.bytes | |
---|---|
interface |
ByteStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.bytes that implement Stack | |
---|---|
class |
AbstractByteBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractByteBigList.ByteSubList
|
class |
AbstractByteList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractByteList.ByteSubList
|
class |
AbstractByteStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
ByteArrayFrontCodedList
Compact storage of lists of arrays using front coding. |
class |
ByteArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
ByteLists.Singleton
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.chars |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.chars | |
---|---|
interface |
CharStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.chars that implement Stack | |
---|---|
class |
AbstractCharBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractCharBigList.CharSubList
|
class |
AbstractCharList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractCharList.CharSubList
|
class |
AbstractCharStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
CharArrayFrontCodedList
Compact storage of lists of arrays using front coding. |
class |
CharArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
CharLists.Singleton
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.doubles |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.doubles | |
---|---|
interface |
DoubleStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.doubles that implement Stack | |
---|---|
class |
AbstractDoubleBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractDoubleBigList.DoubleSubList
|
class |
AbstractDoubleList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractDoubleList.DoubleSubList
|
class |
AbstractDoubleStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
DoubleArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
DoubleLists.Singleton
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.floats |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.floats | |
---|---|
interface |
FloatStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.floats that implement Stack | |
---|---|
class |
AbstractFloatBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractFloatBigList.FloatSubList
|
class |
AbstractFloatList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractFloatList.FloatSubList
|
class |
AbstractFloatStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
FloatArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
FloatLists.Singleton
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.ints |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.ints | |
---|---|
interface |
IntStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.ints that implement Stack | |
---|---|
class |
AbstractIntBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractIntBigList.IntSubList
|
class |
AbstractIntList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractIntList.IntSubList
|
class |
AbstractIntStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
IntArrayFrontCodedList
Compact storage of lists of arrays using front coding. |
class |
IntArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
IntLists.Singleton
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.longs |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.longs | |
---|---|
interface |
LongStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.longs that implement Stack | |
---|---|
class |
AbstractLongBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractLongBigList.LongSubList
|
class |
AbstractLongList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractLongList.LongSubList
|
class |
AbstractLongStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
LongArrayFrontCodedList
Compact storage of lists of arrays using front coding. |
class |
LongArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
LongLists.Singleton
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.objects |
---|
Classes in it.unimi.dsi.fastutil.objects that implement Stack | |
---|---|
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 |
AbstractObjectList<K>
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractObjectList.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 |
AbstractReferenceList<K>
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractReferenceList.ReferenceSubList<K>
|
class |
ObjectArrayList<K>
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
ObjectLists.Singleton<K>
An immutable class representing a type-specific singleton list. |
class |
ReferenceArrayList<K>
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
ReferenceLists.Singleton<K>
An immutable class representing a type-specific singleton list. |
Uses of Stack in it.unimi.dsi.fastutil.shorts |
---|
Subinterfaces of Stack in it.unimi.dsi.fastutil.shorts | |
---|---|
interface |
ShortStack
A type-specific Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Classes in it.unimi.dsi.fastutil.shorts that implement Stack | |
---|---|
class |
AbstractShortBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface. |
static class |
AbstractShortBigList.ShortSubList
|
class |
AbstractShortList
An abstract class providing basic methods for lists implementing a type-specific list interface. |
static class |
AbstractShortList.ShortSubList
|
class |
AbstractShortStack
An abstract class providing basic methods for implementing a type-specific stack interface. |
class |
ShortArrayFrontCodedList
Compact storage of lists of arrays using front coding. |
class |
ShortArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing. |
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.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 |
ShortLists.Singleton
An immutable class representing a type-specific singleton list. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |