Uses of Class
com.antelmann.db.DatabaseException

Packages that use DatabaseException

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

Uses of DatabaseException in com.antelmann.calendar

Methods in com.antelmann.calendar that throw DatabaseException

void	SQLCalendarDB.close()
void	CalendarDB.close()
boolean	SQLCalendarDB.containsEntry(CalendarEntry entry)
boolean	CalendarDB.containsEntry(CalendarEntry entry) entry is there if the id corresponds to an entry in the database; the contained data may be different
boolean	SQLCalendarDB.deleteEntry(CalendarEntry entry) deletes the given entry from the database
boolean	FileCalendarDB.deleteEntry(CalendarEntry entry)
boolean	CalendarDB.deleteEntry(CalendarEntry entry) the corresponding entry in regards to the id will be deleted
Collection<Alert>	SQLCalendarDB.getActiveAlerts()
Collection<Alert>	FileCalendarDB.getActiveAlerts()
Collection<Alert>	CalendarDB.getActiveAlerts() returns all active non-acknowledged alerts
Collection<Alert>	SQLCalendarDB.getAlerts(Filter<Alert> filter)
Collection<Alert>	FileCalendarDB.getAlerts(Filter<Alert> filter)
Collection<Alert>	CalendarDB.getAlerts(Filter<Alert> filter)
Collection<CalendarEntry>	SQLCalendarDB.getEntries(Filter<CalendarEntry> filter)
Collection<CalendarEntry>	FileCalendarDB.getEntries(Filter<CalendarEntry> filter)
Collection<CalendarEntry>	CalendarDB.getEntries(Filter<CalendarEntry> filter)
void	SQLCalendarDB.insertAlert(Alert alert)
void	FileCalendarDB.insertAlert(Alert alert)
void	CalendarDB.insertAlert(Alert alert)
CalendarEntry	SQLCalendarDB.insertEntry(CalendarEntry entry)
CalendarEntry	FileCalendarDB.insertEntry(CalendarEntry entry)
CalendarEntry	CalendarDB.insertEntry(CalendarEntry entry) the id of the given entry is ignored; the returned entry will reflect the actual database object
void	SQLCalendarDB.updateAlert(Alert alert)
void	FileCalendarDB.updateAlert(Alert alert)
void	CalendarDB.updateAlert(Alert alert)
void	SQLCalendarDB.updateEntry(CalendarEntry entry)
void	CalendarDB.updateEntry(CalendarEntry entry)

Uses of DatabaseException in com.antelmann.crm

Methods in com.antelmann.crm that throw DatabaseException

R	RoleManager.getRole(DBReference baseEntry) returns the first role found of the specified type or null
Collection<R>	RoleManager.getRoles(DBReference baseEntry) returns a collection of roles for the given base entry or an empty collection
boolean	RoleManager.hasRoles(DBReference baseEntry) determines whether there are roles of type R for the given base entry

Constructors in com.antelmann.crm that throw DatabaseException

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 DatabaseException in com.antelmann.db

Subclasses of DatabaseException in com.antelmann.db

class	ConnectionException ConnectionException signals access problems with the database.
class	DBAccessDeniedWarning thrown to indicate that access to a database was not allowed due to applicable restrictions
class	DBVetoException thrown to indicate that a listener disagreed with an update of the database
class	IntegrityWarning
class	NotApplicableDataWarning used to indicate a 'minor' problem with the data that is to be displayed as a warning rather than an exception
class	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.
class	WrongDataException WrongDataException signals a consistency problem with the data submitted to the database.

Methods in com.antelmann.db that return types with arguments of type DatabaseException

Processor<T,? extends DatabaseException>	WrappedDBClassStore.getFetchProcessor()
Handler<T,? extends DatabaseException>	WrappedDBClassStore.getPreStoreHandler()
Handler<T,? extends DatabaseException>	WrappedDBClassStore.getStoreHandler()
Processor<Stub<T>,? extends DatabaseException>	WrappedDBClassStore.getStubProcessor()

Method parameters in com.antelmann.db with type arguments of type DatabaseException

void	WrappedDBClassStore.add(Processor<T,? extends DatabaseException> p)
boolean	WrappedDBClassStore.remove(Processor<T,? extends DatabaseException> p)
void	WrappedDBClassStore.setFetchProcessor(Processor<T,? extends DatabaseException> fetchProcessor)
void	WrappedDBClassStore.setPreStoreHandler(Handler<T,? extends DatabaseException> preStoreHandler)
void	WrappedDBClassStore.setStoreHandler(Handler<T,? extends DatabaseException> storeHandler)
void	WrappedDBClassStore.setStubProcessor(Processor<Stub<T>,? extends DatabaseException> stubProcessor)
protected <X> Filter<X>	WrappedDBClassStore.wrapFilterForProcessing(Filter<? super X> filter, Processor<X,? extends DatabaseException> p) This method is only used if WrappedDBClassStore.setProcessBeforeFiltering(boolean) is set to true.

Methods in com.antelmann.db that throw DatabaseException

void	DBTransaction.abort() aborts this transaction; requires ownership of this instance.
void	AbstractDBTransaction.abort()
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.
void	DBTransaction.commit() commits all data within the transaction scope to the underlying database; requires ownership of this instance.
void	AbstractDBTransaction.commit()
static <T> T	DBUtils.commitCall(Callable<T> call, DBTransaction tx) commits the given task synchronized to the transaction and aborts the transaction in case of an exception
static void	DBUtils.commitEntries(Database<?> db, Iterator<? extends DBEntry> it)
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.
static void	DBUtils.commitTask(Task<?> task, DBTransaction tx) commits the given task synchronized to the transaction and aborts the transaction in case of an exception
boolean	AbstractDatabase.contains(DBReference ref)
<T extends DBEntry> boolean	AbstractDatabase.contains(T entry)
boolean	WrappedDBClassStore.containsID(Object id)
boolean	ReadOnlyCacheStore.containsID(Object id)
boolean	DBClassStoreCache.containsID(Object id)
boolean	DBClassStore.containsID(Object id) determines whether the given ID is present in this store.
boolean	CollectionClassStore.containsID(Object id)
boolean	ArchiveDBClassStore.containsID(Object id)
boolean	AbstractDBClassStore.containsID(Object id)
<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 TableModel	DBUtils.createMappingInfoModel(Database<?> db)
static TableModel	DBUtils.createMappingInfoModel(Database<?> db, Monitor mon)
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
boolean	AbstractDatabase.delete(DBReference ref)
boolean	AbstractDatabase.delete(Stub<?> stub)
<T extends DBEntry> boolean	AbstractDatabase.delete(T entry)
int	WrappedDBClassStore.deleteEntries(Filter<? super T> filter)
int	ReadOnlyStore.deleteEntries(Filter<? super T> filter)
int	ReadOnlyCacheStore.deleteEntries(Filter<? super T> filter)
int	DBClassStoreCache.deleteEntries(Filter<? super T> filter)
int	DBClassStore.deleteEntries(Filter<? super T> filter) deletes all DBEntry objects that match the given filter; if the filter is null, all resources are deleted.
int	CollectionClassStore.deleteEntries(Filter<? super T> filter)
int	ArchiveDBClassStore.deleteEntries(Filter<? super T> filter)
int	AbstractDBClassStore.deleteEntries(Filter<? super T> filter)
protected int	WrappedDBClassStore.deleteEntriesIndividually(Filter<? super T> filter) deletes all applicable entries by instantiating them and then call WrappedDBClassStore.deleteEntry(Object) on each entries.
boolean	WrappedDBClassStore.deleteEntry(Object id)
boolean	ReadOnlyStore.deleteEntry(Object id)
boolean	ReadOnlyCacheStore.deleteEntry(Object id)
boolean	EnumDBStore.deleteEntry(Object id)
boolean	DBClassStoreCache.deleteEntry(Object id)
boolean	DBClassStore.deleteEntry(Object id) removes the entry with the given ID from this store in the database.
boolean	CollectionClassStore.deleteEntry(Object id)
boolean	ArchiveDBClassStore.deleteEntry(Object id)
static <T extends DBEntry> int	DBUtils.deleteIndividually(DBClassStore<T> store, Filter<? super T> filter) deletes all entries that pass the given filter individually
DBEntry	DefaultDBReference.dereference(Database<?> db)
protected abstract void	AbstractDBTransaction.doAbort()
protected abstract void	AbstractDBTransaction.doCommit()
void	Stub.ensureReferenceString(Database<?> db)
void	DefaultDBReference.ensureReferenceString(Database<?> db)
static DBReference	DBUtils.ensureReferenceString(Database<?> db, DBReference ref)
void	Stub.ensureReferenceString(DBClassStore<T> store)
static void	DefaultDBReference.ensureReferenceString(DBReference ref, Database<?> db)
static boolean	DBUtils.exists(Database<?> db, DBReference ref) determines whether there is a relevant store that contains the relevant id for the given reference in the given database
DBEnumeration<T>	WrappedDBClassStore.fetch(Filter<? super T> filter)
DBEnumeration<T>	ReadOnlyCacheStore.fetch(Filter<? super T> filter)
DBEnumeration<T>	EnumDBStore.fetch(Filter<? super T> filter)
DBEnumeration<T>	DBClassStoreCache.fetch(Filter<? super T> filter) adds support for DBClassStoreCache.PrefetchedFilter
DBEnumeration<T>	DBClassStore.fetch(Filter<? super T> filter) allows to retrieve the entries of this storage via iteration.
DBEnumeration<T>	CollectionClassStore.fetch(Filter<? super T> filter)
DBEnumeration<T>	ArchiveDBClassStore.fetch(Filter<? super T> filter)
DBEnumeration<Stub<T>>	WrappedDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)
DBEnumeration<Stub<T>>	ReadOnlyCacheStore.fetchStubs(Filter<? super Stub<?>> filter)
DBEnumeration<Stub<T>>	DBClassStore.fetchStubs(Filter<? super Stub<?>> filter) allows to access objects from this store w/o having to instantiate the entire original objects, but instead use Stubs to be able to display the list properly for selection.
DBEnumeration<Stub<T>>	CollectionClassStore.fetchStubs(Filter<? super Stub<?>> filter) the display value of the returned Stub is based on the toString() method of the DBEntry instance
DBEnumeration<Stub<T>>	ArchiveDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)
DBEnumeration<Stub<T>>	AbstractDBClassStore.fetchStubs(Filter<? super Stub<?>> filter)
static Set<Class<? extends DBEntry>>	DBUtils.findStoresWithID(Database<?> db, Object id)
void	TransactionListener.finishTransaction(DBTransaction transaction) called before the transaction commits (and before TransactionListener.prepareToCommit(DBTransaction)), so that the commit at the database level can be prevented by throwing a DatabaseException here.
void	TransactionListener.Adapter.finishTransaction(DBTransaction transaction)
void	LoggerTransactionListener.finishTransaction(DBTransaction transaction)
void	DBTransactionStoreAdapter.finishTransaction(DBTransaction transaction)
void	DBClassStoreCache.finishTransaction(DBTransaction transaction)
boolean	LockManager.forceUnlock(DBReference ref, long lockTime) if you don't have the token, you may first obtain the LockInfo and then use its time to release the given lock
int	LockManager.forceUnlockForAll(long anyLockAquiredBeforeThisTime)
Object	WrappedDBClassStore.generateNewID()
Object	ReadOnlyStore.generateNewID()
Object	ReadOnlyCacheStore.generateNewID()
Object	EnumDBStore.generateNewID()
Object	DBClassStore.generateNewID() this method is to generate unique new IDs for the DBEntry at hand - if the application has no other specific way of providing new IDs for this implementation.
Object	CollectionClassStore.generateNewID()
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.
protected abstract String	SessionIdGenerator.generateSessionPrefix() this method is to access the database to generate a new session prefix on every call and also store it into the database, so that it is guaranteed that no other call ever re-uses this prefix again.
protected String	SessionIdGenerator.generateSQLSessionPrefix(Connection con, String table, String idColumn, String sessionKey, String valueColumn, String separator)
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.
User[]	UserLoginStore.getActiveUsers() returns a generated array of currently active users (never null).
Iterable<Object>	CategoryManager.getAllSubCategoryIDs(DBReference categoryRef)
<T extends DBEntry> T	AbstractDatabase.getEntry(Class<T> c, Object id) a shortcut w/o having to go through the DBClassStore
DBEntry	AbstractDatabase.getEntry(DBReference ref) This method will begin and abort a transaction if none is active at the time.
T	WrappedDBClassStore.getEntry(Object id)
T	ReadOnlyCacheStore.getEntry(Object id)
T	DBClassStoreCache.getEntry(Object id)
T	DBClassStore.getEntry(Object id) returns the DBEntry based on its ID.
T	CollectionClassStore.getEntry(Object id)
T	ArchiveDBClassStore.getEntry(Object id)
T	AbstractDBClassStore.getEntry(Object id)
<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)
LockInfo	LockManager.getLockInfo(DBReference ref)
T	Stub.getOriginalInstance(Database<?> db) retrieves and returns the original object for this stub
T	Stub.getOriginalInstance(DBClassStore<T> store) retrieves and returns the original object for this stub
<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	EntryHeader.getReferenceEntry(Database<?> db) retrieves and returns the original object for this EntryHeader
Long	TransactionalNumberGenerator.getRelevantValue() calls TransactionalNumberGenerator.generateNewCount() in a transactionally synchronized context
<T extends DBEntry> Stub<T>	AbstractDatabase.getStub(Class<T> c, Object id) a shortcut w/o having to go through the DBClassStore
Stub<? extends DBEntry>	AbstractDatabase.getStub(DBReference ref) This method will begin and abort a transaction if none is active at the time.
Stub<T>	WrappedDBClassStore.getStub(Object id)
Stub<T>	ReadOnlyCacheStore.getStub(Object id)
Stub<T>	DBClassStoreCache.getStub(Object id)
Stub<T>	DBClassStore.getStub(Object id) returns a Stub representing the resource for the given ID or null.
Stub<T>	CollectionClassStore.getStub(Object id)
Stub<T>	ArchiveDBClassStore.getStub(Object id)
Stub<T>	AbstractDBClassStore.getStub(Object id)
List<? extends Category<?>>	CategoryManager.getSubCategories(DBReference categoryRef)
List<? extends Category<?>>	CategoryManager.getTopCategories()
User	UserLoginStore.getUserForName(String name) returns the User associated with the given name or null if no such user exists
User	DefaultUserLoginStore.getUserForName(String name)
Iterable<String>	UserLoginStore.getUserNames() returns a list of valid user names (never null)
static <T extends DBEntry> void	DBUtils.handle(DBClassStore<T> store, Handler<? super T,?> handler, Filter<? super T> filter, Monitor monitor, boolean useCommitNotAbort)
void	SessionIdGenerator.initNewSession() this method must be called at least once after instanciation to init a new session for providing unique IDs.
void	WrappedDBClassStore.insert(T entry)
void	ReadOnlyStore.insert(T entry)
void	ReadOnlyCacheStore.insert(T entry)
void	EnumDBStore.insert(T entry)
void	DBClassStoreCache.insert(T entry)
void	DBClassStore.insert(T entry) it is suggested to create the entry with an ID obtained through generateNewID() before passing it into this method.
void	CollectionClassStore.insert(T entry)
Object	WrappedDBClassStore.insertAsNew(T entry)
Object	ReadOnlyStore.insertAsNew(T entry)
Object	ReadOnlyCacheStore.insertAsNew(T entry)
Object	EnumDBStore.insertAsNew(T entry)
Object	DBClassStore.insertAsNew(T entry) inserts the given entry using an ID generated by generateNewID while ignoring the ID of the given entry.
Object	CollectionClassStore.insertAsNew(T entry) always throws UnsupportedOperationException
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.
boolean	DefaultEntryRelationship.isBroken(Database<?> db) a relationship is NOT broken only if the following applies for both, the from-reference and the to-reference: there is a store in the database for the specified type there exists an entry with the id of the reference in the store
boolean	CategoryManager.isLeaf(DBReference categoryRef)
boolean	LockManager.isLocked(DBReference ref)
boolean	LockManager.isLockedWithToken(DBReference ref, String token)
boolean	CategoryManager.isUsed(DBReference categoryRef)
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)
ArrayList<User>	AbstractUserLoginStore.listUsers(Filter<? super User> filter)
static ArrayList<User>	AbstractUserLoginStore.listUsers(UserLoginStore uls, Filter<? super User> filter) it may be more efficient to achieve this via an embedded DBClassStore if applicable
static Stub<?>	DBUtils.loadStub(Database<?> db, DBReference ref) reloads a reference as a stub, so that the display value is properly initialized.
String	LockManager.lock(DBReference ref, String who, String where, String why)
User	UserLoginStore.loginUser(String name, char[] password, String fromLocation) returns the User that corresponds to the credentials provided; listeners are notified
User	AbstractUserLoginStore.loginUser(String name, char[] password, String fromLocation)
void	UserLoginStore.loginUser(User user, String fromLocation) allows to login a user via API directly
void	AbstractUserLoginStore.loginUser(User user, String fromLocation)
static void	AbstractUserLoginStore.logoutAll(UserLoginStore uls)
boolean	UserLoginStore.logoutUser(User user) logs the given user out of this store and notifies the listeners
<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(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(DBClassStore<T> store, Filter<? super Stub<?>> filter)
int	ArchivedStore.moveToArchive(Filter<? super T> filter) requires transactional context on both stores
int	ArchiveDBClassStore.moveToArchive(Filter<? super T> filter)
void	CollectionClassStore.put(T entry)
void	ReadOnlyCacheStore.refreshContent()
boolean	LockManager.release(DBReference ref, String token)
void	Stub.reloadDisplayValue(Database<?> db)
void	Stub.reloadDisplayValue(DBClassStore<T> store)
Stub<T>	Stub.reloadInstance(Database<?> db)
Stub<T>	Stub.reloadInstance(DBClassStore<T> store)
static DBEntry	DBEntrySelection.resolve(DBReference ref, Database<?> db)
static <T> T	DBUtils.runInTransaction(Callable<T> call, DBTransaction t, boolean useCommitNotAbort) the given task is guaranteed to run in an active transaction, where this method only begins a transaction, if the given transaction is not active, yet.
static void	DBUtils.runInTransaction(Task<? extends Exception> task, DBTransaction t, boolean useCommitNotAbort) the given task is guaranteed to run in an active transaction, where this method only begins a transaction, if the given transaction is not active, yet.
static User	JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls) uses the default location
static User	JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, Image image, JUserLoginPanel.ImageLocation imageLocation)
static User	JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, String location)
static User	JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, String location, Image image, JUserLoginPanel.ImageLocation imageLocation)
static User	JUserLoginPanel.showDialog(String title, Component parent, UserLoginStore uls, String location, Image image, JUserLoginPanel.ImageLocation imageLocation, String userString, String pwdString) Upon successful login, the associated user is logged into the UserLoginStore.
int	WrappedDBClassStore.size(Filter<? super T> filter)
int	ReadOnlyCacheStore.size(Filter<? super T> filter)
int	DBClassStore.size(Filter<? super T> filter) returns the total number of T elements in this store based on the given filter (which may be null)
int	CollectionClassStore.size(Filter<? super T> filter)
int	ArchiveDBClassStore.size(Filter<? super T> filter)
int	AbstractDBClassStore.size(Filter<? super T> filter)
static void	DBUtils.store(Database<?> db, DBEntry... entries)
static void	DBUtils.store(Database<?> db, Iterator<? extends DBEntry> i)
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
boolean	LockManager.unlock(DBReference ref, String token)
void	WrappedDBClassStore.update(T entry)
void	ReadOnlyStore.update(T entry)
void	ReadOnlyCacheStore.update(T entry)
void	EnumDBStore.update(T entry)
void	DBClassStoreCache.update(T entry)
void	DBClassStore.update(T entry) updates the given entry in the database.
void	CollectionClassStore.update(T entry)
void	ArchiveDBClassStore.update(T entry)
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 that throw DatabaseException

CollectionClassStore(Database<?> db, boolean serialize, Class<T> type, T... entries)

CollectionClassStore(Database<?> db, Class<T> type, boolean serialize, Collection<T> col)

DefaultDBReference(DBClassStore<?> store, Object referenceID)

Uses of DatabaseException in com.antelmann.genealogy.db

Methods in com.antelmann.genealogy.db that throw DatabaseException

static DBClassStore<GPerson.Header>	GPersonStore.createHeaderStore(Database<Connection> db)
protected String	GIDFactory.generateSessionPrefix()

Constructors in com.antelmann.genealogy.db that throw DatabaseException

GPersonRelationStore(Database<Connection> db, IDFactory factory)

GPersonStore(Database<Connection> db, IDFactory idFactory)

Uses of DatabaseException in com.antelmann.image

Methods in com.antelmann.image that throw DatabaseException

static <T extends ImageURLEntry.Thumbnail<?>> JDBCRowStore<T>	ThumbnailMapper.createStore(Database<Connection> db, Class<T> thumbnailType, Class<? extends ImageURLEntry> imageEntryType, String tableName, String idColumn, String thumbnailColumn, String urlColumn, String displayColumn)
<TN extends ImageURLEntry.Thumbnail<T>> ThumbnailMapper<TN>	ImageURLEntrySQLStore.createThumbnailMapper(Class<TN> tnType)

Constructors in com.antelmann.image that throw DatabaseException

ImageURLEntryMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, Class<T> type)
uses BaseRowMapper.getNextIntID() as id-factory

ImageURLEntryMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)

ImageURLEntrySQLStore(Database<Connection> database, String tableName, IDFactory idFactory, Class<T> type)
uses 'id' and 'title' for id and display column

ImageURLEntrySQLStore(Database<Connection> database, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)

ThumbnailMapper(Database<Connection> db, Class<T> thumbnailType, Class<? extends ImageURLEntry> imageEntryType, String tableName, String idColumn, String thumbnailColumn, String urlColumn, String displayColumn)

Uses of DatabaseException in com.antelmann.io

Methods in com.antelmann.io that throw DatabaseException

boolean	FileClassStore.containsID(Object id)
int	FileClassStore.deleteEntries(Filter<? super T> filter)
boolean	FileClassStore.deleteEntry(Object id)
DBEnumeration<T>	FileClassStore.fetch(Filter<? super T> filter)
DBEnumeration<Stub<T>>	FileClassStore.fetchStubs(Filter<? super Stub<?>> filter)
String	FileClassStore.generateNewID()
T	FileClassStore.getEntry(Object id)
Stub<T>	FileClassStore.getStub(Object id)
void	FileClassStore.insert(T entry)
Object	FileClassStore.insertAsNew(T entry)
protected T	FileClassStore.loadEntry(File file)
protected Stub<T>	FileClassStore.loadStub(File file)
int	FileClassStore.size(Filter<? super T> filter)
void	FileClassStore.update(T entry)

Uses of DatabaseException in com.antelmann.math

Methods in com.antelmann.math that throw DatabaseException

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

Methods in com.antelmann.net.mail that throw DatabaseException

boolean	TableCustomizer.individualizeEmail(Email email, javax.mail.internet.InternetAddress address)
boolean	SQLEmailCustomizer.individualizeEmail(Email email, javax.mail.internet.InternetAddress address)
boolean	EmailCustomizer.individualizeEmail(Email email, javax.mail.internet.InternetAddress address) this method is called by the EmailAccount.send() method to individualize this particular email for given the address.
void	MessageEntryMapper.verifyBeforeStore(M entry, boolean isInsert)

Constructors in com.antelmann.net.mail that throw DatabaseException

MessageEntryMapper(Database<Connection> db, MappingInfo mi, Class<M> type)

MessageEntryMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<M> type)

MessageEntryMapper(Database<Connection> db, String tableName, String idColumn, String contentColumn, Class<M> type, IDFactory idFactory)

Uses of DatabaseException in com.antelmann.opengeodb

Methods in com.antelmann.opengeodb that throw DatabaseException

ArrayList<GeoLocation>

OpenGeoDB.getRootLocations()

Constructors in com.antelmann.opengeodb that throw DatabaseException

OpenGeoDB(Connection con)

OpenGeoDB(String server, String dbname, String user, String password)

Uses of DatabaseException in com.antelmann.servlet

Methods in com.antelmann.servlet that throw DatabaseException

static User	ServletUtils.authenticate(javax.servlet.ServletRequest req, UserLoginStore uls, Filter<? super User> filter) implements authentication via BasicAuth
User	UserAuthenticationFilter.getUserFor(javax.servlet.ServletRequest request)
static User	ServletUtils.getUserFromHeader(UserLoginStore uls, javax.servlet.ServletRequest request, String userKey, String pwdKey, boolean hashedPassword, Filter<? super User> filter)
static User	ServletUtils.getUserFromParams(UserLoginStore uls, javax.servlet.ServletRequest request, String userKey, String pwdKey, boolean hashedPassword, Filter<? super User> filter)

Uses of DatabaseException in com.antelmann.sql

Method parameters in com.antelmann.sql with type arguments of type DatabaseException

void	JDBCRowStore.add(Processor<T,? extends DatabaseException> processor)
boolean	JDBCRowStore.remove(Processor<T,? extends DatabaseException> processor)

Methods in com.antelmann.sql that throw DatabaseException

protected void	BaseRowMapper.checkExistence(DBReference ref)
static String	MySqlQueryToViewMapper.checkMySqlViewForQuery(BaseRowMapper<?> mapper, String tableQuery) checks whether an appropriate view already exists for the given mapper and creates one based on the given query if it doesn't exist.
boolean	SQLColumnInfoStore.containsColumnValue(String column, Object value)
boolean	SQLColumnInfo.containsColumnValue(String column, Object value)
boolean	JDBCRowStore.containsID(Object id)
int	SQLColumnInfoStore.countDistinctValues(String column, Map<String,Object> sqlRestrictions)
int	SQLColumnInfo.countDistinctValues(String column, Map<String,Object> sqlRestrictions)
int	RelationshipStore.countRelations(Map<RelationshipManager.Column,Object> restrictions)
int	RelationshipManager.countRelations(Map<RelationshipManager.Column,Object> restrictions) the mapped values for the class columns RelationshipManager.Column.TO_CLASS and RelationshipManager.Column.FROM_CLASS may be represented as Class
static <T extends Category.Entry> BaseRowMapper<T>	CategoryStore.createDefaultMapper(Database<Connection> db, String table, String idColumn, String nameColumn, String parentColumn, IDFactory factory, 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
int	SQLColumnInfoStore.deleteEntries(Filter<? super T> filter)
int	JDBCRowStore.deleteEntries(Filter<? super T> filter) supports SQLMapFilter for more effective deletion.
int	DetailRowStore.deleteEntries(Filter<? super T> filter) Deprecated.
boolean	TaggableSQLStore.deleteEntry(Object id)
boolean	PropertyEntryTableStore.deleteEntry(Object id)
boolean	JDBCRowStore.deleteEntry(Object id)
boolean	DetailRowStore.deleteEntry(Object id) Deprecated.
boolean	CategoryStore.deleteEntry(Object id)
protected void	TaggableSQLStore.deleteGroups(Object entryID)
protected void	SQLTransaction.doAbort()
protected void	SQLTransaction.doCommit()
DBEnumeration<T>	JDBCRowStore.fetch(Filter<? super T> filter) Depending of the capabilities of the mapper in use, this method can support various special filters.
DBEnumeration<Stub<T>>	JDBCRowStore.fetchStubs(Filter<? super Stub<?>> filter) This implementation supports SQLStubFilter and SQLDirectQueryEntryFilter objects; but otherwise, it doesn't filter in any more intelligent way than leaving the filtering to the AbstractIterator.
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)
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.
GenericPropertyEntryStore<RowItem>	SQLDatabase.generateGenericClassStore(String table, String idColumn, String displayColumn) generates and returns a generic wrapped DBClassStore on RowItem objects; the store is not put into the database (as multiple stores working on different tables could map to the RowItem class).
Object	WrappedObjectRowMapper.generateNewID()
Object	UserImplMapper.generateNewID() if no factory is given, getNextIntID is returned
Integer	SerializedEntrySQLMapper.generateNewID()
Object	ObjectRowMapper.generateNewID()
Object	JDBCRowStore.generateNewID() returns a value supplied by the mapper
Object	GenericPropertyEntryMapper.generateNewID() simply returns getNextIntID(), unless an IDFactory was provided
Object	BaseRowMapper.generateNewID() returns the return value of the given IDFactory or throws UnsupportedOperationException if no IDFactory was supplied
User[]	UserImplStore.getActiveUsers()
Iterable<Object>	CategoryStore.getAllSubCategoryIDs(DBReference categoryRef)
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.
Set<?>	SQLColumnInfoStore.getDistinctValues(String column, Map<String,Object> sqlRestrictions)
Set<?>	SQLColumnInfo.getDistinctValues(String column, Map<String,Object> sqlRestrictions)
Map<?,Integer>	SQLColumnInfoStore.getDistinctValuesWithCount(Map<String,Object> sqlRestrictions, String... column)
Map<?,Integer>	SQLColumnInfo.getDistinctValuesWithCount(Map<String,Object> sqlRestrictions, String... column)
T	JDBCRowStore.getEntry(Object id)
T	DetailRowStore.getEntry(Object id) Deprecated.
static TableModelWrapper	ForeignKeyMappingInfo.Analyzer.getForeignKeys(Database<Connection> db)
Object	SQLColumnInfoStore.getFunctionValueForColumn(String column, SQLFunction func, Map<String,Object> sqlRestrictions)
Object	SQLColumnInfo.getFunctionValueForColumn(String column, SQLFunction func, Map<String,Object> sqlRestrictions)
protected List<T>	CategoryStore.getList(Filter<? super T> filter)
int	SQLColumnInfoStore.getMaxLength(String textColumn, Map<String,Object> sqlRestrictions)
int	SQLColumnInfo.getMaxLength(String textColumn, Map<String,Object> sqlRestrictions)
protected Integer	BaseRowMapper.getNextIntID() a convenience implementation for easily providing a way of generating new IDs for tables using an integer column as ID column.
<T extends DBEntry> T	SQLDatabase.getRandomEntry(Class<T> type, Filter<? super T> filter)
Stub<T>	JDBCRowStore.getStub(Object id)
List<T>	CategoryStore.getSubCategories(DBReference categoryRef)
String[]	BaseRowMapper.getTableColumnNames()
String[]	SQLDatabase.getTableNames()
List<T>	CategoryStore.getTopCategories()
static Map<Class<? extends DBEntry>,Integer>	ForeignKeyMappingInfo.Analyzer.getUsage(DBReference ref, Database<?> db)
User	UserImplStore.getUserForName(String name)
T	UserImplMapper.getUserForName(String name) for use with an AbstractUserLoginStore
Iterable<String>	UserImplStore.getUserNames()
Iterable<String>	UserImplMapper.getUserNames() for use with an AbstractUserLoginStore
void	WrappedObjectRowMapper.handleAfterStore(T entry, boolean isInsert)
void	UserImplMapper.handleAfterStore(T entry, boolean isInsert)
void	ObjectRowMapper.handleAfterStore(T entry, boolean isInsert) called by the store after a given entry is either inserted or updated, so that additional updates (other than providing the RowItem for storage) can take place.
void	BaseRowMapper.handleAfterStore(T entry, boolean isInsert) does nothing unless overridden
boolean	RelationshipStore.hasRelationships(DBReference ref)
boolean	RelationshipManager.hasRelationships(DBReference ref) determines if there are any relationsips present for a given reference (both: active and passive)
protected void	TaggableSQLStore.initGroups(T entry)
protected void	BaseRowMapper.initMapping() responsible for initializing and caching the meta data for the MappingInfo interface; note that this method is indirectly called by the constructor
void	PropertyEntryTableStore.insert(T entry)
void	JDBCRowStore.insert(T entry)
void	DetailRowStore.insert(T entry) Deprecated.
Object	PropertyEntryTableStore.insertAsNew(T entry)
Object	JDBCRowStore.insertAsNew(T entry)
Object	DetailRowStore.insertAsNew(T entry) Deprecated.
static boolean	ForeignKeyMappingInfo.Analyzer.isInUse(DBReference ref, Database<?> db)
boolean	CategoryStore.isLeaf(DBReference categoryRef)
boolean	CategoryStore.isUsed(DBReference categoryRef)
Set<DefaultEntryRelationship>	RelationshipStore.listAllRelations(DBReference ref, Object relationType)
Set<DefaultEntryRelationship>	RelationshipManager.listAllRelations(DBReference ref, Object relationType) contains passive and active relationships for the given reference - restricted to the given type if non-null
List<DefaultEntryRelationship>	RelationshipStore.listRelations(Map<RelationshipManager.Column,Object> restrictions)
List<DefaultEntryRelationship>	RelationshipManager.listRelations(Map<RelationshipManager.Column,Object> restrictions) the mapped values for the class columns RelationshipManager.Column.TO_CLASS and RelationshipManager.Column.FROM_CLASS may be represented as Class
User	UserImplStore.loginUser(String name, char[] password, String fromLocation)
void	UserImplStore.loginUser(User user, String fromLocation)
boolean	UserImplStore.logoutUser(User user)
int	SQLColumnInfoStore.replaceColumnValue(String column, Object oldValue, Object newValue, boolean useQueryIfApplicable)
int	SQLColumnInfo.replaceColumnValue(String column, Object oldValue, Object newValue, boolean useQueryIfApplicable) fires a database update event
void	GenericPropertyEntryStore.setRestrictedMappedColumns(String... columns)
void	RelationshipStore.setTableQuery(String query)
void	MySqlQueryToViewMapper.setTableQuery(String tableQuery)
void	GenericPropertyEntryStore.setTableQuery(String query)
void	GenericPropertyEntryMapper.setTableQuery(String tableQuery)
protected void	BaseRowMapper.setTableQuery(String tableQuery) allows to set a query for mapping the data instead of just using the table name.
void	GenericPropertyEntryStore.setTableQuery(String query, String newIdColumn)
void	GenericPropertyEntryMapper.setTableQuery(String tableQuery, String newIdColumn)
protected void	BaseRowMapper.setTableQuery(String tableQuery, String newIdColumn) in addition to setting a table query, this also allows to change the id column (often required to ensure the uniqueness of the id column in a query that may contain the column multiple times).
int	JDBCRowStore.size(Filter<? super T> filter) supports special performance optimization for SQLMapFilter and some other.
protected void	TaggableSQLStore.storeGroups(T entry)
protected void	SortedGroupableSQLStore.storeGroups(T entry)
void	PropertyEntryTableStore.update(T entry)
void	JDBCRowStore.update(T entry)
void	DetailRowStore.update(T entry) Deprecated.
void	WrappedObjectRowMapper.verifyBeforeDelete(Object id)
void	UserImplMapper.verifyBeforeDelete(Object id)
void	ObjectRowMapper.verifyBeforeDelete(Object id) called by the store before a given entry is deleted, so that additional checks can easily be incorporated.
void	BaseRowMapper.verifyBeforeDelete(Object id) does nothing unless overridden
void	BaseDocumentMapper.verifyBeforeDelete(Object id) if a relationshipManager is set, it is verified that there are no relations to this document
void	WrappedObjectRowMapper.verifyBeforeStore(T entry, boolean isInsert)
void	RelationshipStore.Mapper.verifyBeforeStore(T entry, boolean isInsert)
void	ObjectRowMapper.verifyBeforeStore(T entry, boolean isInsert) called by the store before a given entry is either inserted or updated, so that additional checks can easily be incorporated.
void	BaseRowMapper.verifyBeforeStore(T entry, boolean isInsert) checks whether the filter (if non-null) accepts the entry.

Constructors in com.antelmann.sql that throw DatabaseException

BaseDocumentMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)

BaseRowMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)
allows to initialize this MappingInfo with the given one.

BaseRowMapper(Database<Connection> db, String tableName, String idColumn)
the idColumn is also used as the displayColumn

BaseRowMapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)

BaseRowMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn)

BaseRowMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)

BaseRowMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)
this constructor is eventually called by all others

BeanMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)

BeanMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)

DBDocumentStore.Mapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)

DBDocumentStore(Database<Connection> db, IDFactory idFactory, Class<T> type)
uses a table named 'dokumente'

DBDocumentStore(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, String query, Class<T> type)

GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, Class<T> type)
uses reflection to utilize the constructor that takes the ID and then the properties as a map

GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, IDFactory idFactory, Class<T> type)

GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, PropertyEntryFactory<T> factory, Class<T> type)
uses the factory to generate instances; either factory or type must not be null

GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, String displayColumn, Class<T> type)
uses reflection to utilize the constructor that takes the ID and then the properties as a map

GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, String displayColumn, PropertyEntryFactory<T> factory, Class<T> type)
uses the factory to generate instances; either factory or type must not be null

GenericPropertyEntryMapper(Database<Connection> db, String table, String idColumn, String displayColumn, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)
uses the factory to generate instances; either factory or type must not be null

GenericPropertyEntryMapper(DBClassStore<?> refStore, Class<T> type)

GenericPropertyEntryMapper(DBClassStore<?> refStore, PropertyEntryFactory<T> factory, Class<T> type, IDFactory idFactory)

GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, Class<T> type)

GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, Class<T> type, IDFactory idFactory)

GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, PropertyEntryFactory<T> factory, Class<T> type)

GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, String displayColumn, Class<T> type)

GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, String displayColumn, PropertyEntryFactory<T> factory, Class<T> type)

GenericPropertyEntryStore(Database<Connection> db, String table, String idColumn, String displayColumn, 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.

MappedEntryMapper(Database<Connection> db, Class<T> type)

MappedEntryMapper(Database<Connection> db, Class<T> type, IDFactory factory)

MySqlQueryToViewMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)

MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn)

MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)

MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn)

MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)

MySqlQueryToViewMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)

PropertyMapper(Database<Connection> db, MappingInfo mi, IDFactory idFactory, Class<T> type, Object... topics)

PropertyMapper(Database<Connection> db, String tableName, String idColumn)

PropertyMapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)

PropertyMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn)

PropertyMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type)

PropertyMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> type, String query)

RelationshipStore.Mapper(Database<Connection> db, String tableName, String idColumn, IDFactory idFactory, Class<T> type)

RelationshipStore.Mapper(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory idFactory, Class<T> type)

RelationshipStore.Mapper(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory idFactory, Class<T> type, String query)

RelationshipStore(Database<Connection> db, String tableName, String idColumn, Class<T> type, boolean useNextIntAsID)

RelationshipStore(Database<Connection> db, String tableName, String idColumn, IDFactory factory, Class<T> type)

RelationshipStore(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, Class<T> type, boolean useNextIntAsID)

RelationshipStore(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory factory, Class<T> type)

RelationshipStore(Database<Connection> db, String tableName, String idColumn, Map<RelationshipManager.Column,String> config, IDFactory factory, Class<T> type, String query)

SerializedEntrySQLMapper(Database<Connection> db, String tableName, String idColumnName, String displayColumn, String objectStreamColumnName)

UnionSqlStore(Class<T> type, Collection<Object> topics, DBClassStore<?>... stores)

UnionSqlStore(Class<T> type, DBClassStore<?>... stores)

UserImplMapper(Database<Connection> db, String tableName, String idColumn, String displayColumn, IDFactory idFactory, Class<T> userType)

Uses of DatabaseException in com.antelmann.util

Methods in com.antelmann.util that throw DatabaseException

boolean	Country.Store.containsID(Object id)
int	Country.Store.deleteEntries(Filter<? super Country> filter)
boolean	Country.Store.deleteEntry(Object id)
DBEnumeration<Country>	Country.Store.fetch(Filter<? super Country> filter)
DBEnumeration<Stub<Country>>	Country.Store.fetchStubs(Filter<? super Stub<?>> filter)
Object	Country.Store.generateNewID()
Country	Country.Store.getEntry(Object id)
Stub<Country>	Country.Store.getStub(Object id)
void	Country.Store.insert(Country entry)
Object	Country.Store.insertAsNew(Country entry)
int	Country.Store.size(Filter<? super Country> filter)
void	Country.Store.update(Country entry)

Uses of DatabaseException in com.antelmann.util.gui

Methods in com.antelmann.util.gui that throw DatabaseException

protected List<? extends Keyword>

JTagsField.getAvailableGroups()