Holger's Java API

## Uses of Interface
com.antelmann.db.DBClassStore

Packages that use DBClassStore
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.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.

Uses of DBClassStore in com.antelmann.crm

Classes in com.antelmann.crm that implement DBClassStore
`class` `FriendsEntryStore<T extends FriendsEntry<?>>`

Uses of DBClassStore in com.antelmann.db

Classes in com.antelmann.db that implement DBClassStore
`class` `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
`class` `ArchiveDBClassStore<T extends DBEntry>` allows to add an archive store to any given store, which enables to extend the data set.
`class` `CollectionClassStore<T extends DBEntry>` a transient DBClassStore implementation based on a simple collection of DBEntries.
`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` `EnumDBStore<T extends Enum<?> & DBEntry>` allows any Enum that also implements DBEntry to be made available via DBClassStore.
`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` `WrappedDBClassStore<T extends DBEntry>` a generic DBClassStore wrapper easing the implementation of special wrappers.

Fields in com.antelmann.db declared as DBClassStore
`protected DBClassStore<T>` `WrappedDBClassStore.store` access to the embedded original store; only the constructor should change this value

Methods in com.antelmann.db that return DBClassStore

`protected

`<T extends DBEntry> DBClassStore<T>`

`

`AbstractDatabase.getOriginalClassStore(Class<T> c)`
returns the original class store that was put in here directly (not the proxy/wrapper that ensures listeners are notified and transactional integrity is guaranteed)

`DBClassStore<?>` `DBUpdateEvent.getSource()` returns the store that updated the database.
`DBClassStore<LockEntry>` `LockManager.getStore()`
`DBClassStore<T>` `EntryAnalyzer.getStore()` may be null if this instance works off an iterable or another retriever

`

`<T extends DBEntry> DBClassStore<T>`

`

`Database.getStore(Class<T> c)`
allows to query for a persistence service for a given DBEntry class.

`

`<T extends DBEntry> DBClassStore<T>`

`

`AbstractDatabase.getStore(Class<T> c)`
returns a monitored Proxy of the previously added DBClassStore for c or null

`

`<T extends DBEntry> DBClassStore<T>`

`

`AbstractDatabase.getStoreForEntry(T entry)`
provides a save cast to obtain the relevant DBClassStore

`

`<T extends DBEntry> DBClassStore<T>`

`

`AbstractDatabase.putClassStore(Class<T> c, DBClassStore<T> dbcs)`
puts the given dbcs into this database, which is then available in a wrapped Proxy when accessing the class store via interface method `getClassStore(Class)`.

`

`<T extends DBEntry> DBClassStore<T>`

`

`AbstractDatabase.remove(Class<T> c)`

`static DBClassStore<DBEntry>` `DBUtils.unsaveStore(DBClassStore<?> store)`
`DBClassStore<T>` `WrappedDBClassStore.unwrap()`
`DBClassStore<T>` `ReadOnlyCacheStore.unwrap()`
`DBClassStore<LockEntry>` `LockManager.unwrap()`

Methods in com.antelmann.db that return types with arguments of type DBClassStore
`Collection<DBClassStore<?>>` `CategoryManager.getCategoryUserStores()`

Methods in com.antelmann.db with parameters of type DBClassStore
`void` `DBAccessController.checkAccess(DBClassStore<?> store, DBClassStore.DBMethod method, Object parameter)` controls access to the database via the `DBClassStore` interface; information on the state of the database (like its current user) can be accessed through the given DBClassStore.

`static

`<T extends DBEntry> T`

`

`DBUtils.commitEntry(DBClassStore<T> store, T entry)`
the store is used to update/insert the entry and the transaction is committed.

`void` `LoggerDBListener.databaseAccessed(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter, long timeTaken)`
`void` `DBTransactionStoreAdapter.databaseAccessed(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter, long timeTaken)`
`void` `DBStoreProfiler.databaseAccessed(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter, long timeTaken)`
`void` `DBStoreListener.databaseAccessed(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter, long timeTaken)` called upon successfully reading from the database (guaranteed to be called from within the transaction).
`void` `DBStoreListener.Adapter.databaseAccessed(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter, long timeTaken)`
`void` `DatabaseTableModel.databaseAccessed(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter, long timeTaken)`
`void` `LoggerDBListener.databaseError(DBClassStore<?> dbstore, Throwable t, DBClassStore.DBMethod method, Object parameter)`
`void` `DBTransactionStoreAdapter.databaseError(DBClassStore<?> dbstore, Throwable t, DBClassStore.DBMethod method, Object parameter)`
`void` `DBStoreProfiler.databaseError(DBClassStore<?> dbstore, Throwable t, DBClassStore.DBMethod method, Object parameter)`
`void` `DBStoreListener.databaseError(DBClassStore<?> dbstore, Throwable t, DBClassStore.DBMethod method, Object parameter)` called when an error occurred while accessing the database (not guaranteed to be called from within the transaction)
`void` `DBStoreListener.Adapter.databaseError(DBClassStore<?> dbstore, Throwable t, DBClassStore.DBMethod method, Object parameter)`
`void` `DatabaseTableModel.databaseError(DBClassStore<?> dbstore, Throwable t, DBClassStore.DBMethod method, Object parameter)`

`static

`<T extends DBEntry> int`

`

`DBUtils.delete(DBClassStore<T> store, Iterable<T> entries)`
deletes the given entries from the database

`static

`<T extends DBEntry> int`

`

`DBUtils.deleteIndividually(DBClassStore<T> store, Filter<? super T> filter)`
deletes all entries that pass the given filter individually

`void` `Stub.ensureReferenceString(DBClassStore<T> store)`

`static

`<E extends DBEntry,I> I`

`

`AbstractDatabase.extractInterface(DBClassStore<E> store, Class<I> desiredInterface)`
allows to extract an interface from a store only if it is 'exposed'

`void` `LoggerDBListener.fetchCall(DBClassStore<?> dbstore, DBEnumeration<?> e, String method, long timeTaken)`
`void` `DBTransactionStoreAdapter.fetchCall(DBClassStore<?> dbstore, DBEnumeration<?> e, String method, long timeTaken)`
`void` `DBStoreProfiler.fetchCall(DBClassStore<?> store, DBEnumeration<?> e, String method, long timeTaken)`
`void` `DBStoreListener.fetchCall(DBClassStore<?> dbstore, DBEnumeration<?> e, String method, long timeTaken)` called when a method is called on a DBEnumeration that is returned by the store
`void` `DBStoreListener.Adapter.fetchCall(DBClassStore<?> store, DBEnumeration<?> e, String method, long timeTaken)`
`void` `DatabaseTableModel.fetchCall(DBClassStore<?> store, DBEnumeration<?> e, String method, long timeTaken)`

`static

`<T extends DBEntry> T`

`

`DBUtils.getFirstEntry(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> Stub<T>`

`

`DBUtils.getFirstStub(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`T` `Stub.getOriginalInstance(DBClassStore<T> store)` retrieves and returns the original object for this stub

`static

`<T extends DBEntry> T`

`

`DBUtils.getRandomEntry(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> Stub<T>`

`

`DBUtils.getRandomStub(DBClassStore<T> store)`

`static

`<T extends DBEntry> void`

`

`DBUtils.handle(DBClassStore<T> store, Handler<? super T,?> handler, Filter<? super T> filter, Monitor monitor, boolean useCommitNotAbort)`

`static

`<T extends DBEntry> T`

`

`DBUtils.insertEntry(DBClassStore<T> store, T entry)`
the store is used to insert the entry and the transaction is committed.

`static

`<T extends DBEntry> Iterable<T>`

`

`DBUtils.iterate(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> ArrayList<T>`

`

`DBUtils.listEntries(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> ArrayList<T>`

`

`DBUtils.listEntries(DBClassStore<T> store, Filter<? super T> filter, int maxEntries)`

`static

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`DBUtils.listStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`static

`<T extends DBEntry> ArrayList<Stub<T>>`

`

`DBUtils.listStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter, int maxEntries)`

`static

`<T extends DBEntry> Hashtable<Object,T>`

`

`DBUtils.mapEntries(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry,P> Hashtable<Object,P>`

`

`DBUtils.mapEntries(DBClassStore<T> store, PatternExtractor<? super T,P> pe, Filter<? super T> filter)`

`static

`<T extends DBEntry> Hashtable<Object,Stub<T>>`

`

`DBUtils.mapStubs(DBClassStore<T> store, Filter<? super Stub<?>> filter)`

`void` `LoggerDBListener.prepareDatabaseCall(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter)`
`void` `DBTransactionStoreAdapter.prepareDatabaseCall(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter)`
`void` `DBStoreProfiler.prepareDatabaseCall(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter)`
`void` `DBStoreListener.prepareDatabaseCall(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter)` called before the given method is delegated to the embedded store
`void` `DBStoreListener.Adapter.prepareDatabaseCall(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter)`
`void` `DatabaseTableModel.prepareDatabaseCall(DBClassStore<?> dbstore, DBClassStore.DBMethod method, Object parameter)`
`protected void` `DBStoreProfiler.profileCall(long timeTaken, DBClassStore<?> store, String method, Object parameter)`

`

`<T extends DBEntry> DBClassStore<T>`

`

`AbstractDatabase.putClassStore(Class<T> c, DBClassStore<T> dbcs)`
puts the given dbcs into this database, which is then available in a wrapped Proxy when accessing the class store via interface method `getClassStore(Class)`.

`

`<S extends DBEntry> PatternExtractor<Object,Filter<S>>`

`

`CategoryManager.registerCategoryUse(DBClassStore<S> store, PatternExtractor<Object,Filter<S>> filterCreator)`

`void` `Stub.reloadDisplayValue(DBClassStore<T> store)`
`Stub<T>` `Stub.reloadInstance(DBClassStore<T> store)`
`void` `EntryAnalyzer.setData(DBClassStore<T> store)`
`void` `EntryAnalyzer.setData(DBClassStore<T> store, Filter<? super T> filter)`

`static

`<T extends DBEntry> void`

`

`DBUtils.store(DBClassStore<T> store, Collection<T> entries)`
inserts/updates the given entries in the database depending on whether it already exists

`static

`<T extends DBEntry> void`

`

`DBUtils.store(DBClassStore<T> store, Iterator<T> entries)`
inserts/updates the given entries in the database depending on whether it already exists

`static

`<T extends DBEntry> void`

`

`DBUtils.store(DBClassStore<T> store, T entry)`
inserts/updates the given entry into the database depending on whether it already exists

`static DBClassStore<DBEntry>` `DBUtils.unsaveStore(DBClassStore<?> store)`

`static

`<T extends DBEntry,E extends Exception> void`

`

`DBUtils.updateAll(DBClassStore<T> store, Processor<T,E> handler, Filter<? super T> filter)`

`static

`<T extends DBEntry,E extends Exception> void`

`

`DBUtils.updateAll(DBClassStore<T> store, Processor<T,E> handler, Filter<? super T> filter, Monitor mon)`

`static

`<T extends DBEntry> T`

`

`DBUtils.updateEntry(DBClassStore<T> store, T entry)`
the store is used to update the entry and the transaction is committed.

Constructors in com.antelmann.db with parameters of type DBClassStore
`ArchiveDBClassStore(DBClassStore<T> store, DBClassStore<T> archive, boolean enableArchive)`
`ArchiveDBClassStore(DBClassStore<T> store, DBClassStore<T> archive, boolean enableArchive)`
`DatabaseException(DBClassStore<?> store, Throwable cause)`
`DBClassStoreCache(DBClassStore<T> store)`
`DBSet(DBClassStore<T> store)`
`DBUpdateEvent(DBClassStore<?> source, DBClassStore.DBMethod type, Object parameter, long time, Object returnValue)`
`DBUpdateEvent(DBClassStore<?> source, DBClassStore.DBMethod type, Object parameter, long time, Object option, Object returnValue)`
`DBUpdateEvent(DBClassStore<?> source, DBClassStore.DBMethod type, Object parameter, Object returnValue)`
`DefaultDBReference(DBClassStore<?> store, Object referenceID)`
`EntryAnalyzer(DBClassStore<T> store)`
`EntryAnalyzer(DBClassStore<T> store, Filter<? super T> filter)`
`LockManager(DBClassStore<LockEntry> store)`
`ReadOnlyCacheStore(DBClassStore<T> store)`
`ReadOnlyCacheStore(DBClassStore<T> store, Filter<? super T> filter)`
`ReadOnlyStore(DBClassStore<T> store)` calls this(store, false)
`ReadOnlyStore(DBClassStore<T> store, boolean allowGenerateNewID)` if allowGenerateNewID is true, the method `ReadOnlyStore.generateNewID()` will delegate to the embedded store
`StoreUpdateTableModel(ObjectTableModel<T> model, DBClassStore<T> store)`
`WrappedDBClassStore(DBClassStore<T> store)`

Uses of DBClassStore in com.antelmann.genealogy.db

Classes in com.antelmann.genealogy.db that implement DBClassStore
`class` `GPersonRelationStore`
`class` `GPersonStore`

Methods in com.antelmann.genealogy.db that return DBClassStore
`static DBClassStore<GPerson.Header>` `GPersonStore.createHeaderStore(Database<Connection> db)`

Uses of DBClassStore in com.antelmann.image

Classes in com.antelmann.image that implement DBClassStore
`class` `ImageURLEntrySQLStore<T extends ImageURLEntry>` an implementation of a DBClassStore to be used with ImageURLEntry objects.

Uses of DBClassStore in com.antelmann.io

Classes in com.antelmann.io that implement DBClassStore
`class` `FileClassStore<T extends DBEntry>` a simple store that stores entries as serialized objects into a file in a directory, which may be suitable for few very large instances of a class.

Constructors in com.antelmann.io with parameters of type DBClassStore
`BinaryData(DBClassStore<?> store, Object keyValue, String dataColumn)`

Uses of DBClassStore in com.antelmann.math

Methods in com.antelmann.math with parameters of type DBClassStore

`static

`<T extends DBEntry> void`

`

`DataMatrix.loadMatrix(DataMatrix<T> matrix, DBClassStore<? extends T> store, Filter<? super T> filter, Monitor mon)`
min, max of the given logger must be set explicitly

Uses of DBClassStore in com.antelmann.net.mail

Methods in com.antelmann.net.mail with parameters of type DBClassStore
`static void` `IMAPBackup.backupToDB(javax.mail.Store imapStore, DBClassStore<MessageEntry> dbstore, Filter<javax.mail.Message> filter, File logFile)`

Uses of DBClassStore in com.antelmann.sql

Classes in com.antelmann.sql that implement DBClassStore
`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` `DBDocumentStore<T extends DBDocument>`
`class` `DetailRowStore<T extends PropertyEntry>` Deprecated. use `PropertyEntryTableStore` instead
`class` `GenericPropertyEntryStore<T extends PropertyEntry>` automatically maps a PropertyEntry class to a database, where some default assumptions have to be met.
`class` `JDBCRowStore<T extends DBEntry>` provides JDBC persistence for Objects that have a corresponding ObjectRowMapper.
`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` `RelationshipStore<T extends DefaultEntryRelationship>` provides an SQL-based store for relationships.
`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` `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

Methods in com.antelmann.sql that return DBClassStore
`DBClassStore<RowItem>` `SQLDatabase.generateGenericClassStore(String table, String idColumn)` generates and returns a generic wrapped DBClassStore on RowItem objects; the store is not put into the database.

Methods in com.antelmann.sql that return types with arguments of type DBClassStore
`Collection<DBClassStore<?>>` `CategoryStore.getCategoryUserStores()`

Methods in com.antelmann.sql with parameters of type DBClassStore
`boolean` `SQLEntryClassMapper.addStore(DBClassStore<?> store)`
`SQLMapFilter<T>` `TopicMapFilter.convertTopicFilter(DBClassStore<?> store)`

`static

`<T extends DBDocument> T`

`

`DBDocument.createDocument(Object id, DBClassStore<T> store, boolean preloadContentStream)`
provides a standard way to create instances of a subclass of DBDocument

`static SubSelectCondition` `SubSelectCondition.createDuplicateConstraint(DBClassStore<?> store, String... columns)` creates a constraint to be used with an `SQLMapFilter` that limits the result to entries where values in the given columns exist more than once.
`static SubSelectCondition` `SubSelectCondition.createGroupConstraint(DBClassStore<?> store, String... groups)`

`

`<E extends DBEntry> PreparedStatementEntryFilter<T>`

`

`SQLComboFilter.createPreparedStatementEntryFilter(DBClassStore<E> store)`
Deprecated. cannot extract the mapper this way, so this is discouraged

`static SubSelectCondition` `SubSelectCondition.createPropertyConstraint(DBClassStore<?> store, String key, String... values)` creates a constraint that can be used with an `SQLMapFilter` that limits the result to entries that have the given key with any of the given values.

`static

`<T extends DBEntry> PatternExtractor<Object,Filter<T>>`

`

`CategoryStore.createStandardExtractor(DBClassStore<T> store)`

`SubSelectCondition` `SQLComboFilter.createSubSelectCondition(DBClassStore<?> store)`

`static

`<T extends DefaultEntryRelationship> ArrayList<T>`

`

`RelationshipStore.findBrokenRelationships(DBClassStore<T> store, boolean breakOnFirstEncounter)`

`static

`<T extends DefaultEntryRelationship> void`

`

`RelationshipStore.findBrokenRelationships(DBClassStore<T> store, Collection<T> set, Monitor monitor, boolean breakOnFirstEncounter)`
looks for broken relationships in the database and puts them into the given collection.

`static

`<T extends DefaultEntryRelationship> ArrayList<T>`

`

`RelationshipStore.findBrokenRelationships(DBClassStore<T> store, Monitor monitor, boolean breakOnFirstEncounter)`

`

`<S extends DBEntry> PatternExtractor<Object,Filter<S>>`

`

`CategoryStore.registerCategoryUse(DBClassStore<S> store, PatternExtractor<Object,Filter<S>> filterCreator)`

`static

`<T extends DBEntry> void`

`

`CategoryStore.registerCategoryUser(DBClassStore<T> store, String categoryIdColumn, Class<? extends Category<?>> categoryClass)`

Constructors in com.antelmann.sql with parameters of type DBClassStore
`CategoryStore(DBClassStore<T> store, String parentCategoryIDColumn)`
`DBDocument(Object id, DBClassStore<DBDocument> store)`
`DBDocument(Object id, DBClassStore<DBDocument> store, boolean preloadContentStream)`
`DefaultMappingInfo(DBClassStore<?> store)`
`GenericPropertyEntryMapper(DBClassStore<?> refStore, Class<T> type)`
`GenericPropertyEntryMapper(DBClassStore<?> refStore, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)`
`GenericPropertyEntryStore(DBClassStore<?> refStore, Class<T> type)` takes table, id column, display column names and table query (if applicable) from the given reference store; additionally, new ids are generated through the given store
`GenericPropertyEntryStore(DBClassStore<?> refStore, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)` takes table, id column, display column names and table query (if applicable) from the given reference store.
`PropertyEntryHeaderStore(DBClassStore<T> store, Class<E> propertyEntryType)`
`PropertyEntryHeaderStore(DBClassStore<T> headerStore, DBClassStore<E> propertyEntryStore)`
`PropertyEntryHeaderStore(DBClassStore<T> headerStore, DBClassStore<E> propertyEntryStore)`
`PropertyEntryHeaderStore(DBClassStore<T> headerStore, PropertyEntryMapping pm, MappingInfo propertyEntryMappingInfo)`
`PropertyEntryTableStore(DBClassStore<T> store, MappingInfo mi)` allows to obtain the relevant information from a given mapping
`PropertyEntryTableStore(DBClassStore<T> store, String detailTable, String detailIdColumn, String detailKeyColumn, String detailValueColumn)` the String parameters correspond to the `PropertyEntryMapping.DetailKey` values
`SortedGroupableSQLStore(DBClassStore<T> store, String groupTable, String idColumn, String groupColumn, String indexColumn, Class<G> groupType)`
`SQLColumnInfoStore(DBClassStore<T> store)`
`TaggableHeaderStore(DBClassStore<T> store, Class<E> groupableType)`
`TaggableHeaderStore(DBClassStore<T> headerStore, DBClassStore<E> groupableStore)`
`TaggableHeaderStore(DBClassStore<T> headerStore, DBClassStore<E> groupableStore)`
`TaggableHeaderStore(DBClassStore<T> headerStore, TaggableMapping gm, MappingInfo groupableMappingInfo)`
`TaggableSQLStore(DBClassStore<T> store, String groupTable, String idColumn, String groupColumn, Class<G> groupType)`
`UnionSqlStore(Class<T> type, Collection<Object> topics, DBClassStore<?>... stores)`
`UnionSqlStore(Class<T> type, DBClassStore<?>... stores)`
`WrappedDBClassStoreMapping(DBClassStore<T> store)` the given store must directly support or wrap the MappingInfo interface
`WrappedDBClassStoreMapping(DBClassStore<T> store, MappingInfo mi)`

Uses of DBClassStore in com.antelmann.util

Classes in com.antelmann.util that implement DBClassStore
`static class` `Country.Store` provides a convenient read-only store for all existing Country objects without having to hold them all in memory constantly

Methods in com.antelmann.util that return DBClassStore
`static DBClassStore<Country>` `Country.makeStore(Database<?> db, boolean readOnly)` returns a collection store containing all countries that is yet to be put into the database

Uses of DBClassStore in com.antelmann.util.gui

Fields in com.antelmann.util.gui declared as DBClassStore
`protected DBClassStore<T>` `JPropertyEntryForm.store`

Methods in com.antelmann.util.gui with parameters of type DBClassStore
`static void` `FormHelper.limitSize(JTextComponent c, DBClassStore<?> store, String column)`
`void` `JPropertyEditor.setClassStore(DBClassStore<?> store)` if set to a a non-null value, the given store is queried for mapping information allowing to pre-initialize possible key/value selections

Constructors in com.antelmann.util.gui with parameters of type DBClassStore
`JCategoryField(DBClassStore<?> store)` convenience constructor assuming that the given store implements `CategoryManager` and is based on a category using the `Database` as context
`JPropertyEntryForm(T entry, DBClassStore<T> store, String... propertyKeys)`
`JPropertyEntryForm(T entry, ValueSetter<T> setter, DBClassStore<T> store, boolean initComponent, String... propertyKeys)`
`JPropertyEntryForm(T entry, ValueSetter<T> setter, DBClassStore<T> store, int padding, int maxRows, boolean initComponent, String... propertyKeys)`
`JPropertyEntryForm(T entry, ValueSetter<T> setter, DBClassStore<T> store, int padding, int maxRows, String... propertyKeys)`
`JPropertyEntryForm(T entry, ValueSetter<T> setter, DBClassStore<T> store, String... propertyKeys)`
`JTagsField(String title, DBClassStore<T> store)`
`JTagsField(String title, DBClassStore<T> store, T entry)`

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