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

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.
 



Copyright © 2011. All Rights Reserved.