Package ariba.util.core Description

Utility classes

See Also:
ariba.util.log,, java.util

Interface Summary
Blob Represents a stream based interface to a "binary large-object" (or blob for short.)
ClassFactory Interface to provide settable class factory.
ClassProxy Objects that implement ClassProxy will be able to get the Class of the object they represent, and answer convenient instanceOf questions.
CommandLine This interface provides a general mechanism for its clients to set up the command line arguments that it is expecteing, to process the arguments, and finally to run with the input arguments.
Compare Compare is an interface that provides an object comparison function for use by the static sorting methods in Sort.
ConsistentHashRing.HashFunction The HashFunction interface is used to implement the hashing function for the keys.
ContextCommandLine This interface provides a general mechanism for its clients to set up the command line arguments that it is expecting, to process the arguments, and finally to run with the input arguments.
DebugState DebugState is used on conjunction with the ThreadDebugState class to print out information on the current application state when problems occur, or for general debugging.
EncodingMapStrategy This interface provides a general mechanism replace EmailEncodingMap
Executor Copy of the java.util.concurrent.Executor which is part of Java 5.0
GlobalLock Interface for a GlobalLock.
GlobalLockingService provide services for acquiring global locks and creating lock groups.
Linkable By implementing this interface the object in question can be stored in a LinkableList.
LRURemoveListener For use with LRUHashtable
MIMESource This interface provides the abstraction of MIME data source.
OutputStreamHolder Represents the capability to hold an OutputStream.
PerformanceCheck.ErrorSink Callback interface for to record warnings/erros detected.
Priority Priority represent the user preceived speed of an operation, not necessarily the speed of the operation.
ReferenceReader Interface class for reading value of a parameter reference.
RejectedExecutionHandler An interface for handling rejected executions.
ServerExtension Interface used to bind new extension into the server.
ServerInterface Interface that defines basic functionalities that should be provided by the servers.
StringCSVConsumer The StringCSVConsumer is callback from ResourceSerivce to process string tables.
StringTableProcessor The StringCSVProcessor is callback for ResourceSerivce to process string tables.
Target Interface enabling a generalized object request framework.
ThreadFactory ThreadFactory's allow an API to create threads that match the callers desires in terms of implementation.
ThreadManager Interface to allow Ariba thread management.
ThreadNamedPropertyGetter use this interface to get named property per thread
ThreadNamedPropertySetter use this interface to set named property per thread
ThreadPoolMonitor This interface specifies a hook to monitor the thread pool.

Class Summary
AndPredicate<T> Implements a boolean and of the contained set of predicates
ArgumentParser Provide a cleaner way of handling arguments to public static void main (String args[]).
Arithmetic Arithmetic is an abstract class that encapsulates the idea of doing simple arithmetic operations on instances of the sub-types of java.lang.Number.
Arithmetic.Operation Enumeration class capturing binary operations on instances of java.lang.Number.
ArrayUtil Array Utilities.
Assert This class defines and implements various Assert methods
Asynchronous Dummy type for RPC's that are asynchronizes and have a void return type.
Base64 Base64.
BatchMapProcessor Convenience class that abstracts the notion of processing a map of objects in batches.
BatchProcessor Convenience class that abstracts the notion of processing a collection of objects in chunks of a given size.
BatchSizer Is a class that defines how a stream of objects should be batched.
BatchSizer.Fixed Is a batch sizer that uses a simple fixed batch size.
BooleanArray A DynamicArray of Booleans
BufferPool<T extends Buffer> This abstract self cleaning pool of Buffer instances can be extended by subclasses for specific types of Buffers, for example CharBuffer and ByteBuffer.
ByteBufferPool This class implements a self cleaning pool of ByteBuffers, each wrapped around a byte array of the configured buffer length.
CharBufferPool This class implements a self cleaning pool of CharBuffers, each wrapped around a char array of the configured buffer length.
ChecksumManager Service that manages ComponentChecksums.
Chrono Simple timing class, used for timing one or more trials of an event.
ChronoWithMemory Chrono subclass which displayed more information when being printed.
ClassExtension The ClassExtension class is the abstract superclass for all ClassExtension subclasses.
ClassExtensionRegistry The ClassExtensionRegistry class provides a convenient and consistent way to cache ClassExtension subclasses.
ClassUtil ClassUtil.
ComponentChecksum The abstract class to support checking the that the runtime configuration of components are consistent within a cluster.
ConsistentHashRing<T> The Consistent Hash Ring is a data structure that is used to load balance resources across several server nodes.
ConsistentHashRing.MD5HashFunction A MD5 hash function which is a good alternative for uniform hashing.
Constants Constants for well known values
Crypt Crypt
Crypto Disclaimer.
DatabaseBaseId This is a stripped down BaseId, for use in tools (such as migration) below the level of ObjectServer.
Date The Date class implements helper functions on top of the java.util.Date class.
DefaultThreadManager Default implementation that doesn't do anything.
Deque This class implements a double-ended queue (pronounced like "deck").
DoubleArray A DynamicArray of Doubles
DynamicArray A DynamicArray is like List except that is exposes the underlying array.
EqHashtable This class extends Hashtable, but provides for pointer hashing and equality instead of hashCode() and equals() equality.
EqLRUHashtable This class extends LRUHashtable, but provides for pointer hashing and equality instead of hashCode() and equals() equality.
EventLoop A simple event loop
EventQueue A simple queue of events that can be added to and waited on by multiple threads
Factory<T> Convenience generic factory class.
FastStringBuffer Object subclass resembling the java.lang.StringBuffer class (an object that manages a mutable string).
Feature<T> Represents a feature or capability in the system and can answer the question of whether the feature is enabled in an instance of a given context, which is specified by the generic T parameter.
FeatureConfig<T> Different products will fetch configuration in various ways: file, DB, etc.
FeatureSet<T> A feature set groups a set of features (Feature) by name.
FileArray A DynamicArray of Files
FileCompare An implementation of Compare for Files
FileComponentChecksum This class extends the ComponentChecksum class to compute a checksum for files and directories.
FileReplacer Utility class that supports replacing a given base file with a new file (typically, a new version of that file.)

There is support for obtaining an OutputStream to write a changed version of the file, applying the changes, then reverting the changes (you can apply and revert changes as many times as desired) before finally committing either the applied or reverted changes (dropping the files used for temporary storage.)

The temporary files are stored in the same directory as the base file.

FileUtil File Utilities.
Fmt Formatted output.
FormatBuffer A version of a FastStringBuffer that is able to append some basic java types directly without having to use intermediate strings.
Function<K> Generic class that represents a function returning a type K.
Function.MethodFunction<T> Convenience nested class that adapts a Method into a Function
GlobalLocking Finder class for the GlobalLockingService
GlobalLockUtil A helper class for acquiring and releasing global lock
Gridtable A two-dimensional map.
GrowOnlyGridTable A two-dimensional GrowOnlyHashtable.
GrowOnlyHashSet A GrowOnlyHashSet built on top of a GrowOnlyHashTable.
GrowOnlyHashtable<K,V> A version of Hashtable that...
GZipUtil Utility class to perform gzip on strings, byte arrays, etc.
Hashtable A Hashtable class that has a number of performance improvements over other Hashtable classes.
HeapTimerQueue An implementation of a TimerQueue that stores the Timers in a PriorityQueue.
Holder<V> Convenience class that makes it a little simpler to write a lazily evalated value.
HTML Some HTML helpers
IntCompanionSort provides functions for sorting arrays of objects, with integer companion arrays
IntegerArray A DynamicArray of Integers
InternCharToString This class implements an instance of a GrowOnlyHashtable with the following properties: -- implements a version of intern() that does not have the small size limitations of the native intern() methods on at least hp and nt.
IOUtil Input/Output Utilities.
IOUtil.BufferHolder Holds a byte buffer for use in this class while copying bytes around.
IteratorUnion An enumeration that is the union of a list of enumerations.
JavaThreadFactory A ThreadFactory for plain Java Threads
LinearLRUHashtable Provides an LRUHashtable that uses linear growth (the LRUHashtable class uses exponential growth).
Link Link implements a fairly textbook "link" suitable for use in a doubly linked list.
LinkableList LinkableList implements a fairly straightforward doubly linked list.
LinkedList This class implements a basic doublely linked list.
LinkedTimerQueue A TimerQueue implemented using a linked list of Timers.
LinkPayload LinkPayload is a simply wrapper around Link that includes a payload reference.
ListUtil List Utilities.
ListUtil.Comparator<T extends List<?>> Is a java.util.Comparator for Lists based on a supplied elementComparator that delegates to, java.util.List, java.util.Comparator) when doing the comparison.
LRUEntry An entry in LRUHashtable.
LRUHashtable A hashtable that tracks the age of entries.
MapArray A DynamicArray of Maps
MapBasedSet A generic implementation of the Set built on top of a Map.
MapUtil Map Utilities.
MasterPasswordClient Manages master password.
MathUtil Math Utilities.
MemoryOptimizedMap<K,V> This is a map implementation that is very memory efficient for very small maps.
MemoryStats Simple class that captures the current memory situation.
MessageDigestUtil A utility class for generating message digests, suitable for password hashing.
MimeEncoding This class is generated by Add Language Tool.
ModifiableInteger This is a handy class to use in cases where Integer needs to be part of a Collection object, yet needs to be modified very frequently.
ModMofNPredicate<T> Implements a predicate on the mod of some hash function of T.
MultiKeyHashtable A MultiKeyHashtable class that allows for multiple keys per entry.
MultiValueHashtable A map like class that can store multiple values for the keys.
NamedValue Simple class to store a simple pair name/value
NoCrypto Disclaimer.
NonCachingClassLoader Implementation of a ClassLoader that can be used to force reloading of class files from the file system.
NotPredicate<T> Implements a boolean not of the contained predicate.
ObjectArray A DynamicArray of Objects No array() needed because the underlying array is the same type
ObjectLockManager This class maintains a set of objects that can be exclusively locked.
ObjectUtil This is a class of static methods useful for Objects in general.
OrderedHashtable An OrderedHashtable is just like a normal Hashtable except that it remembers the order the keys were added to the table and, whenever keys() or elements() is called, they are returned in that order.
OrPredicate<T> Implements a boolean or of the contained set of predicates
Parameters Interface to access easily configuration parameters
PerformanceCheck PerformanceCheck defines a set of expected performance boundaries for task execution.
PerformanceChecker Object used by the PerformanceCheck to check a specific metric (or PerformanceStateCore).
PerformanceState This class maintains performance state for the current thread.
PerformanceStateCore This class is the root for performance counters.
PerformanceStateCore.Instance the real data bearing instance
PerformanceStateCounter A thread specific counter.
PerformanceStateCounter.Instance the real instance
PerformanceStateCPUTimedCounter A performance counter for thread CPU time.
PerformanceStateTimedCounter.Instance the real instance
PermutationIterator A PermutationIterator produces a series of permutations of the requested size from a source array of objects.
Pool Generic resource pooling mechanism
ProgressMonitor This class stores the user-visible progress information for the current thread so that it can be queried / reflected by a progress panel in the UI.
PropertyTable PropertyTable is an extension of a Map which provides additional convenience methods and some minor semantic changes.
QuickTableDiff Simple command line tool to diff to table files.
ReadOnlyMap<K,V> A Map-like object that can't be modified - not because it is immutable (which would raise a run-time exception), but because it has no API for modifying it.
ReferenceHandler Handles paramaters via indirect references.
ReferenceSyntaxParser This class provides methods to parse Strings that may contain remote and/or local references.
ResourceService The fundamental API to resolving localized resources.
SecurityHelper Very poor stop-gap measure to prevent bogus access to some vital stuff.
SelfCleaningPool<T> Generic resource pooling mechanism, that uses Timer to return allocated storage to be garbage collected when it is no longer needed for current usage patterns.
SelfCleaningPool.PoolFloat<T> Nested class that wraps up an actual resource instance.
SetUtil Set Utilities.
SignalHandler Wrapper around the sun.misc.SignalHandler to avoid having the rest of the application to depend on this undocumented class and as such can be changed in any Java release.
SimpleComponentChecksum A simple implementation of ComponentChecksum that saves a stored byte array.
Sort Sort provides functions for sorting arrays of objects.
SparseVector Object subclass that manages an array of objects.
StringArray A DynamicArray of Strings
StringCompare An implementation of Compare for Strings
StringCompareIgnoreCase An case insensitve implementation of Compare for Strings
StringUtil String Utilities.
StringUtil.SearchResult Small struct class that captures the result of search for a string within some other unidentified string or stream.
SubsetIterator A SubsetIterator produces a series of subsets of the requested size from a source array of objects.
SystemUtil System Utilities.
SystemUtil.ValidCaller A simple bean to hold the attributes of a valid caller for use by validateCaller method.
TableUtil Table file Utilities.
ThreadDebugKey A key to use with ThreadDebugState.
ThreadDebugState This class maintains debug state for the current thread.
ThreadedQueue This is a ThreadedQueue used for a producer/consumer model of threads.
ThreadManager.NoOp Ultra simple implementation: all methods are no-op
ThreadNameAbbreviation Maintain short names for threads.
ThreadPool Standard non-extensible thread pool implememtation on top of queue.
ThreadPoolRejectedExecutionHandler A concrete implementation of RejectedExecutionHandler for ThreadPools.
Timer Object subclass that causes an action to occur at a predefined rate.
TimerQueue Private class to manage a queue of Timers.
TokenTable A table of tokens that map to objects.
URLUtil URL Utilities.
Vector Object subclass that manages an array of objects.
Version This class provides access to build version information.
VersionComponentChecksum Component checksum for the application version.
WhiteListPredicate<T,P> Implements a predicate for checking whether a property on T (fetched via property getter) is contained in the white-list
WriteResistantMap<K,V> Similar to a ReadOnlyMap, but with a method getMap enabling the caller to get direct access to the underlying Map, which may then be modified.

Enum Summary
Pool.PoolChangeReason Used with poolChange method to indicate the reason the pool was changed.
ResourceService.ResourceLocation Is an enumerated type representing the locations where string resources may be found under the string resource base URL.

Exception Summary
BatchProcessingException An exception that occurs during batch processing.
ComponentChecksumException The general exception wrapper for ComponentChecksums.
CycleException An exception that is thrown when a cycle is created.
FatalAssertionException Class used to represent a Fatal Assert Exception.
FileUtil.FileDeletionException Represents the exceptional condition where we expected to be able to delete a file but were not actually able to do so.
FileUtil.FileRenameException Represents the exceptional condition where we expected to be able to rename a file but were not actually able to do so.
GlobalLockingException Something went wrong in GlobalLocking, typically accessing an invalid lock
LobException Represents an exception that has occurred during an interaction with a large-object (lob.)
ReferenceReaderException Exception class to be used for ReferenceReader
RejectedExecutionException Exception thrown by an Executor when a task cannot be accepted for execution.
TransientException TransientException is designed to be thrown by application code that needs to halt execution of an action and display a localized error message to the user about the error while running an action in the UI.
TunnelingException TunnelingException is used to wrap a RunTimeException around a Exception.
WrappedException a generic exception subclass for all exceptions thrown.
WrapperRuntimeException The WrapperRuntimeException class provides a simple runtime exception for all the various problems which might occur within the FieldValue dispatch mechanism.

Error Summary
ExitException If Util.ExitException is true, SystemUtil.exit will throw an ExitException instead of calling System.exit for the purposes of the TestHarness.

AribaWeb User Interface Development Framework
Copyright © 2000-2014 Ariba, Inc. All Rights Reserved.