org.plumelib.util.package-info Maven / Gradle / Ivy

Go to download
/**
 *
 *
 * Plume-lib Util: Utility libraries for Java
 *
 * Note that HashMap
 * Util defines other classes in the org.plumelib.util package.
 *
 * 
Collections and iterators
 *
 * 
 *   {@link org.plumelib.util.ArraysPlume ArraysPlume}
 *   
Utilities for manipulating arrays and collections. This complements java.util.Arrays and
 *       java.util.Collections.
 *   
{@link org.plumelib.util.CollectionsPlume CollectionsPlume}
 *   
Utilities for manipulating collections, iterators, lists, maps, and sets.
 *   
{@link org.plumelib.util.CombinationIterator CombinationIterator}
 *   
Given a set of collections, return all combinations that take one element from each
 *       collection.
 *   
{@link org.plumelib.util.LimitedSizeSet LimitedSizeSet}
 *   
Stores up to some maximum number of unique values, at which point its rep is nulled, in
 *       order to save space.
 *   
{@link org.plumelib.util.LimitedSizeIntSet LimitedSizeIntSet}
 *   
Stores up to some maximum number of unique integer values, at which point its rep is
 *       nulled, in order to save space. More efficient than {@code LimitedSizeSet}.
 *   
{@link org.plumelib.util.LimitedSizeLongSet LimitedSizeLongSet}
 *   
Stores up to some maximum number of unique long values, at which point its rep is nulled,
 *       in order to save space. More efficient than {@code LimitedSizeSet}.
 *   
{@link org.plumelib.util.OrderedPairIterator OrderedPairIterator}
 *   
Given two sequences/iterators/whatever, OrderedPairIterator returns a new
 *       sequence/iterator/whatever that pairs the matching elements of the inputs, according to
 *       their respective sort orders. (This operation is sometimes called "zipping".)
 *   
{@link org.plumelib.util.Hasher Hasher}
 *   
See HashMap
 *       Util.
 *   
{@code WeakHasherMap}
 *   
See HashMap
 *       Util.
 *   
{@code WeakIdentityHashMap}
 *   
See HashMap
 *       Util.
 * 
 *
 * Text processing
 *
 * 
 *   {@link org.plumelib.util.EntryReader EntryReader}
 *   
Class that reads "entries" from a file. In the simplest case, entries can be lines. It
 *       supports: include files, comments, and multi-line entries (paragraphs). The syntax of each
 *       of these is customizable.
 *   
{@link org.plumelib.util.FileIOException FileIOException}
 *   
Extends IOException by also reporting a file name and line number at which the exception
 *       occurred.
 *   
{@link org.plumelib.util.FilesPlume}
 *   
Utility methods that create and manipulate files, directories, streams, readers, and
 *       writers.
 *   
{@link org.plumelib.util.FileWriterWithName FileWriterWithName}
 *   
Just like {@code FileWriter}, but adds a {@code getFileName()} method and overrides {@code
 *       toString()} to give the file name.
 *   
{@link org.plumelib.util.RegexUtil RegexUtil}
 *   
Utility methods for regular expressions, most notably for testing whether a string is a
 *       regular expression.
 *   
{@link org.plumelib.util.StringsPlume}
 *   
Utility methods that manipulate Strings: replacement; prefixing and indentation; splitting
 *       and joining; quoting and escaping; whitespace; comparisons; StringTokenizer; debugging
 *       variants of toString; diagnostic output; miscellaneous.
 *       
 *       
 * 
 *
 * Math
 *
 * 
 *   {@link org.plumelib.util.MathPlume MathPlume}
 *   
Mathematical utilities.
 *   
{@link org.plumelib.util.FuzzyFloat FuzzyFloat}
 *   
Routines for doing approximate ('fuzzy') floating point comparisons. Those are comparisons
 *       that only require the floating point numbers to be relatively close to one another to be
 *       equal, rather than exactly equal.
 * 
 *
 * Random selection
 *
 * 
 *   {@link org.plumelib.util.RandomSelector RandomSelector}
 *   
Selects k elements uniformly at random from an arbitrary iterator, using O(k)
 *       space.
 *   
{@link org.plumelib.util.MultiRandSelector MultiRandSelector}
 *   
Like RandomSelector, performs a uniform random selection over an iterator. However, the
 *       objects in the iteration may be partitioned so that the random selection chooses the same
 *       number from each group.
 * 
 *
 * Determinism and immutability
 *
 * 
 *   {@link org.plumelib.util.DeterministicObject DeterministicObject}
 *   
A version of {@code Object} with a deterministic {@code hashCode()} method. Instantiate
 *       this instead of {@code Object} to remove a source of nondeterminism from your programs.
 *   
{@link org.plumelib.util.ClassDeterministic ClassDeterministic}
 *   
Deterministic versions of {@code java.lang.Class} methods, which return arrays in sorted
 *       order.
 *   
{@link org.plumelib.util.UniqueId UniqueId}
 *   
An interface for objects that have a unique ID. If you are tempted to print the value of
 *       {@code System.identityHashCode()}, consider using this instead.
 *   
{@link org.plumelib.util.UniqueIdMap UniqueIdMap}
 *   
Provides a unique ID (like the {@link org.plumelib.util.UniqueId UniqueId} class) for
 *       classes that you cannot modify.
 *   
{@link org.plumelib.util.ImmutableTypes ImmutableTypes}
 *   
Indicates which types in the JDK are immutable.
 * 
 *
 * Utility interfaces
 *
 * 
 *   {@link org.plumelib.util.Partitioner Partitioner}
 *   
A Partitioner accepts Objects and assigns them to an equivalence class.
 * 
 *
 * JVM runtime system
 *
 * 
 *   {@link org.plumelib.util.DumpHeap DumpHeap}
 *   
Dumps the heap into a {@code .hprof} file.
 *   
{@link org.plumelib.util.SystemPlume SystemPlume}
 *   
Utility methods relating to the JVM runtime system: sleep and garbage collection.
 * 
 *
 * Miscellaneous
 *
 * 
 *   {@link org.plumelib.util.GraphPlume GraphPlume}
 *   
Graph utility methods. This class does not model a graph: all methods are static.
 *   
{@link org.plumelib.util.Intern Intern}
 *   
Utilities for interning objects. Interning is also known as canonicalization or
 *       hash-consing: it returns a single representative object that {@code .equals()} the object,
 *       and the client discards the argument and uses the result instead.
 *   
{@link org.plumelib.util.IPair IPair}
 *   
Immutable pair class: type-safely holds two objects of possibly-different types.
 *   
{@link org.plumelib.util.MPair MPair}
 *   
Mutable pair class: type-safely holds two objects of possibly-different types.
 *   
{@link org.plumelib.util.WeakIdentityPair WeakIdentityPair}
 *   
Immutable pair class with weakly-held values. Differs from {@code IPair} in the following
 *       ways: cannot hold null, holds its elements with weak pointers, clients must use getter
 *       methods rather than accessing the fields, and its {@code equals()} method uses object
 *       equality to compare its elements.
 *   
{@link org.plumelib.util.UtilPlume UtilPlume}
 *   
Utility methods that do not belong elsewhere in the plume package: BitSet; File;
 *       directories; file names; reading and writing; hashing; ProcessBuilder; properties; Stream;
 *       Throwable.
 * 
 */
package org.plumelib.util;