Holger's Java API

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

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