Package com.samskivert.util

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

See:
Description

Interface Summary

CountHashMap.Entry<K>
DebugChords.Hook	Provides the mechanism by which code is provided to be run when a user depresses a particular key combination.
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 object creation by calling nextInt().
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.
ListUtil.EqualityComparator	Used to allow the same code to optionally use reference equality and Object.equals(java.lang.Object).equality.
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	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.
ValueMarshaller.Parser

Class Summary

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).
BasicRunQueue	A very basic implementation of RunQueue for general purpose use.
CalendarUtil	Contains some useful calendar related functions.
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.
Collections.MetaIterator<T>	An iterator that iterates over the union of the iterators provided by a collection of iterators.
Collections.SynchronizedCollection<E>	I wish I could use this from the java.util.Collections class, but those crazy kids at Sun are always using private and default access and pointlessly preventing people from properly reusing their code.
Collections.SynchronizedIntMap<V>	Horked from the Java util class and extended for IntMap.
Collections.SynchronizedIntSet
Collections.SynchronizedSet<E>	I wish I could use this from the java.util.Collections class, but those crazy kids at Sun are always using private and default access and pointlessly preventing people from properly reusing their code.
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.
ConfigUtil.PropRecord	Used when parsing inherited properties.
CountHashMap<K>	A hashmap that maintains a count for each key.
CountHashMap.CountEntryImpl<K>
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.
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.
GenUtil	Utility methods for code that generates code.
HashIntMap<V>	An int map is like a regular map, but with integers as keys.
HashIntMap.Record<V>
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.
Interval.IntervalTask	The task that schedules actually runs the interval.
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.
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.
Invoker.UnitProfile	Used to track profile information on invoked units.
JDK14Logger	A factory for creating JDK14 logger implementations.
JDK14Logger.Impl
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.
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.
Log4JLogger.Impl
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>	A useful building block for implementing one's own Map classes.
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.
PrefsConfig.NullPreferences	This is used if we don't have security access to the preferences implementation that we'd like.
ProcessLogger	Reads the output from a process and copies any output to a supplied Logger.
ProcessLogger.StreamReader
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).
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."
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.
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.
ShortestPath.NodeInfo	Used to maintain information during the shortest path search.
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 unsuprressable 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. vt100, xterm, etc.) in which our code is running.
Throttle	A throttle is used to prevent code from attempting a particular operation too often.
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.
WeakObserverList.DerefOp<T>	An operation that resolves a reference and applies a wrapped op.

Enum Summary

SignalUtil.Number

Exception Summary

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.