Holger's Java API

## Package com.antelmann.db

This package contains generally useful classes for generic database management.

See:
Description

Interface Summary
ArchivedStore<T>: allows to control the archive option of a supporting `DBClassStore`
Categorized<T>: specifies an object that is categorized.
Category<T>: represents a category that may be associated with any kind of entry and supports cascading sub-categories
CategoryManager: specifies the functionality commonly used to deal with categories and implemented by a `DBClassStore`.
Database<S>: provides a wrapper around a database service implementation and a lookup service for persistence services for DBEntry objects.
DatabaseChangeListener: listens for committed changes through DBClassStore objects in a database and propagates the information to its listeners.
DBAccessController: used to control access on database resources in an `AbstractDatabase`.
DBClassStore<T extends DBEntry>: provides persistence service for a DBEntry class in the context of a Database.
DBConfigListener: listens to events that change the configuration of the database
DBEntry: represents a managable resource that can be persisted through database services and accessed by its ID, which is to remain unique even after serialization within other JVMs.
DBEnumeration<T extends DBEntry>: a special Enumeration that allows to release its resources even though a caller has not completely iterated through this instance.
DBReference: DBReference represents an Object that can hold a reference to a DBEntry object, providing sufficient means to retrieve that object from a Database.
DBStoreListener: listens for database updates and access through DBClassStore objects
DBTransaction: a transaction controlls access to all resources of a Database through DBClassStore instances.
DocumentEntry: specifies a general-purpose document that can be managed in a database
EntryClassMapper: this interface maps between DBEntry classes and some Object that allows its external storage and retrieval and custom labeling for classes
EntryRelationship: represents a relationship between two `DBEntry` instances.
IDFactory: provides a way for an application to centralize the creation of new IDs for DBEntry instances
LoginListener: listens to events associated with a UserLoginStore
MutableCategory<T>: an extension of a category that allows to set its parent category
PasswordPolicy: defines a policy for accepting passwords when changing them
ProcessedFilterOption<T extends DBEntry>: allows to control whether a processor is run before filtering when using a `WrappedDBClassStore`.
PropertyEntry: represents an entity that is specified by various properties that may flexibly change.
PropertyEntryFactory<T extends PropertyEntry>: a factory for generating PropertyEntry instances
ProtocolNote: a protocol note.
SortedGroupable<T extends Tag>: same as a Groupable, except this one also supports a stable order of groups, meaning the groups are prioritized.
SpecialRelationship<F extends DBEntry,T extends DBEntry,R>: a relationship definition specifying the classes that may be connected as well as the type of relation
Tag: represents a group that allows `Taggable` objects to be a member of.
Taggable<T extends Tag>: represents an object that can be a member of several groups
TransactionListener: listens for DBTransaction changes and can potentially intervene upon preparing for a commit.
TransactionRequired: This annotation suggests that implementations of these methods (or all methods of that type) should always be called only in a proper transactional context.
User: This interface defines the basic functionality for a user; setter methods are optional in the sense that they may generally throw an UnsupportedOperationException
UserLoginStore: defines the ability to manage a system that allows Users to log in/out

Class Summary
AbstractDatabase<S>: a base class for implementing a database.
AbstractDBClassStore<T extends DBEntry>: provides basic implementation of methods that can be implemented based on other methods of the interface - though these implementations may be very inefficient
AbstractDBEntry: implements common functionality, including immutable ID and hashCode/equals methods based on the ID (and class).
AbstractDBEnumeration<T extends DBEntry>: a base for making it easy to implement `DBEnumeration`.
AbstractDBTransaction: a simple base implementation for a DBTransaction.
AbstractUserLoginStore: a base for easily implementing a UserLoginStore.
ArchiveDBClassStore<T extends DBEntry>: allows to add an archive store to any given store, which enables to extend the data set.
BaseDocument: a base implementation for a DocumentEntry
Category.Adapter<T>
Category.Entry
CollectionClassStore<T extends DBEntry>: a transient DBClassStore implementation based on a simple collection of DBEntries.
DatabaseChangeListener.ClassListener: allows to easily register an ActionListener for changes on a particular DBEntry class
DatabaseChangeListener.LoggerListener: allows to simply log the events
DatabaseChangeMonitor: listens to database events and propagates committed changes in a database to its DatabaseChangeListeners to its listeners.
DatabaseTableModel: lists all available DBClassStore instances with their size.
DBAccessLoggerLevel: used as a level to log database access
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.
DBClassStoreCache.PrefetchedFilter<T>: a special interface supported by the enclosing class store that indicates that only pre-fetched (cached) instances should be returned from a fetch.
DBEntrySelection: implements a special Transferable for DBReference and/or DBEntry objects.
DBReferenceFilter: convenience class that allows to filter references by their reference class
DBSet<T extends DBEntry>
DBStoreListener.Adapter: provides convenient empty implementations for all methods
DBStoreListener.StoreUpdateAdapter: allows to simply register an ActionListener for changes of a specified type
DBStoreProfiler: allows to easily profile a store.
DBStoreProfiler.ProfileModel: the profile model is a read-only snapshot of the given profile.
DBTransactionStoreAdapter: convenience class to extend from when implementing something like a `DatabaseChangeMonitor`
DBUpdateEvent
DBUtils: provides convenience methods for dealing with database related issues
DBVersionedUpdateEvent: this special update event extends a standard event by including the actual entry state before and after the update.
DefaultDBReference: this class implements a simple DBReference object.
DefaultEntryRelationship: a default implementation for an EntryRelationship
DefaultSpecialRelationship<F extends DBEntry,T extends DBEntry,R>: provides a default implementation for SpecialRelationships.
DefaultUserLoginStore: a simple transient implementation of a UserLoginStore.
EntryAnalyzer<T extends DBEntry>: provides a convenient base and several methods to easily analyze aggregated DBEntry data; the underlying data can additionally be provided as a `DBClassStore`.
EntryClassMapper.Adapter: a default implementation (based on some other basic mapping like `EntryClassMapper.STRING_MAPPER`) which supports label customization per instance
EntryHeader<T extends DBEntry>: serves as a reference to a more complex DBEntry object while allowing for more content than a mere Stub.
EnumDBStore<T extends Enum<?> & DBEntry>: allows any Enum that also implements DBEntry to be made available via DBClassStore.
JPasswordChangeForm: provides a component that allows to easily display a dialog to change a password for a user.
JPasswordHash: little sample app to manually hash an MD5 from a String
JUserLoginPanel: a component to be used for user logins
Keyword: implements a Group/Tag solely based on a String that also represents the ID for the `DBEntry` it is.
LockEntry
LockInfo
LockManager: provides methods for persistent locks on DBEntry objects.
LoggerDBListener: provides convenient logging capabilities for Database objects
LoggerLoginListener: a simple LoginListener that writes all events into the given Logger.
LoggerTransactionListener
LoginListener.Adapter
MutableCategory.Adapter<T>
MutableCategory.Entry
PropertyEntryComparator<T extends PropertyEntry>: A special comparator that compares based on given property values of an PropertyEntry.
PropertyEntryFilter<T extends PropertyEntry>: filters on the properties of an entity based on simple equality of key/value pairs.
PropertyEntryImpl: This class represents a default PropertyEntry implementation that can serve as a base class for PropertyEntry implementations.
PropertyEntryTableModel<T extends PropertyEntry>: a TableModel that first uses the value of method names and then tries to retrieve properties based on the name as key.
ProtocolNoteEntry
ReadOnlyCacheStore<T extends DBEntry>: provides a transaction-independent, in-memory-cached, read-only wrapper around a given store.
ReadOnlyStore<T extends DBEntry>: a wrapper around a DBClassStore that disables altering the store's content
SecureUserImpl: provides an implementation that uses a secure way of storing hashed passwords using appropriate algorithms along with some randomly generated salt.
SessionIdGenerator: This class provides efficient unique String-based IDs for different clients.
SortedGroupable.Adapter<T extends Tag>
StoreUpdateTableModel<T extends DBEntry>: a special TableModel wrapper that supports store updates upon `StoreUpdateTableModel.setValueAt(Object, int, int)`
Stub<T extends DBEntry>: a Stub is a small object that can serve as a proxy for larger objects, so that you can maintain a lot of these in memory and only access the full object if needed.
Taggable.Adapter<T extends Tag>
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.
TransactionCounter: A TransactionCounter increments its counter upon transaction begin to allow determining whether it's still the same transaction.
TransactionListener.Adapter: provides convenient empty implementations for all methods
UserFilter: a simple user filter that conveniently allows to define acceptance based on rights
UserImpl: This class represents a default User implementation that can serve as the basis for more specific implementations.
UserTransactionListener: a special transaction listener that will set the current database user to the one specified by the user retriever on each transaction begin.
WrappedDBClassStore<T extends DBEntry>: a generic DBClassStore wrapper easing the implementation of special wrappers.

Enum Summary
DBClassStore.DBMethod
JUserLoginPanel.ImageLocation

Exception Summary
ConnectionException: ConnectionException signals access problems with the database.
DatabaseException: DatabaseException signals problems while accessing/using any form of database.
DBAccessDeniedWarning: thrown to indicate that access to a database was not allowed due to applicable restrictions
DBVetoException: thrown to indicate that a listener disagreed with an update of the database
IntegrityWarning
NotApplicableDataWarning: used to indicate a 'minor' problem with the data that is to be displayed as a warning rather than an exception
TransactionException: thrown to indicate that the caller doesn't hold the lock on an active DBTransaction while trying to access Resources of the associated Database.
WrongDataException: WrongDataException signals a consistency problem with the data submitted to the database.

## Package com.antelmann.db Description

This package contains generally useful classes for generic database management.

The framework in this package is entirely open to any kind of database system. if you are looking for specific support for relational databases, you may want to check out the com.antelmann.sql package. There are quite a few classes that implement interfaces of this package.

But as long as you stay within this package, all concepts are entirely independant of the underlying system, i.e. this framework can work on file databases, object-oriented databases, or any other type.

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