Uses of Interface
com.antelmann.db.TransactionRequired

Packages that use TransactionRequired

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.net.mail	The classes in this package are designed to ease the handling of emails.
com.antelmann.sql	This package contains classes to ease JDBC development and also provides useful SQL-based implementations for com.antelmann.db classes
com.antelmann.util	This package contains generally useful classes that are used throughout the other packages in this framework.

Uses of TransactionRequired in com.antelmann.crm

Subinterfaces of TransactionRequired in com.antelmann.crm

interface

RoleManager<R extends Role<?>> Provides convenience for dealing with roles assuming that.

Classes in com.antelmann.crm that implement TransactionRequired

class	AddressableMapper<T extends Addressable & DBEntry> handles the address of a given addressable entry
class	FriendsEntryStore<T extends FriendsEntry<?>>

Uses of TransactionRequired in com.antelmann.db

Subinterfaces of TransactionRequired in com.antelmann.db

interface	CategoryManager specifies the functionality commonly used to deal with categories and implemented by a DBClassStore.
interface	DBClassStore<T extends DBEntry> provides persistence service for a DBEntry class in the context of a Database.

Classes in com.antelmann.db that implement TransactionRequired

class	AbstractDBClassStore<T extends DBEntry> provides basic implementation of methods that can be implemented based on other methods of the interface - though these implementations may be very inefficient
class	ArchiveDBClassStore<T extends DBEntry> allows to add an archive store to any given store, which enables to extend the data set.
class	CollectionClassStore<T extends DBEntry> a transient DBClassStore implementation based on a simple collection of DBEntries.
class	DBClassStoreCache<T extends DBEntry> a special store that has the ability of caching entries, so that multiple calls to retrieve an entry may be answered through cache hits.
class	EnumDBStore<T extends Enum<?> & DBEntry> allows any Enum that also implements DBEntry to be made available via DBClassStore.
class	ReadOnlyCacheStore<T extends DBEntry> provides a transaction-independent, in-memory-cached, read-only wrapper around a given store.
class	ReadOnlyStore<T extends DBEntry> a wrapper around a DBClassStore that disables altering the store's content
class	WrappedDBClassStore<T extends DBEntry> a generic DBClassStore wrapper easing the implementation of special wrappers.

Uses of TransactionRequired in com.antelmann.genealogy.db

Classes in com.antelmann.genealogy.db that implement TransactionRequired

class	GPersonRelationStore
class	GPersonStore

Uses of TransactionRequired in com.antelmann.image

Subinterfaces of TransactionRequired in com.antelmann.image

interface

ImageEntryManager<T extends DBEntry>

Classes in com.antelmann.image that implement TransactionRequired

class	ImageURLEntryMapper<T extends ImageURLEntry> an abstract base implementation of a mapper to be used with an ImageHolderSQLStore.
class	ImageURLEntrySQLStore<T extends ImageURLEntry> an implementation of a DBClassStore to be used with ImageURLEntry objects.
class	ThumbnailMapper<T extends ImageURLEntry.Thumbnail<?>>

Uses of TransactionRequired in com.antelmann.io

Classes in com.antelmann.io that implement TransactionRequired

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

Classes in com.antelmann.net.mail that implement TransactionRequired

class

MessageEntryMapper<M extends MessageEntry>

Uses of TransactionRequired in com.antelmann.sql

Subinterfaces of TransactionRequired in com.antelmann.sql

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.
interface	PropertyEntryMapping provides mapping information for PropertyEntry objects
interface	RelationshipManager allows to effectively work with relationships stored in a relational database.
interface	SQLColumnInfo provides some useful information about certain columns in a table.
interface	TaggableMapping allows to access relevant information for Taggable objects

Classes in com.antelmann.sql that implement TransactionRequired

class	BaseDocumentMapper<T extends BaseDocument> a bases for implementing a store for a given BaseDocument class
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	DBDocumentStore<T extends DBDocument>
static class	DBDocumentStore.Mapper<T extends DBDocument>
class	DetailRowStore<T extends PropertyEntry> Deprecated. use PropertyEntryTableStore instead
class	GenericPropertyEntryMapper<T extends PropertyEntry> provides an easy way to map a table to a PropertyEntry class; this implementation makes several (common) assumptions about the mapping.
class	GenericPropertyEntryStore<T extends PropertyEntry> automatically maps a PropertyEntry class to a database, where some default assumptions have to be met.
class	JDBCRowStore<T extends DBEntry> provides JDBC persistence for Objects that have a corresponding ObjectRowMapper.
class	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
class	PropertyEntryHeaderStore<T extends EntryHeader<?>> useful for mapping EntryHeader objects transparently to support the PropertyEntry interface on the header store (for filtering purposes)
class	PropertyEntryTableStore<T extends PropertyEntry> a specialized store that provides help for dealing with PropertyEntry objects, assuming that the properties are to be stored in a separate detail table.
class	PropertyMapper<T extends DBEntry> allows to easily map only remaining columns that are not mapped otherwise to properties - if applicable and desirable.
class	RelationshipStore<T extends DefaultEntryRelationship> provides an SQL-based store for relationships.
static class	RelationshipStore.Mapper<T extends DefaultEntryRelationship>
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	TaggableHeaderStore<T extends EntryHeader<?>> useful for mapping EntryHeader objects transparently to support the TaggableMapping interface on the header store (for filtering purposes)
class	TaggableMappingImpl a default implementation that allows to easily adopt a mapping based on JDBC information
class	TaggablePropertyEntrySQLStore<T extends PropertyEntry & Taggable<G>,G extends Keyword> a convenient standard implementation of a DBClassStore combining TaggableMapping and PropertyEntryMapping.
class	TaggableSQLStore<T extends Taggable<G> & DBEntry,G extends Keyword> provides a store that can wrap any given store to provide persistence for its grouping capacity based on Keyword objects.
class	UnionSqlStore<T extends DBEntry> implements a read-only store that is based on a union-sql-query derived from the common columns of a number of given stores.
class	UserImplMapper<T extends UserImpl> provides a base mapper implementation for storing a User.
class	UserImplStore<T extends UserImpl> provides a user store implementation that implements UserLoginStore, so that the database can be queried based on that interface.
class	WrappedDBClassStoreMapping<T extends DBEntry> eases the wrapping of stores that need to override certain mapping infos
class	WrappedObjectRowMapper<T extends DBEntry> eases the task of wrapping a given mapper and overriding only certain aspects of its behavior.

Uses of TransactionRequired in com.antelmann.util

Classes in com.antelmann.util that implement TransactionRequired

static class

Country.Store provides a convenient read-only store for all existing Country objects without having to hold them all in memory constantly