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.