Holger's Java API

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

Packages that use DBEntry
com.antelmann.calendar: This package contains classes for implementing calendar and time related solutions.
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.db.remote: This package contains classes that add remote capacities to the database concept of the super package.
com.antelmann.genealogy: This package contains classes that provide classes to implement applications dealing with genealogy related issues.
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.opengeodb: This package contains classes easing to deal with geological data as provided by http://opengeodb.org/.
com.antelmann.servlet: This package contains classes to help with the implementation of servlets.
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.revision: This package contains classes useful for implementing systems that deal with revisions.
com.antelmann.webdav: provides higher level access for WebDAV, CalDAV and CardDAV clients.

Uses of DBEntry in com.antelmann.calendar

Classes in com.antelmann.calendar that implement DBEntry
`class` `CalendarEntry` represents a generic entry in a calendar

Uses of DBEntry in com.antelmann.crm

Classes in com.antelmann.crm with type parameters of type DBEntry
`class` `AddressableMapper<T extends Addressable & DBEntry>` handles the address of a given addressable entry
`class` `FriendsEntry<T extends DBEntry>`
`interface` `Role<T extends DBEntry>` a role is an instance that can extends its base to 'play' that role for its base in appropriate contexts.

Subinterfaces of DBEntry in com.antelmann.crm
`interface` `Contact` represents a contact that is also the base to have several different roles
`interface` `Person` represents the role of a person
`interface` `Role<T extends DBEntry>` a role is an instance that can extends its base to 'play' that role for its base in appropriate contexts.

Classes in com.antelmann.crm that implement DBEntry
`class` `ContactImpl<T extends Keyword>` a base implementation for a Contact
`class` `FriendsEntry<T extends DBEntry>`
`class` `PersonImpl<T extends Keyword>` a basic implementation for a Person
`class` `PropertyEntryWithAddress` implements a PropertyEntry that stores a `GlobalAddress` through its properties; this class can also serve as a configuration helper for a mapper that embeds storing a GlobalAddress.

Constructor parameters in com.antelmann.crm with type arguments of type DBEntry
`FriendsEntryStore(Database<Connection> db, String table, String idColumn, String fromColumn, String toColumn, String commentColumn, IDFactory idFactory, Class<T> type, Class<? extends DBEntry> entriesWhoAreFriendsClass)`

Uses of DBEntry in com.antelmann.db

Classes in com.antelmann.db with type parameters of type DBEntry
`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` `AbstractDBEnumeration<T extends DBEntry>` a base for making it easy to implement `DBEnumeration`.
`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.
`interface` `DBClassStore<T extends DBEntry>` provides persistence service for a DBEntry class in the context of a Database.
`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.
`interface` `DBEnumeration<T extends DBEntry>` a special Enumeration that allows to release its resources even though a caller has not completely iterated through this instance.
`class` `DBSet<T extends DBEntry>`
`class` `DefaultSpecialRelationship<F extends DBEntry,T extends DBEntry,R>` provides a default implementation for SpecialRelationships.
`class` `DefaultSpecialRelationship<F extends DBEntry,T extends DBEntry,R>` provides a default implementation for SpecialRelationships.
`class` `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`.
`class` `EntryHeader<T extends DBEntry>` serves as a reference to a more complex DBEntry object while allowing for more content than a mere Stub.
`class` `EnumDBStore<T extends Enum<?> & DBEntry>` allows any Enum that also implements DBEntry to be made available via DBClassStore.
`interface` `ProcessedFilterOption<T extends DBEntry>` allows to control whether a processor is run before filtering when using a `WrappedDBClassStore`.
`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
`interface` `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
`interface` `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
`class` `StoreUpdateTableModel<T extends DBEntry>` a special TableModel wrapper that supports store updates upon `StoreUpdateTableModel.setValueAt(Object, int, int)`
`class` `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.
`class` `WrappedDBClassStore<T extends DBEntry>` a generic DBClassStore wrapper easing the implementation of special wrappers.

Subinterfaces of DBEntry in com.antelmann.db
`interface` `DocumentEntry` specifies a general-purpose document that can be managed in a database
`interface` `EntryRelationship` represents a relationship between two `DBEntry` instances.
`interface` `PropertyEntry` represents an entity that is specified by various properties that may flexibly change.
`interface` `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
`interface` `User` This interface defines the basic functionality for a user; setter methods are optional in the sense that they may generally throw an UnsupportedOperationException

Classes in com.antelmann.db that implement DBEntry
`class` `AbstractDBEntry` implements common functionality, including immutable ID and hashCode/equals methods based on the ID (and class).
`class` `BaseDocument` a base implementation for a DocumentEntry
`static class` `Category.Entry`
`class` `DefaultEntryRelationship` a default implementation for an EntryRelationship
`class` `DefaultSpecialRelationship<F extends DBEntry,T extends DBEntry,R>` provides a default implementation for SpecialRelationships.
`class` `EntryHeader<T extends DBEntry>` serves as a reference to a more complex DBEntry object while allowing for more content than a mere Stub.
`class` `Keyword` implements a Group/Tag solely based on a String that also represents the ID for the `DBEntry` it is.
`class` `LockEntry`
`static class` `MutableCategory.Entry`
`class` `PropertyEntryImpl` This class represents a default PropertyEntry implementation that can serve as a base class for PropertyEntry implementations.
`class` `ProtocolNoteEntry`
`class` `SecureUserImpl` provides an implementation that uses a secure way of storing hashed passwords using appropriate algorithms along with some randomly generated salt.
`class` `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.
`class` `UserImpl` This class represents a default User implementation that can serve as the basis for more specific implementations.

Methods in com.antelmann.db with type parameters of type DBEntry

`static

`<T extends DBEntry,X extends T,Y extends T> DBEnumeration<T>`

`

`AbstractDBEnumeration.add(DBEnumeration<X> e1, DBEnumeration<Y> e2)`

`static

`<T extends DBEntry> Stub<T>`

`

`Stub.asStub(T entry)`

`static

`<T extends DBEntry> Stub<T>`

`

`Stub.castStub(Stub<?> stub, Class<T> t)`

`static

`<T extends DBEntry> T`

`

`DBUtils.commitEntry(Database<?> db, T entry)`
commits the given entry to the database and returns the given entry

`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.

`

`<T extends DBEntry> boolean`

`

`AbstractDatabase.contains(T entry)`

`

`<T extends DBEntry> int`

`

`AbstractDatabase.count(Class<T> c, Filter<? super T> filter)`

`

`<T extends DBEntry> int`

`

`AbstractDatabase.countStubs(Class<T> c, Filter<Stub<?>> filter)`

`static

`<T extends DBEntry> int`

`

`DBUtils.delete(Database<?> db, Iterable<? extends DBReference> list)`
deletes the given entries from the database

`static

`<T extends DBEntry> int`

`

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

`

`<T extends DBEntry> boolean`

`

`AbstractDatabase.delete(T entry)`

`static

`<T extends DBEntry> int`

`

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

`static

`<T extends DBEntry> DBEnumeration<T>`

`

`AbstractDBEnumeration.emptyDBEnumeration()`

`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'

`static

`<E extends DBEntry> AbstractDBEnumeration<E>`

`

`AbstractDBEnumeration.filter(DBEnumeration<E> i, Filter<? super E> filter)`
remove() is not supported on the returned iterator

`

`<S extends DBEntry> Filter<S>`

`

`CategoryManager.getCategoryUsageFilterFor(Class<S> type, Object categoryId)`

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getEntry(Class<T> c, Object id)`
a shortcut w/o having to go through the DBClassStore

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getEntry(Stub<T> stub)`
This method will begin and abort a transaction if none is active at the time.

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getFirstEntry(Class<T> type, Filter<? super T> filter)`

`static

`<T extends DBEntry> T`

`

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

`

`<T extends DBEntry> Stub<T>`

`

`AbstractDatabase.getFirstStub(Class<T> type, Filter<Stub<?>> filter)`

`static

`<T extends DBEntry> Stub<T>`

`

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

`static

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

`

`DBUtils.getIDExtractor()`

`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)

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getRandomEntry(Class<T> type)`

`

`<T extends DBEntry> T`

`

`AbstractDatabase.getRandomEntry(Class<T> type, Filter<? super T> filter)`

`static

`<T extends DBEntry> T`

`

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

`

`<T extends DBEntry> Stub<T>`

`

`AbstractDatabase.getRandomStub(Class<T> type)`

`static

`<T extends DBEntry> Stub<T>`

`

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

`

`<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> Stub<T>`

`

`AbstractDatabase.getStub(Class<T> c, Object id)`
a shortcut w/o having to go through the DBClassStore

`static

`<T extends DBEntry> PatternExtractor<T,Stub<T>>`

`

`Stub.getStubExtractor()`

`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.

`

`<E extends DBEntry> boolean`

`

`AbstractDatabase.isVersioningEnabled(Class<E> type, boolean flag)`

`static

`<T extends DBEntry> Iterable<T>`

`

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

`

`<T extends DBEntry> ArrayList<T>`

`

`AbstractDatabase.listEntries(Class<T> c, Filter<? super T> filter)`
This method will begin and abort a transaction if none is active at the time.

`

`<T extends DBEntry> ArrayList<T>`

`

`AbstractDatabase.listEntries(Class<T> type, Filter<? super T> filter, int maxEntries)`

`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)`

`

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

`

`AbstractDatabase.listStubs(Class<T> c, Filter<? super Stub<?>> filter)`
This method will begin and abort a transaction if none is active at the time.

`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> Stub<T>`

`

`Stub.makeStub(DBReference ref, Class<T> type)`
combines `Stub.makeStub(DBReference)` and `Stub.castStub(Stub, Class)`

`static

`<T extends DBEntry> Stub<T>`

`

`Stub.makeStub(Object id, Object displayValue, Class<T> type)`

`

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

`

`AbstractDatabase.mapEntries(Class<T> c, Filter<? super T> filter)`
returns a Hashtable mapping the ID to its DBEntry of those that apply to the given filter.

`static

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

`

`DBUtils.mapEntries(Collection<T> entries, Filter<? super T> filter)`

`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)`

`

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

`

`AbstractDatabase.mapStubs(Class<T> c, Filter<? super Stub<?>> filter)`
returns a Hashtable mapping the ID to its Stub of those that apply to the given filter.

`static

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

`

`DBUtils.mapStubs(Collection<Stub<T>> stubs, Filter<? super Stub<T>> filter)`

`static

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

`

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

`static

`<E extends DBEntry> DBEnumeration<E>`

`

`AbstractDBEnumeration.monitor(DBEnumeration<E> i, Monitor monitor)`
increments the monitor upon calling next()

`static

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

`

`AbstractDBEnumeration.processDB(DBEnumeration<T> e, Processor<T,E> p)`

`

`<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)`.

`

`<E extends DBEntry,I> I`

`

`Database.queryStoreForInterface(Class<E> type, Class<I> desiredInterface)`
allows to query an embedded DBClassStore for additional functionality exposed via the given desired interface.

`

`<E extends DBEntry,I> I`

`

`AbstractDatabase.queryStoreForInterface(Class<E> type, Class<I> desiredInterface)`
supports `WrappedDBClassStore` instances for querying the interface from embedded stores

`

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

`

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

`

`<T extends DBEntry> DBClassStore<T>`

`

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

`

`<E extends DBEntry> void`

`

`Database.setVersioningEnabled(Class<E> type, boolean flag)`
Enabling versioning on a class store results on additional overhead for insert, update and delete operations, as for each update and delete operation the store first retrieves the existing instance from the database before storing the new version.

`

`<E extends DBEntry> void`

`

`AbstractDatabase.setVersioningEnabled(Class<E> type, boolean flag)`

`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

`

`<T extends DBEntry> void`

`

`AbstractDatabase.store(T... entries)`
inserts/updates the given entries in the database depending on whether it already exists

`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.

`static

`<T extends DBEntry> Stub<T>`

`

`Stub.verify(Stub<?> stub, Class<T> type)`
verifies that the given stub is indeed of the given type

`static

`<T extends DBEntry> DBEnumeration<T>`

`

`AbstractDBEnumeration.wrap(Enumeration<T> e)`

`static

`<T extends DBEntry> DBEnumeration<T>`

`

`AbstractDBEnumeration.wrap(Iterator<T> i)`

Methods in com.antelmann.db that return DBEntry
`DBEntry` `DefaultDBReference.dereference(Database<?> db)`
`static DBEntry` `DBUtils.get(Database<?> db, DBReference ref)` determines whether there is a relevant store that contains the relevant id for the given reference in the given database.
`DBEntry` `AbstractDatabase.getEntry(DBReference ref)` This method will begin and abort a transaction if none is active at the time.
`DBEntry` `DBVersionedUpdateEvent.getNewVersion()` in case of `DBClassStore.DBMethod.DELETE` or `DBClassStore.DBMethod.DELETE_MULTIPLE`, the return value is always null.
`DBEntry` `DBVersionedUpdateEvent.getOldVersion()` in case of `DBClassStore.DBMethod.INSERT`, `DBClassStore.DBMethod.INSERT_AS_NEW` or `DBClassStore.DBMethod.DELETE_MULTIPLE`, the return value is always null.
`static DBEntry` `DBEntrySelection.resolve(DBReference ref, Database<?> db)`

Methods in com.antelmann.db that return types with arguments of type DBEntry
`static ArrayList<DBEntry>` `DBEntrySelection.extractEntries(Transferable t, Database<?> db)`
`static Set<Class<? extends DBEntry>>` `DBUtils.findStoresWithID(Database<?> db, Object id)`
`Collection<Class<? extends DBEntry>>` `Database.getAvailableClassStores()` returns an unmodifiable view of the existing classes that map to a DBClassStore in this database
`Set<Class<? extends DBEntry>>` `AbstractDatabase.getAvailableClassStores()`
`Class<? extends DBEntry>` `Stub.getReferenceClass()`
`Class<? extends DBEntry>` `DefaultDBReference.getReferenceClass()`
`Class<? extends DBEntry>` `DBReference.getReferenceClass()` indicates the type of DBEntry that represents the class of the reference ID, so that the instance could be looked up in a Database; this may be null only if the reference itself is null, too.
`Stub<? extends DBEntry>` `AbstractDatabase.getStub(DBReference ref)` This method will begin and abort a transaction if none is active at the time.
`Class<? extends DBEntry>` `EntryClassMapper.objectToEntryClass(Object entryClassRepresentation)` converts the given (maybe externally retrieved) Object into some DBEntry class to be used
`Class<? extends DBEntry>` `EntryClassMapper.Adapter.objectToEntryClass(Object referenceType)`
`static Converter<Class<? extends DBEntry>,Object>` `EntryClassMapper.Adapter.toConverter(EntryClassMapper ecm)`
`static DBClassStore<DBEntry>` `DBUtils.unsaveStore(DBClassStore<?> store)`

Methods in com.antelmann.db with parameters of type DBEntry
`protected String` `DBEntrySelection.extractStringFlavor(DBEntry entry)` allows to customize the String used for the `DataFlavor.stringFlavor`; here, `Object.toString()` is used - unless `DetailedString` is implemented
`static DefaultDBReference` `DefaultDBReference.fromEntry(DBEntry entry)`
`static int` `AbstractDBEntry.hashEntry(DBEntry entry)`
`static boolean` `DBUtils.referenceRefersToEntry(DBReference ref, DBEntry entry)`
`boolean` `Stub.refersTo(DBEntry entry)`
`boolean` `DefaultDBReference.refersTo(DBEntry entry)`
`static boolean` `DefaultDBReference.refersTo(DBReference ref, DBEntry entry)`
`static void` `DBUtils.store(Database<?> db, DBEntry... entries)`

`

`<T extends DBEntry> void`

`

`AbstractDatabase.store(T... entries)`
inserts/updates the given entries in the database depending on whether it already exists

Method parameters in com.antelmann.db with type arguments of type DBEntry
`static void` `DBUtils.commitEntries(Database<?> db, Iterator<? extends DBEntry> it)`
`Object` `EntryClassMapper.entryClassToObject(Class<? extends DBEntry> entryClass)` converts the given Class into an object that can easily be stored/exported elsewhere.
`Object` `EntryClassMapper.Adapter.entryClassToObject(Class<? extends DBEntry> resourceClass)`
`Object` `TransactionalNumberGenerator.generateNewID(Class<? extends DBEntry> entryClass)` calls `TransactionalNumberGenerator.getRelevantValue()`
`Object` `SessionIdGenerator.generateNewID(Class<? extends DBEntry> entryClass)` this implementation doesn't do anything but returning generateNewID(), thus disregarding the given parameter
`Object` `IDFactory.generateNewID(Class<? extends DBEntry> entryClass)` generates and returns an Object suitable to be used as a new ID for an instance of the given DBEntry class.
`static void` `DBUtils.store(Database<?> db, Iterator<? extends DBEntry> i)`

Constructors in com.antelmann.db with parameters of type DBEntry
`CollectionClassStore(Database<?> db, boolean serialize, Class<T> type, T... entries)`
`DBEntrySelection(DBEntry... entries)`
`DBVersionedUpdateEvent(DBUpdateEvent updateEvent, DBEntry oldVersion, DBEntry newVersion)`

Constructor parameters in com.antelmann.db with type arguments of type DBEntry
`DBStoreListener.StoreUpdateAdapter(Class<? extends DBEntry> type, ActionListener al)`
`DefaultDBReference(Database<?> db, Object referenceID, Class<? extends DBEntry> referenceClass)`

Uses of DBEntry in com.antelmann.db.remote

Methods in com.antelmann.db.remote that return types with arguments of type DBEntry
`Class<? extends DBEntry>` `RemoteDBUpdateEvent.getEntryClass()`

Uses of DBEntry in com.antelmann.genealogy

Classes in com.antelmann.genealogy that implement DBEntry
`class` `GAnnotation`
`class` `GEventEntry`
`class` `GEventRelation<P extends GPerson,E extends GEventEntry,R>` defines the relationship between an event entry and a natural person
`class` `GPerson` represents a natural person
`static class` `GPerson.Header`
`class` `GPersonalBlogEntry`
`class` `GPersonRelation` implements the relation between two people in regards to their literal relation
`class` `GTag` defines general tags for this package.
`class` `GUser`

Uses of DBEntry in com.antelmann.image

Classes in com.antelmann.image with type parameters of type DBEntry
`interface` `ImageEntryManager<T extends DBEntry>`

Classes in com.antelmann.image that implement DBEntry
`class` `ImageURLEntry` ImageEntry serves as a basic wrapper for image information stored in a database.
`static class` `ImageURLEntry.Thumbnail<T extends ImageURLEntry>`

Uses of DBEntry in com.antelmann.io

Classes in com.antelmann.io with type parameters of type DBEntry
`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.

Uses of DBEntry in com.antelmann.math

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

`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 DBEntry in com.antelmann.net.mail

Classes in com.antelmann.net.mail that implement DBEntry
`class` `MessageEntry` A wrapper around a Message object that allows for database storage and serialization.

Uses of DBEntry in com.antelmann.net.web

Classes in com.antelmann.net.web that implement DBEntry
`class` `YouTubeVideo` wraps a YouTube video ID and provides access to online meta data for the video

Uses of DBEntry in com.antelmann.opengeodb

Classes in com.antelmann.opengeodb that implement DBEntry
`class` `GeoLocation` represents a location entry in the OpenGeoDB

Uses of DBEntry in com.antelmann.servlet

Methods in com.antelmann.servlet with parameters of type DBEntry
`protected void` `DBEntryServlet.showEntry(DBEntry entry, javax.servlet.http.HttpServletRequest req, javax.servlet.http.HttpServletResponse resp)` supports `HtmlSupported`, `Imageable`, `DetailedString` and `Object.toString()`.

Uses of DBEntry in com.antelmann.sql

Classes in com.antelmann.sql with type parameters of type DBEntry
`class` `BaseRowMapper<T extends DBEntry>` serves as a base class for implementations of ObjectRowMapper.
`class` `BeanMapper<T extends DBEntry>` a specialized mapper that allows to map columns to property names based on Bean patterns.
`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` `JDBCRowStore<T extends DBEntry>` provides JDBC persistence for Objects that have a corresponding ObjectRowMapper.
`class` `MappedEntryMapper<T extends DBEntry>` a special mapper that completely automates the mapping with specially annotated `DBEntry` classes via reflection.
`class` `MySqlQueryToViewMapper<T extends DBEntry>` enables the automated use of views with MySQL for better performance
`interface` `ObjectRowMapper<T extends DBEntry>` provides methods to convert an object to a RowItem and vice versa to facilitate persistent storage with JDBC for simple objects.
`class` `PropertyMapper<T extends DBEntry>` allows to easily map only remaining columns that are not mapped otherwise to properties - if applicable and desirable.
`class` `SerializedEntrySQLMapper<T extends DBEntry>` implements a simple mapper that serializes the entire object and stores it as a stream
`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` `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` `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.

Classes in com.antelmann.sql that implement DBEntry
`class` `DBDocument` DBDocument stores/retrieves the content from a stream out of a table column in a relational database.
`static class` `DBDocument.Header`
`class` `RowItem` represents a row in a sql database table and provides convenient access to its properties.

Methods in com.antelmann.sql with type parameters of type DBEntry

`

`<E extends DBEntry> PreparedStatementEntryFilter<T>`

`

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

`static

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

`

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

`static

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

`

`CategoryStore.createStandardExtractor(String categoryIdColumn, Class<T> type)`

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type)`
convenience method to easily create a store with no factory

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type, boolean useNextIntForID)`
convenience method to easily create a store and use `BaseRowMapper.getNextIntID()` to implement `BaseRowMapper.generateNewID()`

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type, boolean useNextIntForID, boolean fastDelete)`
convenience method to easily create a store and use `BaseRowMapper.getNextIntID()` to implement `BaseRowMapper.generateNewID()`

`static

`<T extends DBEntry> JDBCRowStore<T>`

`

`MappedEntryMapper.createStore(Database<Connection> db, Class<T> type, IDFactory factory, boolean enableFastDelete)`
convenience method to easily create a store

`

`<S extends DBEntry> Stub<S>`

`

`BaseRowMapper.extractStub(RowItem ri, Object idTopic, Object stringTopic, Class<S> type)`
convenience method

`

`<S extends DBEntry> Filter<S>`

`

`CategoryStore.getCategoryUsageFilterFor(Class<S> type, Object categoryId)`

`

`<T extends DBEntry> T`

`

`SQLDatabase.getRandomEntry(Class<T> type, Filter<? super T> filter)`

`

`<E extends DBEntry,I> I`

`

`SQLDatabase.queryStoreForInterface(Class<E> type, Class<I> desiredInterface)`
additionally supports `SQLColumnInfo` via `SQLColumnInfoStore` for every store supporting `MappingInfo`

`

`<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)`

Methods in com.antelmann.sql that return types with arguments of type DBEntry
`Map<String,Class<? extends DBEntry>>` `ForeignKeyMappingInfo.getForeignKeys()` returns all columns denoting a foreign key mapped to their respective class representation, so that a component can allow to select from the respective values accordingly.
`Map<String,Class<? extends DBEntry>>` `DefaultMappingInfo.getForeignKeys()`
`static Map<Class<? extends DBEntry>,Integer>` `ForeignKeyMappingInfo.Analyzer.getUsage(DBReference ref, Database<?> db)`
`Class<? extends DBEntry>` `SQLEntryClassMapper.objectToEntryClass(Object referenceType)`

Methods in com.antelmann.sql with parameters of type DBEntry
`boolean` `SQLColumnInfo.UpdateFilter.accept(DBEntry entry)`
`protected Map<String,Object>` `SerializedEntrySQLMapper.generateRowProperties(DBEntry entry)`
`boolean` `PropertyMapper.mapColumnsAsProperties(RowItem row, DBEntry entry)` maps all columns that are not reserved otherwise to properties only if the given entry is actually a `PropertyEntry` and `PropertyMapper.isMapRemainingColumnsAsProperties()` is true.
`boolean` `PropertyMapper.mapPropertiesAsColumns(DBEntry entry, Map<String,Object> map)` maps all properties that are not already contained in the given map only if the given entry is actually a `PropertyEntry` and `PropertyMapper.isMapRemainingColumnsAsProperties()` is true.

Method parameters in com.antelmann.sql with type arguments of type DBEntry
`boolean` `SQLEntryClassMapper.addMapping(Class<? extends DBEntry> type, String tableName)`
`Object` `SQLEntryClassMapper.entryClassToObject(Class<? extends DBEntry> resourceClass)`
`String[]` `SQLDatabase.getColumnNames(Class<? extends DBEntry> type)` returns all column names that are mapped by the standard query by taking advantage of the `MappingInfo` interface - if applicable
`Hashtable<String,Integer>` `SQLDatabase.getColumnTypes(Class<? extends DBEntry> type)` returns all column names mapped to their respective `Types`.
`String` `SQLDatabase.getDisplayColumn(Class<? extends DBEntry> type)` takes advantage of the `MappingInfo` interface - if applicable
`String` `SQLDatabase.getIDColumn(Class<? extends DBEntry> type)` takes advantage of the `MappingInfo` interface - if applicable
`String` `SQLDatabase.getTableName(Class<? extends DBEntry> type)` takes advantage of the `MappingInfo` interface - if applicable
`String` `SQLDatabase.getTableQuery(Class<? extends DBEntry> type)` takes advantage of the `MappingInfo` interface - if applicable
`String` `SQLEntryClassMapper.removeMapping(Class<? extends DBEntry> type)`
`void` `DefaultMappingInfo.setForeignKey(String column, Class<? extends DBEntry> c)`
`void` `RelationshipStore.setFromClass(Class<? extends DBEntry> c)` must be set if the topic `RelationshipManager.Column.FROM_CLASS` is not set
`protected void` `RelationshipStore.Mapper.setFromClass(Class<? extends DBEntry> c)`
`void` `RelationshipStore.setToClass(Class<? extends DBEntry> c)` must be set if the topic `RelationshipManager.Column.TO_CLASS` is not set
`protected void` `RelationshipStore.Mapper.setToClass(Class<? extends DBEntry> c)`

Uses of DBEntry in com.antelmann.util

Classes in com.antelmann.util that implement DBEntry
`class` `Country` allows to treat a country just like any other DBEntry object and includes useful components to use countries in tables and lists.

Uses of DBEntry in com.antelmann.util.gui

Methods in com.antelmann.util.gui with type parameters of type DBEntry

`static

`<T extends DBEntry> ValueRetriever<DBReference>`

`

`MyAbstractAction.createReferenceRetriever(ValueRetriever<T> retriever)`

`static

`<T extends DBEntry> ValueRetriever<Stub<T>>`

`

`MyAbstractAction.createStubRetriever(T entry)`

`static

`<T extends DBEntry> ValueRetriever<Stub<T>>`

`

`MyAbstractAction.createStubRetriever(ValueRetriever<T> retriever)`

Uses of DBEntry in com.antelmann.util.revision

Classes in com.antelmann.util.revision that implement DBEntry
`class` `StatusString` a status based on a simple String object

Uses of DBEntry in com.antelmann.webdav

Classes in com.antelmann.webdav that implement DBEntry
`class` `CardHeader` represents a VCard entry

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