Holger's Java API

## Package com.antelmann.util

This package contains generally useful classes that are used throughout the other packages in this framework.

See:
Description

Interface Summary
CascadingFilter<T>: a filter that relies on another embedded filter for further filtering (which in turn may yet be another CascadingFilter)
Compound<T>: denotes an object that consists of other components
Converter<T1,T2>: used to transform an object into another representation, which is optionally reversible
DetailedString: implementing classes provide a String suitable for displaying their full instance details in a (potentially multi-line) String.
Discriminator<T>
Enabled: specifies methods that allow to determine and alter the status of an object in regards to it being enabled or not
Factory<T>: provides a generic factory
Filter<T>: used to filter collections or anything else.
Forgeable<T>: defines an object that is capable of behaving like another one by applying all properties from the given one to this instance
Handler<T,E extends Exception>: a fairly generic way to specify some handler to be used as an easy-to-use call-back mechanism
InterfaceMonitor: allows to monitor all method calls to an object through a proxy object based on a specified interface.
LifeCycleObject: specifies an object that has a begin and end in time.
ListRetriever<T>: to be implemented by classes that are to provide a special list of objects that are flexibly generated at runtime.
Localizable: instances of Localizable are objects that support localized return values for their methods based on a Locale that can be set on the instance prior to calling a method.
NotificationListener: listens for notifications based on certain monitored objects.
NotificationService.Listener
PatternExtractor<TYPE,PATTERN>: PatternExtractor provides a way to group objects by a pattern defined by an implementation.
PrintUtilities.Printer: allows to plug in a printing service into PrintUtilities
Processor<T,E extends Exception>: a generic callback mechanism to handle and/or substitute objects while being able to throw a declared Exception
ProcessorHook<T,E extends Exception>: ProcessorHook objects allow to register multiple Processor instances for processing purposes
QueryMechanism: provides a generic way to query an object for flexible functionality
Refreshable: marks classes that have content that can be refreshed
SynchronousKey: An interface to support very simple synchronous key encryption.
Task<EX extends Exception>: A task that - opposed to Runnable - may throw a certain exception.
ThreadWorker.Listener: listens for tasks run by a ThreadWorker to be finished
ValueRetriever<T>: provides a way to access a specific value that is relevant to a given context at the time of calling the interface's method
ValueSetter<T>: provides a way to generically set some relevant value on some instance
VerboseFilter<T>: a special filter that will provide a message if this instance doesn't accept an element.
WarningOnly: tagging interface for Exceptions that are considered recoverable from a user's perspective
Wrapped<T>: indicates that this is a wrapper around another object

Class Summary
AbstractIterator<E>: makes it very easy to implement both, Enumeration and Iterator.
Bootstrapper: a special class that allows to bootstrap another java application by calling it via reflection within a given class loader context.
CipherKey: CipherKey provides a very easy-to-use, yet effective encryption mechanism.
ComboFilter<T>: a special filter that allows to combine different filters.
ComparableString: a small utility class that provides a special object that is comparable independently of its display value
Converter.Adapter<T1,T2>
Country: allows to treat a country just like any other DBEntry object and includes useful components to use countries in tables and lists.
Country.Store: provides a convenient read-only store for all existing Country objects without having to hold them all in memory constantly
DefaultTransferable: provides a simple standard way to generate a transferable object quickly.
DelayedTask: a utility class to define a delayed task while allowing to easily postpone the execution at any time to the full delay time.
Encoded: Encoded encapsulates a serializable object in an encrypted format that requires the same synchronous key for both, encoding and decoding.
FormattedResourceBundle: a ResourceBundle that gets its content from a specially formatted file, supporting different encodings, in particular UTF8 for global support.
HandlerList<T,E extends Exception>: allows to combine different handlers.
I18n: some utility methods useful for internationalization.
InterfaceMonitor.Adapter: a helper class to facilitate the implementation of the enclosing interface
InterfaceMonitor.IMLogger: a convenience class that simply logs all access to an interface
InterfaceMonitor.Profiler: allows to profile the access to an interface
InterfaceWrapper: provides methods to generate special proxy objects that observe calls to specified interfaces
IteratorQueue<T>: a special iterator that supplies elements from an embedded blocking queue and blocks on calls to `IteratorQueue.hasNext()`.
Localizable.Adapter
MethodComparator<T>: compares objects by the return value of a specified method name.
MethodFilter<T>: a special filter that can filter objects based on the return values of methods that take no parameters and return something but void.
Misc: just some miscellaneous stuff for convenience that doesn't fit anywhere else
Monitor: Monitor is a convenient class that is useful to communicate between threads by exchanging information through this Monitor.
MonitorDelegate: The relevant calls to the monitor are delegated to a ProgressMonitor or JProgressBar or Logger.
NotificationListener.Adapter
NotificationService: a singleton that maintains Notifier objects
Notifier: Notifier objects are created exclusively by the NotificationService and deliver events as long as they are not stopped by the NotificationService.
OffsetFilter<T>: a filter that specifies to a supporting implementation that not all results are desired, but only those starting at a given offset and limited to a given limit.
PDFUtils: a few utility methods surrounding PDF.
PerformanceMonitor<T>: allows to easily monitor the performance of method calls of an interface and then analyze the data based on a `TimeDataGrid`.
Placeholder<T>: useful for storing immutable objects in local variables which are used in inner classes when the value may change or to enable 'call by reference' on methods with otherwise primitive parameters.
PrintUtilities: some ease-of-use-functions for printing.
ProcessorList<T,E extends Exception>: allows to combine different processors.
RandomFilter: a special filter that randomly accepts Objects based on given odds.
Range<T extends Comparable<? super T>>: provides a generic wrapper for lower- and upperbounds for a comparable object.
ReferenceHolder<T>: useful to easily cache a large value 'softly' or 'weakly' through a ValueRetriever using a `Reference`.
SecurityUtils: a collection of security related names of supported algorithms - just for reference.
Sets: utility class for calculations on sets, lists and other collections.
SimpleEntry<K,V>: a simple convenient Map.Entry implementation
SimpleEntry.Editable<K,V>: makes `SimpleEntry.Editable.setKey(Object)` public
SimpleEntry.Immutable<K,V>
SimpleKey: A very simple encryption algorithm for demonstration purposes only.
SoftHolder<T>: useful to cache a large value 'softly' through a ValueRetriever using a `SoftReference` and very easy to use.
Strings: A utility class with several useful functions to manipulate String objects.
TextPrinter: enables printing of plain text with line wrapping over multiple pages
ThreadPool: uses a pool of threads to execute tasks asynchronously and concurrently.
ThreadWorker: ThreadWorker runs tasks in a separate thread, where the tasks are queued up and performed one by one.
ThreadWorker.Listener.Adapter
UniversalComparator: The UniversalComparator is useful as a default if no other more specific sorting strategy is present.
VerboseFilter.Adapter<T>
WeakHolder<T>: useful to cache a large value 'weakly' through a ValueRetriever using a `WeakReference` and very easy to use.
XmlHelper: a helper class that allows to easily handle some aspects of an xml source element and also provides some convenient utility functions.

Enum Summary
Direction: useful for providing directions, so to speak.
Strings.Symbol: generally useful symbols to ease their use in non-UTF8 source code Convenient example tables are found e.g. here: http://www.csbruce.com/software/utf-8.html

Exception Summary
CancellationWarning: indicates that an operation has been deliberately canceled, which is only to be viewed as a warning
FormatException: indicates that some content was not in the expected format
GeneralWarning
InconsistentContentException: indicates that some object is not in a consistent state
IterationException: thrown to indicate a problem during iteration.
OptionNotAvailableWarning: thrown to indicate that a given option is currently not available
ResourceNotFoundException: Thrown to indicate that a specific resource (an image, a sound, etc.) needed to perform the requested operation was not found (while the resource was expected to be present with the distribution of this Antelmann.com framework).

Annotation Types Summary
Localized: marks a method that is affected by changing the locale of a Localized instance.

## Package com.antelmann.util Description

This package contains generally useful classes that are used throughout the other packages in this framework.

(c) Holger Antelmann since 2001- all rights reserved (contact: info@antelmann.com)
see www.antelmann.com/developer for further details and available downloads