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.