Package edu.stanford.nlp.util

Interface Summary
CoreMap Base type for all annotatable core objects.
Factory<T> A generified factory class which creates instances of a particular type.
Filter<T> Filter is an interface for predicate objects which respond to the accept method.
Function<T1,T2> An interface for classes that act as a function transforming one object to another.
HasInterval<E extends Comparable<E>> HasInterval interface
Index<E> Minimalist interface for implementations of Index.
PriorityQueue<E> A Set that also represents an ordering of its elements, and responds quickly to add(), changePriority(), removeFirst(), and getFirst() method calls.
Scored Scored: This is a simple interface that says that an object can answer requests for the score, or goodness of the object.
TypesafeMap<BASE> Type signature for a class that supports the basic operations required of a typesafe heterogeneous map.
TypesafeMap.Key<BASE,VALUE> Base type of keys for the map.
 

Class Summary
AbstractIterator<E> Iterator with remove() defined to throw an UnsupportedOperationException.
ArrayCoreMap Base implementation of CoreMap backed by Java Arrays.
ArrayIterable<E>  
ArrayMap<K,V> Map backed by an Array.
ArrayUtils Static utility methods for operating on arrays.
BinaryHeapPriorityQueue<E> PriorityQueue with explicit double priority values.
ByteStreamGobbler Stream Gobbler that read and write bytes (can be used to gobble byte based stdout from a process.exec into a file)
CollectionFactory<T> Factory for vending Collections.
CollectionFactory.ArrayListFactory<T>  
CollectionFactory.HashSetFactory<T>  
CollectionFactory.LinkedListFactory<T>  
CollectionFactory.SizedArrayListFactory<T>  
CollectionFactory.TreeSetFactory<T>  
CollectionUtils Collection of useful static methods for working with Collections.
ErasureUtils Class to gather unsafe operations into one place.
FixedPrioritiesPriorityQueue<E> A priority queue based on a binary heap.
Generics A collection of utilities to make dealing with Java generics less painful and verbose.
HashableCoreMap An extension of ArrayCoreMap with an immutable set of key,value pairs that is used for equality and hashcode comparisons.
HashIndex<E> An Index is a collection that maps between an Object vocabulary and a contiguous non-negative integer index series beginning (inclusively) at 0.
Interner<T> For interning (canonicalizing) things.
Interval<E extends Comparable<E>> Represents a interval of a generic type E that is comparable.
IntPair  
IntQuadruple  
IntTriple  
IntTuple A tuple of int.
IntUni Just a single integer
MapFactory<K,V> A factory class for vending different sorts of Maps.
MetaClass A meta class using Java's reflection library.
MetaClass.ClassFactory<T>  
MutableDouble A class for Double objects that you can change.
MutableInteger A class for Integer objects that you can change.
Pair<T1,T2> Pair is a Class for holding mutable pairs of objects.
ReflectionLoading The goal of this class is to make it easier to load stuff by reflection.
ScoredComparator ScoredComparator allows one to compare Scored things.
ScoredObject<T> Wrapper class for holding a scored object
Sets Utilities for sets.
StreamGobbler Reads the output of a process started by Process.exec() Adapted from: http://www.velocityreviews.com/forums/t130884-process-runtimeexec-causes-subprocess-hang.html
StringUtils StringUtils is a class for random String things, including output formatting and command line argument parsing.
Timing A class for measuring how long things take.
Triple<T1,T2,T3> Class representing an ordered triple of objects, possibly typed.
 

Enum Summary
Interval.RelType RelType gives the basic types of relations between two intervals
 

Exception Summary
HashableCoreMap.HashableCoreMapException An exception thrown when attempting to change the value associated with an (immutable) hash key in a HashableCoreMap.
MetaClass.ClassCreationException  
MetaClass.ConstructorNotFoundException  
ReflectionLoading.ReflectionLoadingException This class encapsulates all of the exceptions that can be thrown when loading something by reflection.
 



Stanford NLP Group