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