Uses of Interface
com.antelmann.util.Wrapped

Packages that use Wrapped

com.antelmann.crm	Provides interfaces and classes for implementing applications dealing with Customer Relationship Management (CRM).
com.antelmann.db	This package contains generally useful classes for generic database management.
com.antelmann.genealogy.db	This package provides implementations that manage the persistence for the genealogy package.
com.antelmann.image	This package contains classes for more easily dealing with images.
com.antelmann.io	This package contains classes that are concerned with input/output operations.
com.antelmann.math	This package contains classes to ease calculations.
com.antelmann.net.mail	The classes in this package are designed to ease the handling of emails.
com.antelmann.net.web	This package contains classes for dealing with Web-related content.
com.antelmann.ooffice	The classes in this package are to be used in conjunction with OpenOffice.
com.antelmann.sql	This package contains classes to ease JDBC development and also provides useful SQL-based implementations for com.antelmann.db classes
com.antelmann.util	This package contains generally useful classes that are used throughout the other packages in this framework.
com.antelmann.util.gui	This package contains utility classes for GUI related implementations.
com.antelmann.util.logging	This package contains classes that implement a custom logging for this framework - separate from java.util.logging.
com.antelmann.util.table	This package provides useful additions to TableModels and contains classes to ease development with Swing tables.

Uses of Wrapped in com.antelmann.crm

Classes in com.antelmann.crm that implement Wrapped

class	AddressableMapper<T extends Addressable & DBEntry> handles the address of a given addressable entry
class	FriendsEntryStore<T extends FriendsEntry<?>>

Uses of Wrapped in com.antelmann.db

Subinterfaces of Wrapped in com.antelmann.db

interface

ProcessedFilterOption<T extends DBEntry> allows to control whether a processor is run before filtering when using a WrappedDBClassStore.

Classes in com.antelmann.db that implement Wrapped

class	ArchiveDBClassStore<T extends DBEntry> allows to add an archive store to any given store, which enables to extend the data set.
class	DBClassStoreCache<T extends DBEntry> a special store that has the ability of caching entries, so that multiple calls to retrieve an entry may be answered through cache hits.
class	LockManager provides methods for persistent locks on DBEntry objects.
class	ReadOnlyCacheStore<T extends DBEntry> provides a transaction-independent, in-memory-cached, read-only wrapper around a given store.
class	ReadOnlyStore<T extends DBEntry> a wrapper around a DBClassStore that disables altering the store's content
class	StoreUpdateTableModel<T extends DBEntry> a special TableModel wrapper that supports store updates upon StoreUpdateTableModel.setValueAt(Object, int, int)
class	TransactionalNumberGenerator provides a wrapper around a given number generator that provides a counter that can increment and cache its generated values within a running transaction without having to make the potentially expensive call to the embedded ValueRetriever.
class	WrappedDBClassStore<T extends DBEntry> a generic DBClassStore wrapper easing the implementation of special wrappers.

Uses of Wrapped in com.antelmann.genealogy.db

Classes in com.antelmann.genealogy.db that implement Wrapped

class

GPersonStore

Uses of Wrapped in com.antelmann.image

Classes in com.antelmann.image that implement Wrapped

class

ImageURLEntrySQLStore<T extends ImageURLEntry> an implementation of a DBClassStore to be used with ImageURLEntry objects.

Uses of Wrapped in com.antelmann.io

Classes in com.antelmann.io that implement Wrapped

class

BinaryData allows to keep an instance that will produce an InputStream on demand while supporting serialization of the same.

Uses of Wrapped in com.antelmann.math

Classes in com.antelmann.math that implement Wrapped

class	CurrencyUnit a wrapper that allows a currency to be treated as a unit
class	SIBaseUnit represents a standard SI base unit.

Uses of Wrapped in com.antelmann.net.mail

Classes in com.antelmann.net.mail that implement Wrapped

class

MessageEntry A wrapper around a Message object that allows for database storage and serialization.

Uses of Wrapped in com.antelmann.net.web

Classes in com.antelmann.net.web that implement Wrapped

class	RSSChannel represents a channel in the RSS format created by an RSSHandler
class	RSSItem represents an item in an RSS feed

Uses of Wrapped in com.antelmann.ooffice

Classes in com.antelmann.ooffice that implement Wrapped

class	Cell wrapper around com.sun.star.table.XCell to avoid having to compile with office classes.
class	OfficeElementTreeNode
class	OOTableWriter provides easy to use table-related functionality for TextFrames This class implements ThirdParty for its use of OpenOffice libraries; see www.openoffice.org

Uses of Wrapped in com.antelmann.sql

Classes in com.antelmann.sql that implement Wrapped

class	CategoryStore<T extends Category<?> & DBEntry> provides an SQL-based store wrapper to handle categories more easily based on a column that contains the parent-category-id.
class	ConnectionHelper The class JDBC provides several useful methods for handling JDBC connections.
class	ConnectionWrapper provides a wrapper for a connection that allows to replace the underlying connection
class	DBDocumentStore<T extends DBDocument>
class	DriverWrapper wraps a given driver (that is potentially loaded from a URLClassLoader) so that it can be loaded from the system class loader.
class	MSAccessHelper provides added functionality for Microsoft Access databases
class	MySQLHelper provides added functionality for MySQL database
class	PropertyEntryHeaderStore<T extends EntryHeader<?>> useful for mapping EntryHeader objects transparently to support the PropertyEntry interface on the header store (for filtering purposes)
class	PropertyEntryTableStore<T extends PropertyEntry> a specialized store that provides help for dealing with PropertyEntry objects, assuming that the properties are to be stored in a separate detail table.
class	ResultSetTableModel ResultSetTableModel provides a convenient way to display (or otherwise use) a query result in table format.
class	SortedGroupableSQLStore<T extends DBEntry & SortedGroupable<G>,G extends Keyword> a special store that supports SortedGroupable DBEntry instances
class	SQLColumnInfoStore<T extends DBEntry> an special store providing an implementation for SQLColumnInfo based on a store that provides MappingInfo
class	SQLFetchSizeFilter<T> allows to specify the intended fetch size to be used for the query when executing a fetch on a store
class	SQLServerHelper provides added functionality for Microsoft SQL Server databases
class	TaggableHeaderStore<T extends EntryHeader<?>> useful for mapping EntryHeader objects transparently to support the TaggableMapping interface on the header store (for filtering purposes)
class	TaggablePropertyEntrySQLStore<T extends PropertyEntry & Taggable<G>,G extends Keyword> a convenient standard implementation of a DBClassStore combining TaggableMapping and PropertyEntryMapping.
class	TaggableSQLStore<T extends Taggable<G> & DBEntry,G extends Keyword> provides a store that can wrap any given store to provide persistence for its grouping capacity based on Keyword objects.
class	UnionSqlStore<T extends DBEntry> implements a read-only store that is based on a union-sql-query derived from the common columns of a number of given stores.
class	UserImplStore<T extends UserImpl> provides a user store implementation that implements UserLoginStore, so that the database can be queried based on that interface.
class	WrappedDBClassStoreMapping<T extends DBEntry> eases the wrapping of stores that need to override certain mapping infos
class	WrappedObjectRowMapper<T extends DBEntry> eases the task of wrapping a given mapper and overriding only certain aspects of its behavior.

Uses of Wrapped in com.antelmann.util

Classes in com.antelmann.util that implement Wrapped

class	DelayedTask a utility class to define a delayed task while allowing to easily postpone the execution at any time to the full delay time.
class	IteratorQueue<T> a special iterator that supplies elements from an embedded blocking queue and blocks on calls to IteratorQueue.hasNext().
class	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.
class	PerformanceMonitor<T> allows to easily monitor the performance of method calls of an interface and then analyze the data based on a TimeDataGrid.
class	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.
class	ReferenceHolder<T> useful to easily cache a large value 'softly' or 'weakly' through a ValueRetriever using a Reference.
class	SoftHolder<T> useful to cache a large value 'softly' through a ValueRetriever using a SoftReference and very easy to use.
static class	VerboseFilter.Adapter<T>
class	WeakHolder<T> useful to cache a large value 'weakly' through a ValueRetriever using a WeakReference and very easy to use.
class	XmlHelper a helper class that allows to easily handle some aspects of an xml source element and also provides some convenient utility functions.

Uses of Wrapped in com.antelmann.util.gui

Classes in com.antelmann.util.gui that implement Wrapped

class	CategoryNode<T> provides a model for organizing categories in a tree.
class	JSearchTree a wrapper around a JTree that makes it easier to find a node.
class	SubTreeModel represents a specific branch of a given wrapped tree model.

Uses of Wrapped in com.antelmann.util.logging

Classes in com.antelmann.util.logging that implement Wrapped

class	AppendableLogWriter writes to a given Appendable (PrintStream, StringBuffer, etc) using a String
class	AsynchLogWriter allows to operate any LogWriter asynchronously.
class	ConsoleLog ConsoleLog prints abbreviated log messages to the console using System.out.println().
class	LoggerWriter provides a writer that propagates the LogEntries to another logger

Uses of Wrapped in com.antelmann.util.table

Classes in com.antelmann.util.table that implement Wrapped

class	ConvertedObjectTableModel<X,T> allows to use an ObjectTableModel for a different type by providing a conversion
class	ConvertedTableModel a special model that allows converting the values before setting/getting a cell value.
class	FilteredTableModel a wrapper around a TableModel allowing filtering
class	MovableTableModel a wrapper around a TableModel allowing to rearrange its rows.
class	ObjectTableModelView<T> combines the features of an ObjectTableModel with a TableModelView
class	ObjectTableModelWrapper<T> a wrapper around a TableModel that also supports ObjectTableModel
class	RowNumberTableModel wraps a given TableModel and adds a first column that simply contains a row numbering
class	SortableTableModel a wrapper around a TableModel allowing to sort the model.
class	TableModelRenderer allows to delegate the rendering of table columns to the model if applicable
class	TableModelView provides a view/projection of a given TableModel.
class	TableModelWrapper allows to easily wrap a given table model and quickly just override a single method or customize the model by using appropriate methods herein.
class	TransposedTableModel the first column of the given model will become the header row of the transposed model
class	WrappedTableCellRenderer allows to easily adjust the behavior of a given renderer