Package com.samskivert.util

Provides a variety of utility services including data structures, synchronization support, text processing and more.

See:
Description

Interface Summary

ByteEnum	An interface implemented by enums that can map themselves to a byte.
CountHashMap.Entry<K>
DebugChords.Hook	Provides the mechanism by which code is provided to be run when a user depresses a particular key combination.
Folds.F<B,A>	Used with Folds.foldLeft(com.samskivert.util.Folds.F, B, java.lang.Iterable).
Folds.R<A>	For reductions and same-typed folds.
Interable	An interface similar to java.util.Iterable.
Interator	Can be used as an Iterator, and all Objects returned should be Integer objects, but can also can avoid boxing by calling Interator.nextInt().
Interval.Factory	An interface for entities that create, and keep track of, intervals.
Interval.RunBuddy	An interface that will be implemented by the runnable posted to a RunQueue that can be used to retrieve the original Interval.
IntIntMap.IntIntEntry
IntMap<V>	An int map is a map that uses integers as keys and provides accessors that eliminate the need to create and manipulate superfluous Integer objects.
IntMap.IntEntry<V>	An IntMap entry (key-value pair).
IntResultListener	Provides access to an integer result, or the exception associated with failure.
IntSet	A set that holds integers and provides accessors that eliminate the need to create and manipulate superfluous Integer objects.
Lifecycle.BaseComponent	An interface implemented by components which wish to participate in the lifecycle.
Lifecycle.Component	An interface implemented by components which wish to participate in the lifecycle.
Lifecycle.InitComponent	An interface implemented by components which wish to participate in the lifecycle.
Lifecycle.ShutdownComponent	An interface implemented by components which wish to participate in the lifecycle.
Logger.Factory	Used to create logger instances.
LogProvider	The log provider interface allows the simple logging services provided to the samskivert codebase to be mapped onto an actual logging framework.
LRUHashMap.ItemSizer<V>	Used to return the "size" of a cache item for systems that wish to differentiate cache items based on memory footprint or other metric.
LRUHashMap.RemovalObserver<K,V>	An observer may be registered with a LRU hash map to be notified when items are removed from the table (either explicitly or by being replaced with another value or due to being flushed).
ObserverList.ObserverOp<T>	Instances of this interface are used to apply methods to all observers in a list.
ResultListener<T>	Provides access to a future result, or the exception associated with failure.
RunQueue	An interface for a service that queues up execution of Runnables.
SerialExecutor.ExecutorTask	A task to run in serial on the executor.
ShortestPath.Graph<T,V>	A caller must implement this interface to provide the information needed to define the graph and compute the shortest path.
SignalUtil.Handler
StringUtil.CharacterValidator	Validates a character.

Class Summary

AbstractInterator	A building-block for writing an Interator.
AbstractIntSet	A base class for IntSet implementations.
ArrayIntSet	Provides an IntSet implementation using a sorted array of integers to maintain the contents of the set.
ArrayUtil	Miscellaneous utility routines for working with arrays.
AuditLogger	Used by various services to generate audit logs which can be useful for auditing, debugging and other logly necessities.
BaseArrayList<E>	Provides a base for extending the standard Java ArrayList functionality (which we'd just extend directly if those pig fuckers hadn't made the instance variables private). Note: Does not support null elements.
BasicRunQueue	A very basic implementation of RunQueue for general purpose use.
ByteEnumUtil	ByteEnum utility methods.
Calendars	A fluent approach to dealing with Calendar and some calendar related utilities.
Calendars.Builder	Provides fluent methods for operating on a Calendar.
CalendarUtil	Deprecated. Use Calendars.
Callables	Utilities for Callables.
ChainedResultListener<T,TT>	A result listener that contains another result listener to which failure is passed directly, but allows for success to be handled in whatever way is desired by the chaining result listener.
CheapIntMap	A low overhead hash map using positive integers as keys that is useful for fast storage and lookup of a small and bounded number of items.
ClassUtil	Class object related utility routines.
Collections	Provides functionality for the samskivert collections that the java.util class of the same name provides for the standard Java collections.
CollectionUtil	A collection of collection-related utility functions.
CompactIntListUtil	This class manages compact arrays of ints.
ComparableArrayList<T extends Comparable<? super T>>	Provides a mechanism (ComparableArrayList.sort()) for sorting the contents of the list that doesn't involve creating two object arrays.
ComparableTuple<L extends Comparable<? super L>,R extends Comparable<? super R>>	A pair of Comparable objects that is itself Comparable.
Comparators	A repository for standard comparators.
ComplainingListener<T>	A ResultListener that does nothing on success and logs a warning message on failure, that's all.
Config	The config class provides a unified interaface to application configuration information.
ConfigUtil	The config util class provides routines for loading configuration information.
CountHashMap<K>	A hashmap that maintains a count for each key.
CountMap<K>	A CountMap maps keys to non-null Integers and provides methods for efficiently adding to the count.
Crypt	An implementation of the Unix crypt() function.
CurrencyUtil	Currency related utility functions.
DebugChords	Provides a mechanism for causing code to be invoked when a particular key combination is pressed in a GUI application.
DefaultLogProvider	If no log provider is registered with the log services, the default provider will be used.
DependencyGraph<T>	Maintains a bidirectional graph to manage the order that the items are removed.
ExpiringReference<T>	Provides a simple way of tracking a resource that should become stale after a certain time period.
FailureListener<T>	The pessimist's dream.
FileUtil	Utility methods for files.
Folds	Various useful folds over iterables.
FormatterUtil	Helper bits for OneLineLogFormatter and TerseLogFormatter.
GenUtil	Utility methods for code that generates code.
HashIntMap<V>	An int map is like a regular map, but with integers as keys.
HashIntSet	A set of integers that uses hashing with linear probing to provide most of the memory usage and garbage creation benefits of ArrayIntSet and the performance benefits of a HashSet of Integers (and then some, because of better spatial locality).
Histogram	Used for tracking a set of values that fall into a discrete range of values.
Interval	An interface for doing operations after some delay.
IntIntMap	An int int map is like an int map, but with integers as values as well as keys.
IntListUtil	This class manages arrays of ints.
IntMaps	Provides static methods for creating mutable IntMap instances easily.
IntSets	Utility methods for working with IntSets.
IntTuple	A simple object that holds a reference to two ints.
Invoker	The invoker is used to invoke self-contained units of code on an invoking thread.
Invoker.Unit	The unit encapsulates a unit of executable code that will be run on the invoker thread.
JDK14Logger	A factory for creating JDK14 logger implementations.
KeyUtil	Handy functions for dealing with license key creation and general key issues.
KeyValue<K extends Comparable<? super K>,V>	Used to wrap a key/value pair into an object that behaves like the key but holds on to the value.
Lifecycle	Manages the lifecycle (initialization and shutdown) of a collection of components.
ListUtil	List util is for the times when you just can't bear the overhead of an ArrayList object to manage your list of objects.
Log	The log services provide debug, info and warning message logging capabilities for a set of modules.
Log4JLogger	A factory for creating log4j logger implementations.
LogBuilder	Formats a message and an array of alternating key value pairs like so:
Logger	Provides logging services to this library and others which depend on this library in such a way that they can be used in a larger project and easily be made to log to the logging framework in use by that project.
LoggingLogProvider	Configures the samskivert logging routines to use the Java logging facilities for logging.
LoopingThread	The looping thread provides the basic functionality for a thread that does its processing in a simple loop.
LRUHashMap<K,V>	A HashMap with LRU functionality and rudimentary performance tracking facilities.
MapEntry<K,V>	Deprecated. As of JDK version 1.6 a replacement is available: java.util.AbstractMap.SimpleEntry.
Mapping	A utility class to succinctly construct a HashMap seeded with particular mappings.
MethodFinder	Finds methods and constructors that can be invoked reflectively.
Multex	Provides support for delaying an action until some set of conditions have been satisfied.
ObjectUtil	Utility methods that don't fit anywhere else.
ObserverList<T>	Provides a simplified mechanism for maintaining a list of observers (or listeners or whatever you like to call them) and notifying those observers when desired.
OneLineLogFormatter	A briefer formatter than the default Java SimpleFormatter.
Predicate<T>	Arbitrates membership.
Predicate.And<T>	Includes an object if and only if all the predicates with which it was constructed also include the object.
Predicate.InstanceOf<T>	A simple predicate that includes an object if it is an instance of the specified class.
Predicate.Not<T>	Negates any other predicate.
Predicate.Or<T>	Includes an object if at least one of the predicates specified in the constructor include the object.
PrefsConfig	Extends the Config mechanism to allow the modification of configuration values, which are persisted using the Java preferences system.
ProcessLogger	Reads the output from a process and copies any output to a supplied Logger.
PropertiesUtil	Utility functions related to properties objects.
Queue<T>	A queue implementation that is more efficient than a wrapper around java.util.Vector.
QuickSort	A class to sort arrays of objects (quickly even).
Randoms	Provides utility routines to simplify obtaining randomized values.
RandomUtil	Provides miscellaneous utility routines to simplify obtaining useful random number values and to centralize seeding and proper care and feeding of the pseudo-random number generator.
RecentList	An array list that maintains a list of the N most recent entries added to it.
RepeatCallTracker	A class used to debug situations where a method that should be called once and only once is being called again later and one wishes to report the stack trace of the first and current calling on any repeat callings.
RepeatRecordFilter	Filters repeated log messages, emitting "Previous message repeated N times." when a non-repeated message is eventually logged.
ResultHandler<T>	Acts as a ResultListenerList until the result (or cause of failure) is received, after which ResultHandler.getResult(com.samskivert.util.ResultListener) provides the result immediately.
ResultListener.NOOP<T>	A result listener that does nothing for cases where that is an appropriate behavior.
ResultListenerList<T>	Multiplexes ResultListener responses to multiple ResultListeners.
RunAnywhere	Write once, run anywhere. Well, at least that's what it said in the brochures.
Runnables	Runnable related utility methods.
RunQueue.AsExecutor	Wee helper class to adapt a RunQueue into an Executor.
SerialExecutor	Executes tasks serially, but each one on a separate thread.
ServiceWaiter<T>	A handy base class for issuing server-side service requests and awaiting their responses from within a servlet.
ShortestPath	Implements Dijkstra's algorithm for finding the shortest path between two nodes in a weighted graph.
SignalUtil	A wrapper around Sun's internal signal handling bits that can be used to avoid a) an explicit dependency on Sun's internal stuff (assuming they deprecate that and replace it with something actually supported some day) and b) a slew of unsuppressable warnings every time you compile your project.
SoftCache<K,V>	Implements a SoftReference cache wherein the values in the hashmap are not prevented from being garbage collected.
SortableArrayList<T>	Provides a mechanism (SortableArrayList.sort(java.util.Comparator)) for sorting the contents of the list that doesn't involve creating two object arrays.
StringUtil	String related utility functions.
StringUtil.Formatter	Used to format objects in StringUtil.listToString(Object,StringUtil.Formatter).
SystemInfo	A record detailing that gathers and makes available various useful bits of system information.
TermUtil	Provides access to the very platform specific concept of the terminal (ie.
TerseLogFormatter	A very brief formatter that shows only the message and stack trace (if any).
Throttle	A throttle is used to prevent code from attempting a particular operation too often.
Triple<A,B,C>	A triple of values that properly implements Triple.hashCode() and Triple.equals(java.lang.Object).
Tuple<L,R>	A tuple is a simple object that holds a reference to two other objects.
ValueMarshaller	Provides a mechanism for converting a string representation of a value into a Java object when provided with the type of the target object.
WeakObserverList<T>	An ObserverList equivalent that does not prevent added observers from being garbage-collected.

Enum Summary

Lifecycle.Constraint	Constraints for use with Lifecycle.addInitConstraint(com.samskivert.util.Lifecycle.InitComponent, com.samskivert.util.Lifecycle.Constraint, com.samskivert.util.Lifecycle.InitComponent) and Lifecycle.addShutdownConstraint(com.samskivert.util.Lifecycle.ShutdownComponent, com.samskivert.util.Lifecycle.Constraint, com.samskivert.util.Lifecycle.ShutdownComponent).
ObserverList.Policy	Notification policies.
SignalUtil.Number

Exception Summary

MissingPropertyException	An exception thrown when a required property was not found.
ServiceUnavailableException	The service unavailable exception can be thrown by any service that relies on some other services which is currently not available.
ServiceWaiter.TimeoutException

Package com.samskivert.util Description

Provides a variety of utility services including data structures, synchronization support, text processing and more.