All Classes

Class	Description
Abs	Absolute value.
AbsExpression	Denotes ABS() operation on a given expression.
AbstractBrokerFactory	Abstract implementation of the BrokerFactory that must be subclassed for a specific runtime.
AbstractCFMetaDataFactory	Base class for factory implementations built around XML metadata files in the common format.
AbstractCFMetaDataFactory.Parser	Internal parser interface.
AbstractCFMetaDataFactory.Serializer	Internal serializer interface.
AbstractChangeTracker	Base class that provides utilities to change trackers.
AbstractClassStrategy	No-op strategy for easy extension.
AbstractCollectionDecorator<E>	Decorates another Collection to provide additional behaviour.
AbstractConcurrentEventManager	Base event manager that handles adding/removing listeners and firing events.
AbstractDataCache	Abstract DataCache implementation that provides various statistics, logging, and timeout functionality common across cache implementations.
AbstractDataCacheInstrument	Provides a basic instrument implementation wrapper for the data cache.
AbstractDB2Dictionary	Base dictionary for the IBM DB2 family of databases.
AbstractDiscriminatorStrategy	No-op strategy for easy extension.
AbstractDomainObject	Domain Object is a path expression over which query is evaluated.
AbstractDualBidiMap<K,V>	Abstract BidiMap implemented using two maps.
AbstractDualBidiMap.BidiMapIterator<K,V>	Inner class MapIterator.
AbstractDualBidiMap.EntrySet<K,V>	Inner class EntrySet.
AbstractDualBidiMap.EntrySetIterator<K,V>	Inner class EntrySetIterator.
AbstractDualBidiMap.KeySet<K>	Inner class KeySet.
AbstractDualBidiMap.KeySetIterator<K>	Inner class KeySetIterator.
AbstractDualBidiMap.MapEntry<K,V>	Inner class MapEntry.
AbstractDualBidiMap.Values<V>	Inner class Values.
AbstractDualBidiMap.ValuesIterator<V>	Inner class ValuesIterator.
AbstractDualBidiMap.View<K,V,E>	Inner class View.
AbstractEmptyMapIterator<K,V>	Provides an implementation of an empty map iterator.
AbstractExpressionBuilder	Abstract base class to help build expressions.
AbstractExpressionVisitor	No-op abstract visitor meant for easy extension.
AbstractFieldStrategy	No-op strategy for easy extension.
AbstractHashedMap<K,V>	An abstract implementation of a hash-based map which provides numerous points for subclasses to override.
AbstractHashedMap.EntrySet<K,V>	EntrySet implementation.
AbstractHashedMap.EntrySetIterator<K,V>	EntrySet iterator.
AbstractHashedMap.HashEntry<K,V>	HashEntry used to store the data.
AbstractHashedMap.HashIterator<K,V>	Base Iterator
AbstractHashedMap.HashMapIterator<K,V>	MapIterator implementation.
AbstractHashedMap.KeySet<K>	KeySet implementation.
AbstractHashedMap.KeySetIterator<K>	KeySet iterator.
AbstractHashedMap.Values<V>	Values implementation.
AbstractHashedMap.ValuesIterator<V>	Values iterator.
AbstractInstrument	Provides a base for creating instruments.
AbstractInstrumentationProvider	Specialized instrumentation providers can extend this class to get basic provider state and capabilities.
AbstractIterableMap<K,V>	Provide a basic IterableMap implementation.
AbstractIteratorDecorator<E>	Provides basic behaviour for decorating an iterator with extra functionality.
AbstractJDBCListener	An abstract implementation of the JDBCListener listener.
AbstractJDBCSavepointManager	Abstract SavepointManager implementation that delegates to the subclass for savepoint operations on the active Connection.
AbstractJDBCSeq	Abstract sequence implementation.
AbstractKeyValue<K,V>	Abstract pair class to assist with creating KeyValue and Map.Entry implementations.
AbstractLifecycleListener	Abstract implementation of the LifecycleListener interface which delegates events to a single method.
AbstractLinkedMap<K,V>	An abstract implementation of a hash-based map that links entries to create an ordered map and which provides numerous points for subclasses to override.
AbstractLinkedMap.EntrySetIterator<K,V>	EntrySet iterator.
AbstractLinkedMap.KeySetIterator<K>	KeySet iterator.
AbstractLinkedMap.LinkEntry<K,V>	LinkEntry that stores the data.
AbstractLinkedMap.LinkIterator<K,V>	Base Iterator that iterates in link order.
AbstractLinkedMap.LinkMapIterator<K,V>	MapIterator implementation.
AbstractLinkedMap.ValuesIterator<V>	Values iterator.
AbstractListDecorator<E>	Decorates another List to provide additional behaviour.
AbstractLockManager	Abstract LockManager implementation.
AbstractLog	A simple implementation of the Log interface.
AbstractLRSProxyCollection	A collection proxy designed for collections backed by extremely large result sets in which each call to AbstractLRSProxyCollection.iterator() may perform a database query.
AbstractLRSProxyMap<K,V>	A map proxy designed for maps backed by extremely large result sets in which each call to AbstractLRSProxyMap.get(java.lang.Object) or AbstractLRSProxyMap.containsKey(java.lang.Object) may perform a database query.
AbstractManagedRuntime
AbstractManagedType<X>	Implements the managed persistent type and its attributes.
AbstractManagedType.AttributeNameFilter<X>
AbstractManagedType.AttributeTypeFilter<X,Y>	Selects if the attribute type matches the given Java class.
AbstractManagedType.DeclaredAttributeFilter<X>
AbstractManagedType.ElementTypeFilter<X,E>	Selects plural attribute of given element type.
AbstractManagedType.EntryTypeFilter<X,K,V>
AbstractManagedType.Filter<T>	Affirms if a given element satisfy a condition.
AbstractManagedType.IdAttributeFilter<X>
AbstractManagedType.PluralCategoryFilter<X>
AbstractManagedType.SingularAttributeFilter<X>	Affirms if the given attribute is a Singular attribute.
AbstractManagedType.VersionAttributeFilter<X>
AbstractMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractMapEntry<K,V>	Abstract Pair class to assist with creating correct Map.Entry implementations.
AbstractMapEntryDecorator<K,V>	Provides a base decorator that allows additional functionality to be added to a Map.Entry.
AbstractMetaDataDefaults	Abstract implementation provides a set of generic utilities for detecting persistence meta-data of Field/Member.
AbstractMetaDataFactory	Abstract MetaDataFactory that provides default implementations of many methods.
AbstractNonSequentialResultList	Abstract base class for random-access result lists.
AbstractOpenJpaEnhancerMojo	The base class for all enhancement mojos.
AbstractOpenJpaMappingToolMojo	Processes Application model classes and generate the DDL by running the OpenJPA MappingTool.
AbstractOpenJpaMojo	Base class for OpenJPA maven tasks.
AbstractOrderedMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to an OrderedMap via decoration.
AbstractPCData	Abstract base class which implements core PCData behavior.
AbstractPCResultObjectProvider	Abstract implementation of PCResultObjectProvider that implements ResultObjectProvider.getResultObject() by assembling the necessary information about the object to be loaded.
AbstractPreparedQueryCacheInstrument	Provides a basic instrument implementation wrapper for the prepared query cache.
AbstractProductDerivation	Abstract no-op product derivation for easy extension.
AbstractQuery<X>	An abstract implementation of the Query interface.
AbstractQueryCache	Abstract QueryCache implementation that provides various statistics, logging, and timeout functionality common across cache implementations.
AbstractQueryCache.Default<T>	A default implementation of query statistics for the Query result cache.
AbstractQueryCache.EvictPolicy
AbstractQueryCacheInstrument	Provides a basic instrument implementation wrapper for the query cache.
AbstractReferenceMap<K,V>	An abstract implementation of a hash-based map that allows the entries to be removed by the garbage collector.
AbstractReferenceMap.ReferenceEntry<K,V>	A MapEntry implementation for the map.
AbstractReferenceMap.ReferenceStrength	Reference type enum.
AbstractRemoteCommitProvider	Abstract implementation of RemoteCommitProvider.
AbstractResult	A Result implementation designed to be subclassed easily by implementations.
AbstractResultList<E>	Abstract base class for read-only result lists.
AbstractSequentialResultList	Abstract base class for sequential result lists.
AbstractSerializableListDecorator<E>	Serializable subclass of AbstractListDecorator.
AbstractSerializableSetDecorator<E>	Serializable subclass of AbstractSetDecorator.
AbstractSetDecorator<E>	Decorates another Set to provide additional behaviour.
AbstractSortedMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractSortedMapDecorator.SortedMapIterator<K,V>	OrderedMapIterator implementation.
AbstractSQLServerDictionary	Dictionary for the SQL Server databases (Sybase and MS SQL Server).
AbstractStoreBrokerFactory	BrokerFactory implementation for use with the AbstractStoreManager.
AbstractStoreManager	Abstract store manager implementation to ease development of custom OpenJPA back-ends.
AbstractStoreQuery	Abstract StoreQuery that implements most methods as no-ops.
AbstractStoreQuery.AbstractExecutor	Abstract StoreQuery.Executor that implements most methods as no-ops.
AbstractStrategy	No-op strategy for easy extension.
AbstractTask	Ant tasks all have a nested <config&rt; tag, which uses the configuration as a bean-like task.
AbstractTransactionListener	Abstract implementation of the TransactionListener interface that provides no-op implementations of all methods.
AbstractUntypedIteratorDecorator<I,O>	Provides basic behaviour for decorating an iterator with extra functionality without committing the generic type of the Iterator implementation.
AbstractUpdateManager	Base update manager with common functionality.
AbstractUpdateManager.CustomMapping	Executes customized mapping updates.
AbstractValidator	Abstract validation class which provides base validation methods.
AbstractValueHandler	No-op implementations of ValueHandler interface methods.
AbstractVersionStrategy	No-op strategy for easy extension.
AccessCode	Represents access styles for members of a class and field through a 5-bit integer.
AccessDictionary	Dictionary for Access via DataDirect SequeLink and DataDirect ODBC FoxPro driver.
Address
Aggregate	Type of the result of an aggregate operation
AggregateListener	An aggregate listener aggregates data produced by an ExpressionQuery.
AndPredicate	Denotes (e1 AND e2) predicate.
AnnotationBuilder	Helper class to stringify annotation declarations.
AnnotationPersistenceMappingParser	Persistence annotation mapping parser.
AnnotationPersistenceMappingSerializer	Serializes persistence mappings as annotations.
AnnotationPersistenceMetaDataParser	Persistence annotation metadata parser.
AnnotationPersistenceMetaDataSerializer	Serializes persistence metadata as annotations.
AnnotationPersistenceXMLMetaDataParser	JAXB xml annotation metadata parser.
AnnotationProcessor6	Annotation processing tool generates source code for a meta-model class given the annotated source code of persistent entity.
ApplicationIds	Utility class for manipulating application object ids.
ApplicationIdTool	Generates a class appropriate for use as an application identity class.
ApplicationIdTool.Flags	Run flags.
ApplicationIdTool.ObjectIdLoader	Interface implemented by metadata factories that can load non-existant object id classes.
ApplicationIdToolTask	Executes the application id tool on the specified files.
Args	A list of arguments to a multi-argument function.
ArgumentException	Extended IllegalArgumentException.
Arguments	Multiple arguments to a function call.
ArrayExpression	A single expression that holds an array of values.
ArrayStateImage	Utilities for dealing with a simple state image consisting of an Object[] of field values with one extra index containing a BitSet of loaded fields.
AsmHelper	Utility methods to deal with ASM bytecode
AttachListener	Listener for when a detached instance is attached.
AttachManager	Handles attaching instances.
AttributeLegendView	Displays color codes of each attribute type.
AttributeTranslator	Instances of this interface can convert a positional index for a FieldMetaData that uses property access into the underlying field name.
AttributeView	View of a persistent attribute as a JLabel.
Auditable	Annotates a persistent type for audit.
AuditableOperation	Operations of persistent type that can be audited.
Audited	Carries immutable information about an audited persistent instance.
AuditLogger	A default auditor that simply prints the audited instances.
AuditManager	Controller for audit facility.
Auditor	An auditor is responsible for recoding the audited information.
Author	A persistent entity to represent an author of one or more Book.
AutoClear	State clearing constants.
AutoClearType	The possible settings for the auto-clear behavior of an OpenJPAEntityManager.
AutoDetach	Bit flags for when to automatically detach the entire persistence context.
AutoDetachType	The possible settings for the auto-detach behavior of an OpenJPAEntityManager.
AutoDriverDataSource	Automatic Commons DBCP pooling or Simple non-pooling driver data source.
AutomaticManagedRuntime	Implementation of the ManagedRuntime interface that searches through a set of known JNDI locations and method invocations to locate the appropriate mechanism for obtaining a TransactionManager.
AverageExpression	Denotes AVG() on a given Expression.
Base16Encoder	Base 16 encoder.
BatchedResultObjectProvider	A provider for multiple result sets.
BatchingConstraintUpdateManager	Batch update manager that writes the SQL in object-level operation order.
BatchingOperationOrderUpdateManager	Batch update manager that writes the SQL in object-level operation order.
BatchingPreparedStatementManagerImpl	Batch prepared statement manager implementation.
BCClassWriter
BeanLifecycleCallbacks	Performs a callback method on a cached bean instance.
BeginTransactionListener	Notified when transactions begin.
BetweenExpression	Denotes e1 BETWEEN(e2 AND e3) Expression.
BidiMap<K,V>	Defines a map that allows bidirectional lookup between key and values.
BigDecimalId
BigIntegerId
BinaryConditionalOperator	Enumeration of conditional operator that operates on ordered pair of expression to generate a predicate.
BinaryFunctionalOperator	Enumeration of functional operator that operates on ordered pair of expression to generate another expression.
BinaryOperatorExpression	An expression resulting from a binary operation on two expressions.
BindableParameter
BlacklistClassResolver
BlobValueHandler	Handler for blob values.
Book	An immutable persistent entity represents a Book.
BooleanId	OpenJPAId subclass appropriate for boolean fields.
BooleanRepresentation<REPRESENTATION_TYPE>	Defines how a Boolean or boolean value gets stored in the database by default.
BooleanRepresentationFactory	Factory which is being used to create the active BooleanRepresentation.
BooleanRepresentationFactory.BooleanBooleanRepresentation
BooleanRepresentationFactory.Int10BooleanRepresentation
BooleanRepresentationFactory.StringBooleanRepresentation	BooleanRepresentation which takes 2 strings for true and false representations as constructor parameter;
BooleanValue	A boolean Value.
Bootstrap	Helper methods for acquiring BrokerFactory objects
BootstrapException	Exception recognized by bootstrap framework.
BoundedMap<K,V>	Defines a map that is bounded in size.
BreadthFirstWalk	Performs a breadth-first walk of a given Graph, notifying visitors as it sees each node.
Broker	The broker is the primary interface into the OpenJPA runtime.
BrokerFactory	Factory for Broker instances.
BrokerFactoryEvent	Event fired when a BrokerFactory is created.
BrokerFactoryEventManager	EventManager responsible for notifying listeners of BrokerFactoryEvents.
BrokerFactoryListener	Interface for listening to BrokerFactoryEvent objects.
BrokerFactoryValue	Value type used to represent the BrokerFactory.
BrokerImpl	Concrete Broker.
BrokerImpl.StateManagerId	Unique id for state managers of new datastore instances without assigned object ids.
BrokerValue	Custom PluginValue that can efficiently create BrokerImpl instances.
BuildSchemaPC	Persistent type used in testing the mappingtool's buildSchema action with files that use ASCII column names.
BuildUTF8SchemaPC	Persistent type used in testing the mappingtool's buildSchema action with files that use UTF-8 column names.
BundleDelegatingClassLoader	This is a simple ClassLoader that delegates to the Bundle and is used by the PersistenceUnitInfo
BundleUtils	OSGi helper class and methods.
BuyBookPage	A visual page coordinates the following functions of OpenBookService : query for books choose one or more of the selected books add them to Shopping Cart place a purchase order of the books in the shopping cart.
ByteArrayValueHandler	Handler for byte array values.
BytecodeWriter	Control how enhanced bytecode is written.
ByteId	OpenJPAId subclass appropriate for byte fields.
Bytes	This class came from the Apache Commons Id sandbox project in support of the UUIDGenerator implementation.
CacheDictionary	Dictionary for Intersystems Cache.
CacheDistributionPolicy	A policy determines whether a given entity should be cached and if true, in which named partition of the cache.
CacheMap	Fixed-size map that has ability to pin/unpin entries and move overflow to a backing soft map.
CacheMarshaller	Responsible for marshalling and unmarshalling objects between memory and durable cache.
CacheMarshaller.ValidationPolicy	Validation policies are responsible for computing whether or not a cached data structure is valid for the current context.
CacheMarshallerImpl	Default CacheMarshaller implementation that writes data to a specified file and reads data from a specified file or URL.
CacheMarshallersValue	A configuration value for handling and accessing cache marshallers.
CacheStatistics	Counts number of read/write requests and hit ratio for a cache in total and per-class basis.
CacheStatisticsImpl	The default CacheStatistics(SPI) implementation.
CacheStatisticsSPI	The provider extensions to the CacheStatistics interface.
Calendard	A calendar-modified value.
CallbackException	Exception type thrown when an error occurs in a callback.
CallbackMode	The possible settings for the callback behavior of an OpenJPAEntityManager.
CallbackModes	Callback handling constants.
CallbackOptions	Configurable options for callbacks.
CandidatePath	A path represents a traversal into fields of a candidate object.
CandidatePath.Traversal	Represents a traversal through a field.
CaseExpression	Interface for the construction of case expressions
CaseExpressionImpl
CFMetaDataParser	Custom SAX parser used by the system to quickly parse metadata files for classes.
CFMetaDataSerializer	Helps serialize metadata objects to package and class elements.
ChangeTracker	Interface for components that track changes to containers at a fine-grained level.
CharArrayStreamValueHandler	Handler for char array values.
CharArrayValueHandler	Handler for char array values.
CharId	OpenJPAId subclass appropriate for char fields.
ClassAnnotationMetaDataFilter	Filter that looks for classes with one of a set of annotations.
ClassArgParser	Parser used to resolve arguments into java classes.
ClassCriteria	Marker interface specifying to use the expected class of the relation as criteria in the join.
ClassListValue
ClassLoaderProxyService	Service to load classes dynamically at runtime.
ClassMapping	Specialization of metadata for relational databases.
ClassMappingInfo	Information about the mapping from a class to the schema, in raw form.
ClassMetaData	Contains metadata about a persistent type.
ClassMetaDataIterator	Iterator over all metadata resources that might contain the metadata for a given class, starting with the most general.
ClassNameDiscriminatorStrategy	Stores the class name along with each database object record.
ClassNodeTracker	Helper class to transit from BCClass to ASM
ClasspathMetaDataIterator	Iterator over directories in the classpath.
ClassRedefiner	Redefines the method bodies of existing classes.
ClassResolver	Interface to customize the loading of classes under OpenJPA.
ClassResolverImpl	Default class resolver implementation.
ClassStrategy	Mapping from a class to a relational schema.
ClassTableJDBCSeq	Specialization of the TableJDBCSeq that maintains a separate sequence count per-class.
ClassUtil	Various helper methods to deal with Classes
ClassWriterTracker	Helper to keep track of generated methods when using ASM ClassWriter.
Clearable	Generic interface for components that can be cleared so that helpers can treat them in a generic way.
ClearableScheduler	Cron-style clearable eviction.
ClearListener	Listener for when persistent state is cleared from an instance.
ClobValueHandler	Handler for clob values.
Closeable	Generic interface for components that can be closed so that helpers can treate them in a generic way.
Closure	Computes closure of a collection of managed objects.
Coalesce	An in-memory representation of a coalesce expression
CoalesceExpression	Coalesce expression.
CodeFormat	Encapsulates some common Java source code formatting options.
CodeGenerator	Generates Java class code from metadata.
CollectionChangeTracker	Change tracker that can be used for collections.
CollectionChangeTrackerImpl	Default CollectionChangeTracker.
CollectionParam	A collection-valued input parameter in an in-expression.
CollectionParam.ParamExpState	Expression state.
Column	Represents a database column.
ColumnDefIdentifierRule	Default rule for column definition.
ColumnIdentifierRule	Default rule for column names.
ColumnIO	Metadata about column I/O in a specific context.
Columns	Allows the specification of multiple columns for complex mappings.
ColumnVersionStrategy	Uses a one or more column(s) and corresponding version object.
CommandProcessor	Processes options.
CommandProcessor.Option	A simple immutable object represents meta-data about a command option.
Commentable	Implementations of this interface can be adorned with comments.
CommonsLogFactory	LogFactory implementation that delegates to the commons logging framework.
CommonsLogFactory.LogAdapter	Adapts a commons logging log to the Log interface.
ComparableComparator<E extends java.lang.Comparable<? super E>>	A Comparator that compares Comparable objects.
ComparatorChain<E>	A ComparatorChain is a Comparator that wraps one or more Comparators in sequence.
ComparisonStyle	Defines a comparison style to be applied for query-by-example attribute comparison.
ComparisonStyle.Default	Default implementation.
ComparisonStyle.StringComparisonMode
Compatibility	Struct encompassing backwards-compatibility options.
CompileTimeLogger	Simple logger sets log level from javac compilers annotation processing options -Alog=TRACE|INFO|WARN|ERROR and uses the processing environment to determine the log output stream.
Concat	Concatenate one string with another.
ConcatExpression	Denotes CONCAT(e1,e2,..)
ConcurrentDataCache	A DataCache implementation that is optimized for concurrent access.
ConcurrentHashMap	This class implements a HashMap which has limited synchronization.
ConcurrentHashMap.Entry
ConcurrentMap	A highly concurrent map.
ConcurrentQueryCache	A QueryCache implementation that is optimized for concurrent access.
ConcurrentReferenceHashMap	This class implements a HashMap which has limited synchronization and reference keys or values(but not both).
ConcurrentReferenceHashSet<E>	A concurrent set whose values may be stored as weak or soft references.
ConditionalOperator	Enumerates conditional operator that operates on two predicates to generate another predicate.
Configurable	This interface provides a mechanism for notifying interested objects when configuration events occur.
Configuration	Interface for generic configuration objects.
ConfigurationImpl	Default implementation of the Configuration interface.
ConfigurationProvider	Implementations of this interface can populate Configurations in some environment-specific way.
Configurations	Utility methods dealing with configuration.
Configurations.Runnable
ConfigurationViewer	Displays Properties.
ConfiguringConnectionDecorator	Connection decorator that can configure some properties of the underlying connection.
ConnectionDecorator	A connection decorator can wrap Connections before they are returned to the user to add functionality.
ConnectionInfo	Struct to hold data about the current connection state.
ConnectionRetainMode	The possible values for use when configuring the connection retain behavior for an OpenJPAEntityManager.
ConnectionRetainModes	Connection retain mode constants.
Constant	Interface for any query constant value.
Constants	Static String constants
Constraint	A table constraint.
ConstraintUpdateManager	Standard update manager, capable of foreign key constraint evaluation.
ContactInfo
ContainerFieldStrategy	An abstract container mapping that handles traversing the join to examine the size of the relation.
ContainerTable	Table for array, collection, or map elements.
Context	JPQL / Criteria Query Context
Coordinates
CountExpression	Denotes COUNT(e) Expression.
CriteriaBuilderImpl	Factory for Criteria query expressions.
CriteriaExpressionVisitor	A visitor for Criteria Expression nodes.
CriteriaExpressionVisitor.AbstractVisitor	An abstract implementation that can detect cycles during traversal.
CriteriaExpressionVisitor.ParameterVisitor	A visitor to register Parameter expression of a query.
CriteriaExpressionVisitor.TraversalStyle
CurrentTimeExpression	Denotes CURRENT_TIME(), CURRENT_DATE() and CURRENT_TIMESTAMP() expressions.
Customer	A persistent entity represents a Customer.
DataCache	Interface that must be implemented by any level 2 cache used by OpenJPA.
DataCache	Caching characteristics for this class.
DataCacheInstrument	Interface for providing instrumented data cache metrics and operations.
DataCacheJMXInstrument	A JMX-specific instrument for the data cache
DataCacheJMXInstrumentMBean	Simple MBean interface for providing instrumented data cache metrics and operations.
DataCacheManager	Manages the system's data and query caches.
DataCacheManagerImpl	Default data cache manager provides handle to utilities PCDataGenerator, ClearableScheduler and CacheDistributionPolicy for the cache operation.
DataCacheMode
DataCachePCData	Specialized PCData implementation for data caching.
DataCachePCDataGenerator	A PCDataGenerator instance which generates properly synchronized instances suitable for use in the cache.
DataCachePCDataGenerator.Timed	Simple interface to give access to expiration time.
DataCachePCDataImpl	Specialized PCData implementation for data caching.
DataCacheRetrieveMode	DataCache Retrieve Modes.
DataCacheStoreManager	StoreManager proxy that delegates to a data cache when possible.
DataCacheStoreMode	DataCache Store modes
DataLoader	Cleans and loads a new OpenBooks database.
DataSourceFactory	Factory for DataSource objects.
DataSourceLogs	Provies basic logging facilities to a DataSource.
DatastoreFunction	A unary operator that executes a datastore specific function with zero or more arguments.
DataStoreId	Describes how to generate a value for a field.
DataStoreIdColumn	Surrogate datastore identity column.
DateId	OpenJPAId subclass appropriate for Date fields.
DB2Dictionary	Dictionary for IBM DB2 database.
DBCPDriverDataSource	Commons DBCP basic pooling driver data source.
DBDictionary	Class which allows the creation of SQL dynamically, in a database agnostic fashion.
DBDictionary.DateMillisecondBehaviors
DBDictionary.SerializedData	Used by some mappings to represent data that has already been serialized so that we don't have to serialize multiple times.
DBDictionaryFactory	Factory class to instantiate a dictionary.
DBIdentifier	Encapsulates a database identifier.
DBIdentifier.DBIdentifierType	Database identifier types.
DBIdentifierRule	The default DBIdentifier rule.
DBIdentifierUtil	An interface for DB identifier utility-style operations.
DBIdentifierUtilImpl
DecoratingDataSource	Delegating data source that maintains a list of ConnectionDecorators.
DefaultCacheDistributionPolicy	A default implementation that selects the cache by the type of the given managed instance.
DefaultIdentifierConfiguration
DefaultMapEntry<K,V>	A restricted implementation of Map.Entry that prevents the Map.Entry contract from being broken.
Deity	An entity that contains relations corresponding to family tree relations.
Deity.Gender
DelayedArrayListProxy	ArrayList proxy with delay loading capability.
DelayedCollectionChangeTrackerImpl	A collection change tracker used by delay loaded collections.
DelayedHashSetProxy	HashSet proxy with delay loading capability.
DelayedLinkedHashSetProxy	LinkedHashSet proxy with delay loading capability.
DelayedLinkedListProxy	LinkedList proxy with delay loading capability.
DelayedPriorityQueueProxy	PriorityQueue proxy with delay loading capability.
DelayedProxy	Implemented by proxy classes which are delay-load capable.
DelayedTreeSetProxy	TreeSet proxy with delay loading capability.
DelayedVectorProxy	Vector proxy with delay loading capability.
DelegatingBroker	Delegating broker that can also perform exception translation for use in facades.
DelegatingBrokerFactory	Delegating broker factory that can also perform exception translation for use in facades.
DelegatingCallableStatement	CallableStatement that delegates to an internal statement.
DelegatingConnection	Wrapper around an existing connection.
DelegatingDatabaseMetaData	Wrapper around a DatabaseMetaData instance.
DelegatingDataCache	Delegating data cache that can also perform exception translation for use in facades.
DelegatingDataSource	Wrapper around an existing data source.
DelegatingExtent<T>	Delegating extent that also can perform exception translation for use in facades.
DelegatingFetchConfiguration	Delegating fetch configuration that can also perform exception translation for use in facades.
DelegatingJDBCFetchConfiguration	Delegating fetch configuration that can also perform exception transation for use in facades.
DelegatingJoinable	Delegates to another Joinable after doing column translation.
DelegatingMetaDataFactory	Base class for factory instances that use a delegate.
DelegatingPreparedStatement	Wrapper around an existing statement.
DelegatingQuery	Delegating query that can also perform exception translation for use in facades.
DelegatingQueryCache	Delegating query cache that can also perform exception translation for use in facades.
DelegatingResultList<T>	Delegating result list that can also perform exception translation for use in facades.
DelegatingResultSet	Wrapper around an existing result set.
DelegatingSeq	Delegating sequence that can also perform exception translation for use in facades.
DelegatingStatement	Wrapper around an existing statement.
DelegatingStoreManager	Base class for store manager decorators that delegate to another store manager for some operations.
DeleteListener	Listener for when a persistent instance is deleted.
DeliveryPage	A page to control delivery of pending orders.
Demo	A graphical user interface based client of OpenBooks for demonstration.
Demo.AboutDialog
Demo.ActionTreeNode	A tree node which may have an associated action.
Dependent	Dependent field marker.
DepthFirstAnalysis	Performs a depth-first analysis of a given Graph, caching information about the graph's nodes and edges.
DerbyDictionary	Dictionary for Apache Derby (formerly Cloudscape).
DetachedState	Detached state.
DetachedStateManager	Internal state manager for detached instances.
DetachedValueStateManager	Implementation of OpenJPAStateManager designed to retrieve values from a detached instance, including when managed by a DetachedStateManager.
DetachListener	Listener for when a persistent instance is detached.
DetachManager	Handles detaching instances.
DetachManagerLite	Handles detaching instances.
DetachOptions	Detach options.
DetachOptions.All	Public to allow reflection.
DetachOptions.FetchGroups	Public to allow reflection.
DetachOptions.Loaded	Detach loaded state.
DetachState	Constants for which fields to include in the detach graph.
DetachStateType	The possible settings for the detachment behavior of an OpenJPAEntityManager.
DirtyListener	Listener for when a persistent instance becomes dirty.
Discriminator	Handles determining the object class of database records.
DiscriminatorMappingInfo	Information about the mapping from a discriminator to the schema, in raw form.
DiscriminatorStrategy	Handles determining the object class of database records.
DiscriminatorStrategy	Discriminator mapping strategy.
DistinctExpression	Denotes DISTINCT(e) Expression.
DistinctResultList<E>	An immutable list that imposes uniqueness on its member.
DistributedBroker	Extension to Broker to allow access to virtual data store.
DistributedBrokerFactory	Extension to BrokerFactory to allow dynamically add/remove slices.
DistributedBrokerImpl	A specialized Broker to associate slice identifiers with the StateManagers as they are persisted in a cascade.
DistributedConfiguration	A configuration for multiple data stores, each referred as slice.
DistributedConnection	A virtual connection that contains multiple physical connections.
DistributedDataSource	A virtual datasource that contains many physical datasources.
DistributedJDBCBrokerFactory	A factory for distributed JDBC datastores.
DistributedJDBCConfiguration	A distributed configuration that is a ordered collection of JDBCConfigurations.
DistributedJDBCConfigurationImpl	A specialized configuration embodies a set of Slice configurations.
DistributedPreparedStatement	A virtual PreparedStaement that delegates to a set of actual PreparedStatements.
DistributedQueryImpl	Extension with slice locking policy.
DistributedResultSet	A chain of ResultSet.
DistributedStatement	A virtual Statement that delegates to many actual Statements.
DistributedStoreManager	A specialized Store Manager that encapsulates multiple concrete Store Managers using Distributed Template (or Composite) Design Pattern.
DistributedTemplate<T extends java.sql.Statement>	A template for multiple Statements being executed by multiple connections.
DistributionPolicy	Policy to select one of the physical databases referred as slice in which a given persistent instance will be stored.
DistributionPolicy.Default	Implements a default distribution policy to store the given instance to a randomly selected available slice.
DividedByExpression	Denotes e1/e2 Expression.
DocTypeReader	The DocTypeReader can be used to dynamically include a DOCTYPE declaration in an XML stream.
DomainObject	Domain objects define the domain over which a query operates.
DoubleId	OpenJPAId subclass appropriate for double fields.
DoubleValue	A double Value.
DriverDataSource	A DataSource that allows additional configuration options to be set into it, so that it can wrap a JDBC driver or other DataSource.
DualHashBidiMap<K,V>	Implementation of BidiMap that uses two HashMap instances.
DualTreeBidiMap<K,V>	Implementation of BidiMap that uses two TreeMap instances.
DualTreeBidiMap.BidiOrderedMapIterator<K,V>	Inner class MapIterator.
DualTreeBidiMap.ViewMap<K,V>	Internal sorted map view.
DynamicPersistenceCapable	Instances that implement this marker interface are dynamically-generated subtypes of managed types that were loaded before being enhanced.
DynamicSchemaFactory	Factory whose schema group dynamically fills itself with information as mappings validate themselves in their map method.
DynamicStorage	Interface for dynamically generated classes.
DynamicStorageGenerator	Factory for creating new DynamicStorage classes.
DynamicTCPRemoteCommitProvider
EagerFetchMode	Determines how to eager-fetch a field.
EagerFetchModes	Eager fetch mode constants.
EagerResultList	Simple, non-lazy ResultList implementation
Edge	A graph edge.
ElementClassCriteria	Marker interface specifying to use the expected class of the array, collection, or map element relation as criteria in the join.
ElementColumn	Array, collection, or map element column.
ElementColumns	Allows the specification of multiple element columns for complex mappings.
ElementDependent	Dependent array, collection, or map element marker.
ElementEmbeddedMapping	Embedded mapping information for an array, collection, or map element.
ElementEmbedValueHandler	Handler for embedded objects as elements of a collection or map.
ElementForeignKey	Foreign key on array, collection, or map element columns.
ElementIndex	Index on array, collection, or map element columns.
ElementJoinColumn	Array, collection, or map element join column.
ElementJoinColumns	Allows the specification of multiple array, collection, or map element columns for compound joins.
ElementNonpolymorphic	Indicates that the annotated array, collection, or map's elements are not entirely polymorphic.
ElementStrategy	Array, collection, or map element mapping strategy.
ElementType	Indicates the persistent element type of an array, collection, or map field, if different than the declared element type.
ElseExpression	Else clause in a Case Statement.
Embeddable	Interface for field strategies that can managed fields of embedded-element, embedded-key, and embedded-value objects.
EmbeddedClassStrategy	Class mapping for embedded objects.
EmbeddedMapping	Embedded mapping information.
EmbedFieldStrategy	Mapping for an embedded persistent object.
EmbedValueHandler	Base class for embedded value handlers.
EmpressDictionary	Dictionary for Empress using ODBC server combined with their type 2 driver.
EmptyIterator<E>	Provides an implementation of an empty iterator.
EmptyMapIterator<K,V>	Provides an implementation of an empty map iterator.
EmptyOrderedIterator<E>	Provides an implementation of an empty ordered iterator.
EmptyOrderedMapIterator<K,V>	Provides an implementation of an empty ordered map iterator.
EncryptionProvider	Interface for providing encryption/decryption capabilities to the OpenJPA runtime.
EndTransactionListener	Notified when transactions end.
EnhancementClassLoader	A special ClassLoader to handle classes currently under bytecode enhancement.
EnhancementProject	Keep track of classes under enhancement.
EntityDataModel<T>	A data model for a tabular view of a list of persistent entities.
EntityExistsException	Conflict with existing entity.
EntityManagerFactoryImpl	Implementation of EntityManagerFactory that acts as a facade to a BrokerFactory.
EntityManagerFactoryValue	Plugin type used to represent the EntityManagerFactory.
EntityManagerImpl	Implementation of EntityManager interface.
EntityNotFoundException	Missing entity.
EntityTable<T>	A specialized Swing table to display a list of persistent entity instances.
EntityTableView<T>	An entity table view consists of a JTable and optionally another table for many-valued associations.
EntityTypeView<T>	View of a persistent entity type as a JPanel.
EntryExpression	Denotes ENTRY(e) on a path.
EntrySetToMapIteratorAdapter<K,V>	Adapts a Map entrySet to the MapIterator interface.
EnumValueHandler	Value handler for JDK1.5 enum field types.
EqualExpression	Denotes e1 = e2 Expression.
ErrorDialog	A dialog to display runtime error.
ErrorHandler	Handles error.
EventManager	Basic event manager interface.
ExceptionInfo	Interface supplying additional exception information.
ExceptionOrphanedKeyAction	Throw a ObjectNotFoundException when an orphaned key is discovered.
Exceptions	Utility methods for externalizing and handling exceptions.
ExistsExpression	Denotes EXISTS(SubQuery) Expression.
Exp	An in-memory representation of an Expression.
ExpContext	Expression tree context.
ExpirationEvent	An event indicating the expiration of an object from the data cache, or an expiration of a result list from the query cache.
ExpirationListener	An entity that wishes to be notified when cache keys expire.
Expression	Interface for a set of conditions that must be met for the query to be true.
Expression	Instances of this interface can be used either as select list items or as predicate operands.
ExpressionFactory	The ExpressionFactory must be implemented by a particular runtime to form Expressions in its native query language.
ExpressionParser	Parser for query languages that will be used by a ExpressionQuery.
ExpressionStoreQuery	Implementation of an expression-based query, which can handle String-based query expressions such as JPQL and JDOQL.
ExpressionStoreQuery.AbstractExpressionExecutor	Provides support for queries that hold query information in a QueryExpressions instance.
ExpressionStoreQuery.DataStoreExecutor	The DataStoreExecutor executes the query against the implementation's overridden ExpressionStoreQuery.DataStoreExecutor.executeQuery(org.apache.openjpa.kernel.StoreQuery, java.lang.Object[], org.apache.openjpa.kernel.StoreQuery.Range) method.
ExpressionStoreQuery.InMemoryExecutor	Runs the expression query in memory.
ExpressionVisitor	Visits nodes of a query expression tree.
ExpState	Expression tree state.
Extensions	Vendor extensions.
Extent<T>	Representation of all members of a persistent class.
Extent<T>	An extent is a logical view of all instances of a class.
ExtentImpl<T>	Representation of all members of a persistent class.
ExtentImpl<T>	An extent is a logical view of all instances of a class.
Externalizer	Declares a method that transforms the field value to its datastore equivalent.
ExternalValues	Maps field values to their datastore equivalents.
Factory	Declares a method that transforms the datastore value to its field equivalent.
FetchAttribute	Includes a persistent attribute in a FetchGroup.
FetchConfiguration	Allows configuration and optimization of how objects are loaded from the data store.
FetchConfigurationImpl	Allows configuration and optimization of how objects are loaded from the data store.
FetchConfigurationImpl.ConfigurationState	Configurable state shared throughout a traversal chain.
FetchDirection	The fetch direction to request when creating statements.
FetchGroup	Captures fetch group meta-data.
FetchGroup	Fetch group definition.
FetchGroups	Fetch groups holder.
FetchJoinObject	Interface used for the result of a fetch join.
FetchMode	Type of fetching to employ.
FetchModeValue	Value type used to represent fetch modes.
FetchPath	Denotes a path used in fetch join.
FetchPlan	The fetch plan allows you to dynamically alter eager fetching configuration and other aspects of data loading.
FetchPlanImpl	Implements FetchPlan via delegation to FetchConfiguration.
FetchStatisticsAuxEnhancer	FetchStatisticsAuxEnhancer adds the call back function to each persistent fields in the persistent entity which will invoke the hit method from FetchStatsCollector whenever the field is fetched at runtime.
FetchStatsCollector	FetchStatsCollector aggregates fetch statistics and outputs the data periodically (10 minutes).
FieldConsumer	Consumes persistent field values.
FieldManager	Manages persistent fields.
FieldMapping	Specialization of metadata for relational databases.
FieldMappingInfo	Information about the mapping from a field to the schema, in raw form.
FieldMetaData	Metadata for a managed class field.
FieldMetaData.MemberProvider	Serializable wrapper around a Method or Field.
FieldStrategy	Maps a persistent field to the relational schema.
FieldSupplier	Supplies persistent field values.
FileMetaDataIterator	Iterator over a file, or over all metadata resources below a given directory.
Files	Utility operations on files.
FileScanner
FileSchemaFactory	Factory that uses an XML schema file to construct the system schema.
FileValue	A File Value.
FillStrategy<T>	A strategy to fill data into a ResultShape.
FillStrategy.Array<T>	Fills an array of given type.
FillStrategy.Assign<T>	Populate an instance by simply assigning the 0-th element of the input values.
FillStrategy.Bean<T>	Create and populate a bean by invoking setter methods identified by alias name with each array element value as argument.
FillStrategy.Factory<T>	Populate an instance created by given factory using a given put(key,value) method.
FillStrategy.Map<T>	Construct and populate an instance by invoking the put method with each alias as key and element of the given array of values.
FillStrategy.NewInstance<T>	Construct and populate an instance by the given constructor and arguments.
FilterIterator<E>	Decorates another Iterator using a predicate to filter elements.
FilterListener	A filter listener extends expression filters with custom functionality.
Filters	Helper methods for dealing with query filters.
FilterValue	The simplified public view of any non-operator in a query filter, including constants, variables, and object fields.
FinalizingBrokerImpl	Subtype of BrokerImpl that automatically closes itself during finalization.
FindCallbacks	Allows facades to control the particulars of the find operation through callbacks.
Finder	Searches for a given class in the set of directories recursively.
FinderCache<K,V,R>	A cache to create and maintain finder queries.
FinderCacheImpl	Implementation of FinderCache for JDBC.
FinderQuery<K,V,R>	A finder query is a query for an instance of a class by its primary key.
FinderQueryImpl	Implements Finder Query identified by ClassMappping for SelectExecutor that can be executed to generate Result.
FinderTargetPolicy	Policy to select one or more of the physical databases referred as slice in which a given finder will be executed.
FirebirdDictionary	Dictionary for Firebird.
FlatClassStrategy	Mapping for classes mapped to their superclass table.
FloatId	OpenJPAId subclass appropriate for float fields.
FlushTransactionListener	Notified on transaction flush.
ForeignKey	Represents a database foreign key; may be a logical key with no database representation.
ForeignKey	Foreign key definition.
ForeignKey.FKMapKey
ForeignKeyAction	Foreign key actions.
FormatPreservingProperties	A specialization of Properties that stores its contents in the same order and with the same formatting as was used to read the contents from an input stream.
FormatPreservingProperties.DuplicateKeyException
FoxProDictionary	Dictionary for Visual FoxPro via DataDirect SequeLink and DataDirect ODBC FoxPro driver.
FullClassStrategy	Mapping for when the class maps all fields to its own table.
GeneralCaseExpression	General case expression.
GeneralException	General exception type.
GeneratedClasses	Utility methods when generating classes, including at runtime.
Generator	Represents a store sequence.
GeneratorImpl	Represents a store sequence.
GenericConfigurable	Implementations of this interface may perform additional generic configuration with any key-value pairs that cannot be set into the object via the normal Options.setInto(java.lang.Object) means.
GenericResultObjectProvider	Object provider implementation wrapped around a generic Result.
GetColumn	Returns the SQL alias of the named column for use in a query.
GitUtils
Graph	Graph representation using the adjacency list form.
GraphicOutputStream	An output stream that uses a ScrollingTextPane as its sink.
GraphVisitor	A helper interface that allows third parties to be notified of graph events during graph traversals
GreaterEqualExpression	Denotes e1 >= e2 Expression.
GreaterThanExpression	Denotes e1 > e2 Expression.
H2Dictionary	Dictionary for H2 ({@link http://www.h2database.com}).
HandlerCollectionTableFieldStrategy	Mapping for a collection of values in a separate table controlled by a ValueHandler.
HandlerFieldStrategy	Mapping for a single-valued field that delegates to a ValueHandler.
HandlerHandlerMapTableFieldStrategy	Mapping for a map of keys and values both controlled by ValueHandlers.
HandlerRelationMapTableFieldStrategy	Mapping for a map whose keys are controlled by a ValueHandler and whose values are relations to other persistent objects.
HandlerStrategies	Utility methods for strategies using value handlers.
HelpMojo	Display help information on openjpa-maven-plugin. Call mvn openjpa:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.
HerdDBDictionary	Dictionary for HerdDB.
HintHandler	Manages query hint keys and handles their values on behalf of a owning QueryImpl.
HintValueConverter	Converts a given user-specified value to a target type consumable by the kernel.
HintValueConverter.EnumToInteger	Convert the enum value to an enumerated set of constants.
HintValueConverter.OpenJPAEnumToInteger	Converts an OpenJPA specific enum to an equivalent kernel constant.
HintValueConverter.StringToBoolean
HintValueConverter.StringToInteger	Converts a String to an integer.
HSQLDictionary	Dictionary for HyperSQL (HSQLDB) database.
HTMLTokenRenderer	Renders Java source tokens as HTML tags.
Id	Datastore identity type.
Identifier	Base interface for identifiers.
IdentifierConfiguration	The IdentifierConfiguration interface.
IdentifierImpl	Base identifer implementation.
IdentifierRule	The standard identifier rule.
IdentifierUtil	Base IdentifierUtil interface.
IdentifierUtilImpl	Implementation class for the base identifier impl.
Images	Utility to load and cache images.
ImmutableValueHandler	Handler for simple type and string values.
ImplHelper	Helper for OpenJPA back-ends.
Index	Represents a database index.
Index	Index definition.
IndexedMap<K,V>	A map with indexed access.
IndexExpression	Denotes INDEX(e) Expression.
IndexOf	Find the index of one string within another.
InExpression	Denotes e1 IN (e2) Expression.
InformixDictionary	Dictionary for Informix database.
IngresDictionary
InheritanceComparator	Comparator that keeps classes in inheritance order.
InMemoryExpressionFactory	Expression factory implementation that can be used to execute queries in memory.
InMemorySavepointManager	A SavepointManager implementation which stores all data in memory.
InstanceDataModel<T>
InstanceResultObjectProvider	Object provider implementation wrapped around a Select.
InstanceView<T>
Instrument	Interface that must be implemented by instruments.
InstrumentationFactory	Factory for obtaining an Instrumentation instance.
InstrumentationLevel	The instrumentation level can be used to indicate if and when an instrument will be automatically started and stopped.
InstrumentationManager	Managers of instrumentation providers must implement this interface.
InstrumentationManagerImpl	An implementation of an instrumentation manager.
InstrumentationProvider	Pluggable instrumentation providers (ex.
InterbaseDictionary	Dictionary for Borland Interbase.
InternalException	Exception type for internal errors.
IntId	OpenJPAId subclass appropriate for int fields.
IntValue	An int Value.
InvalidStateException	Extended IllegalStateException.
InvalidStateException	Exception type thrown when attempting to execute an operation that is not allowed by the current state.
InValueDiscriminatorStrategy	Base discriminator strategy that determines the class of database records using a column holding a value mapped to a class, and limits SELECTs using an IN (...) statement.
Inventory	A mutable persistent entity.
InverseLogical	Declares the logical inverse of a field.
InverseManager	Class which manages inverse relations before flushing to the datastore.
InvocationManagedRuntime	Implementation of the ManagedRuntime interface that uses a static method call to find the TransactionManager.
IOR	String reference of a managed object.
IsEmptyExpression
IsNullExpression	Denotes e IS NULL Expression.
IsolationLevel	Isolation levels for use in JDBCFetchPlan.setIsolation(org.apache.openjpa.persistence.jdbc.IsolationLevel).
IterableMap<K,V>	Defines a map that can be iterated directly without needing to create an entry set.
IterableSortedMap<K,V>	SortedMap + OrderedMap.
IteratorChain<E>	An IteratorChain is an Iterator that wraps a number of Iterators.
J2DoPrivHelper	Helper class to obtain the Privilege(Exception)Action object to perform Java 2 doPrivilege security sensitive function call in the following methods: AccessibleObject.setAccessible Class.forName Class.getClassLoader Class.getDeclaredField Class.getDeclaredFields Class.getDeclaredMethod Class.getDeclaredMethods Class.getProtectionDomain Class.getResource Class.newInstance ClassLoader.getParent ClassLoader.getResource ClassLoader.getResources ClassLoader.getSystemClassLoader File.deleteOnExit File.delete File.exists File.getAbsoluteFile File.getAbsolutePath File.getCanonicalPath File.listFiles File.length File.isDirectory File.mkdirs File.renameTo File.toURL FileInputStream new FileOutputStream new System.getProperties InetAddress.getByName MultiClassLoader new ServerSocket new Socket new Socket.accept System.getProperty Thread.getContextClassLoader Thread.setContextClassLoader Thread new TemporaryClassLoader new URL.openStream URLConnection.getContent ZipFile new AnnotatedElement.getAnnotations AnnotatedElement.getDeclaredAnnotations AnnotatedElement.isAnnotationPresent jakarta.validation.Validator.validate jakarta.validation.Validation.buildDefaultValidatorFactory If these methods are used, the following sample usage patterns should be followed to ensure proper privilege is granted:
JarFileURLMetaDataIterator	Iterator over all metadata resources in a given resource addressed by a jar:file URL.
Java2HTMLConverter
Java2HTMLConverterTask	An ant task to run Java2HTML Converter.
Java2HTMLConverterTask.Arg
Java2TextConverter	Converts Java Source code to plain text with optional line number.
JavaCharStream	An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (with java-like unicode escape processing).
JavaLexer
JavaParser	A Java 1.5 grammar for ANTLR v3 derived from the spec This is a very close representation of the spec; the changes are comestic (remove left recursion) and also fixes (the spec isn't exactly perfect).
JavaSQLTypes	Java SQL type constants.
JavaTypes	Type constants for managed fields.
JavaVendors	Utilities for dealing with different Java vendors.
JavaVersions	Utilities for dealing with different Java specification versions.
JDataStoreDictionary	Dictionary for Borland JDataStore
JDBC3SavepointManager	SavepointManager implementation that uses JDBC 3 savepoints to store state.
JDBCAggregateListener	JDBC extension to the AggregateListener.
JDBCBrokerFactory	BrokerFactory type for use with the JDBC runtime.
JDBCConfiguration	Configuration that defines the properties necessary to configure runtime and connect to a JDBC DataSource.
JDBCConfigurationImpl	Default implementation of the JDBCConfiguration interface.
JDBCEvent	A JDBC event.
JDBCEventConnectionDecorator	Manages the firing of JDBCEvents.
JDBCExpressionFactory	Expression factory implementation that can be used to execute queries via SQL.
JDBCFetchConfiguration	JDBC extensions to OpenJPA's FetchConfiguration.
JDBCFetchConfigurationImpl	JDBC extensions to OpenJPA's FetchConfiguration.
JDBCFetchConfigurationImpl.JDBCConfigurationState	Configurable JDBC state shared throughout a traversal chain.
JDBCFetchPlan	JDBC extensions to the fetch plan.
JDBCFetchPlanImpl	JDBC extensions to the fetch plan.
JDBCFilterListener	JDBC extension to the FilterListener.
JDBCListener	A listener for all JDBCEvents that occur.
JDBCLockManager	Extension of the LockManager interface with methods for datastore locking during the select and load process.
JDBCPersistenceProductDerivation	Sets JDBC-specific JPA specification defaults.
JDBCProductDerivation	Sets JDBC as default store.
JDBCSeq	Specialization of the the Seq interface to provide information on the schema needed by this sequence.
JDBCSeqValue	Adds additional aliases to base SeqValue.
JDBCStore	Represents the JDBC store.
JDBCStoreManager	StoreManager plugin that uses JDBC to store persistent data in a relational data store.
JDBCStoreManager.ClientConnection	Connection returned to client code.
JDBCStoreQuery	JDBC query implementation.
JDBCStringContains	Deprecated. Use matches() instead.
JDBCWildcardMatch	Deprecated. Use matches() instead.
JESTCommand	Interface for JEST commands.
JESTCommand.Format	Supported format monikers.
JESTContext	An operational context combines a persistence context and a HTTP execution context expressed as a request and response.
JESTServlet	A specialized HTTP servlet to interpret HTTP requests as Java Persistent API commands on a running persistence unit.
JJTJPQLState
JMSRemoteCommitProvider	JMS-based implementation of RemoteCommitProvider that listens for object modifications and propagates those changes to other RemoteCommitProviders over a JMS topic.
JMXInstrument	Interface for JMX-specific instruments
JMXProvider	A simple MBean JMX instrumentation provider
JNDIManagedRuntime	Implementation of the ManagedRuntime interface that uses JNDI to find the TransactionManager.
Join	Represents a SQL join.
Joinable	Represents a value that can be joined to.
JoinPath	Path resulting by joining from a parent path via an attribute.
Joins	Tracks joins made when traversing relations in a select.
JoinSyntax	Type of join syntax to use.
JoinSyntaxes	Constants for ways of describing joins in SQL.
JPAFacadeHelper	Helper class for switching between OpenJPA's JPA facade and the underlying Broker kernel.
JPAProperties	Enumerates configuration property keys defined in JPA 2.0 Specification.
JPAServletContext	An operating context provides a persistence context and utility functions within which all JEST commands execute.
JPQL
JPQLConstants	Token literal values and constants.
JPQLExpressionBuilder	Builder for JPQL expressions.
JPQLExpressionBuilder.JPQLNode	Base node that will be generated by the JPQLExpressionBuilder; base class of the SimpleNode that is used by JPQL.
JPQLExpressionBuilder.ParsedJPQL	Public for unit testing purposes.
JPQLHelper	Utility for converting elements to JPQL string fragments.
JPQLParser	Parser for JPQL queries.
JPQLTokenManager	Token Manager.
JPQLTreeConstants
JSON	A generic interface for a JSON encoded instance.
JSON	A generic interface for a JSON encoded instance.
JSONObject	A JSON instance for persistence.
JSONObject	A JSON instance for persistence.
JSONObject.Array	An array of objects.
JSONObject.Array	An array of objects.
JSONObject.KVMap	A map whose key or value can be JSON.
JSONObject.KVMap	A map whose key or value can be JSON.
JSONObjectFormatter	Marshals a root instance and its persistent closure as JSON object.
JSPUtility	A set of static utilities used by the Java Server Pages.
JULLogFactory
KeyClassCriteria	Marker interface specifying to use the expected class of the map key relation as criteria in the join.
KeyColumn	Map key column.
KeyColumns	Allows the specification of multiple map key columns for complex mappings.
KeyDependent	Dependent map key marker.
KeyEmbeddedMapping	Embedded mapping information for a map key.
KeyExpression	Denotes KEY(e) Expression.
KeyForeignKey	Foreign key on map key columns.
KeyIndex	Index on map key columns.
KeyJoinColumn	Map key join column.
KeyJoinColumns	Allows the specification of multiple map key columns for compound joins.
KeyNonpolymorphic	Indicates that the annotated map's keys are not entirely polymorphic.
KeyStrategy	Map key mapping strategy.
KeyType	Indicates the persistent key type of a map field, if different than the declared type.
KeyValue<K,V>	Defines a simple key value pair.
KubernetesTCPRemoteCommitProvider
LazyForwardResultList	Lazy forward-only result list.
LazySchemaFactory	Factory that uses database metadata to construct the system schema.
LengthExpression	Denotes LENGTH(e) Expression.
LessEqualExpression	Denotes e1 <= e2 Expression.
LessThanExpression	Denotes e1 < e2 Expression.
LifecycleCallbacks	A lifecycle listener that responds to callbacks rather than events.
LifecycleEvent	Lifecycle event on a persistent instance.
LifecycleEventManager	Manager that can be used to track and notify listeners on lifecycle events.
LifecycleEventManager.ListenerAdapter	Interface that facades to other lifecycle listener interfaces can implement to choose which events to respond to based on their delegate.
LifecycleEventManager.ListenerList	Extended list that tracks what event types its elements care about.
LifecycleListener	Interface for listening to all LifecycleEvents.
LifecycleMetaData	Information about lifecycle events for a managed type.
LikeExpression	Denotes e1 LIKE e2 Expression.
LineItem	An immutable persistent entity with complex primary key.
LineItem.LineItemId	Separate identity class.
LinkedMap<K,V>	A Map implementation that maintains the order of the entries.
ListIteratorWrapper<E>	Converts an Iterator into a ResettableListIterator.
ListResultList	A basic ResultList implementation that wraps a normal list.
ListResultObjectProvider	A result object provider wrapped around a normal list.
Lit	A literal value in a filter.
Literal	Interface for any literal value.
LiteralExpression	Denotes a Literal Expression.
LoadFetchGroup	Fetch group loaded when the annotated field/property is loaded.
LoadListener	Listener for when state is loaded into a persistent instnace.
LobFieldStrategy	Direct mapping from a stream value to a column.
LocalConstraint	Constraint over local table columns, as opposed to a foreign key which spans tables.
Localizer	The Localizer provides convenient access to localized strings.
Localizer.Message	A Message can provide a localized message via the Localizer.Message.getMessage() method call, and can also provide the original key, package, and substitution array that were used to assemble the message.
LocateExpression	Denotes LOCATE(e1, e2, n) Expression.
Location
LockException	Exception indicating that locks on one or more objects could not be acquired.
LockLevels	Standard object lock levels.
LockManager	Handles obtaining and releasing locks on objects.
LockScopes	Defines lock scope levels used for MixedLockManager.
LockScopesHelper	Helper methods translate between JPA-defined pessimistic lock scope and OpenJPA internal lock scope levels.
LockTimeoutException	Pessimistic lock timeout violation.
Log	Logging interface that is independent of other logging frameworks.
Log4J2LogFactory	LogFactory implementation that delegates to the Log4J-2.x framework.
Log4J2LogFactory.LogAdapter	Adapts a Log4J2 logger to the Log interface.
Log4JLogFactory	LogFactory implementation that delegates to the Log4J 1.x framework.
Log4JLogFactory.LogAdapter	Adapts a Log4J logger to the Log interface.
LogFactory	Factory for log instances.
LogFactoryAdapter	Base type that aids in adapting an external log framework to the LogFactory.
LogFactoryImpl	Default LogFactory implementation.
LoggingConnectionDecorator	A ConnectionDecorator that creates logging connections and ReportingSQLExceptions.
LoggingConnectionDecorator.SQLWarningHandler	Interface that allows customization of what to do when SQLWarnings occur.
LogicalPredicate	Logical Predicate combines two predicates with a logical operator.
LogicalUnion	A logical union made up of multiple distinct selects whose results are combined in memory.
LogicalUnion.Selector	A callback used to create the selects in a SQL union.
LogOrphanedKeyAction	Log a message when an orphaned key is discovered.
LogOutputStream	Many standard components log to OutputStreams.
LongId	OpenJPAId subclass appropriate for long fields.
LowerExpression	Denotes LOWER(e) Expression.
LRS	Large result set field marker.
LRSCollectionFieldStrategy	Interface implemented by collection strategies so that they can support large result set collections.
LRSMapFieldStrategy	Interface implemented by map strategies so that they can support large result set maps.
LRSProxy	Marker interface for large result set proxies.
LRSProxyCollection	Large result set collection.
LRSSizeAlgorithm	Algorithm to use for computing the size of an LRS relation.
LRSSizes	Ways of calculating the size of large result sets.
LRUMap<K,V>	A Map implementation with a fixed maximum size which removes the least recently used entry if an entry is added when full.
LRUMap	Extension of the commons LRUMap that can change its maximum size.
Main
Main	A very simple, stand-alone program that stores a new entity in the database and then performs a query to retrieve it.
Main	A very simple, stand-alone program that stores a new entity in the database and then performs a query to retrieve it.
Main	A simple program that uses the reverse-mapped classes from the airlines schema to print out a list of schedules flightes and the projected profits from them.
ManagedClassSubclasser	Redefines the method bodies of existing unenhanced classes to make them notify state managers of mutations.
ManagedInstanceProvider	Instances of this interface can provide an underlying instance.
ManagedInterface	The annotated interface should be treated as a managed interface by OpenJPA.
ManagedRuntime	This interface must be implemented by concrete plugins to application servers in order to integrate the OpenJPA runtime in a managed environment.
MapBackedSet<E,V>
MapChangeTracker	Change tracker that can be used for maps.
MapChangeTrackerImpl	Default MapChangeTracker.
MapConfigurationProvider	Simple configuration provider that sets configuration based on a provided map.
MapEntry	Returns the Map.Entry of a map value.
MapEntry.EntryExpState	Expression state.
MapIterator<K,V>	Defines an iterator that operates over a Map.
MapKey	Returns the key of a map value.
MapKey.KeyExpState	Expression state.
MappingDefaults	Generates default names for tables, columns, indexes, constraints, etc.
MappingDefaultsImpl	Default implementation of MappingDefaults.
MappingFactoryValue	Handles the complex logic of creating a MetaDataFactory for combined metadata and mapping.
MappingInfo	Base class storing raw mapping information; defines utility methods for converting raw mapping information to full mapping to the schema.
MappingInfo.ForeignKeyDefaults	Supplies default foreign key information.
MappingInfo.TableDefaults	Supplies default table information.
MappingOverride	Allows override of complex embedded or superclass mappings.
MappingOverrides	Allows override of complex embedded or superclass mappings.
MappingRepository	Repository of object/relational mapping information.
MappingRepositoryValue	Handles the complex logic of creating a MappingRepository for a given configuration.
MappingStrategyInstaller	Installer used during mapping that attempts to use the given mapping information (if any), and fails if it does not work.
MappingTool	Tool for manipulating class mappings and associated schema.
MappingTool.Flags	Run flags.
MappingTool.ImportExport	Helper used to import and export mapping data.
MappingToolTask	Executes the MappingTool on the specified files.
MappingToolTask.Action
MappingToolTask.SchemaAction
MapTableFieldStrategy	Base class for map mappings.
MariaDBDictionary
Math	Value produced by a mathematical operation on two values.
MaxDBDictionary	Database dictionary for using SAP's MaxDB.
MaxEmbeddedBlobFieldStrategy	Mapping for serialized fields on a dictionary that has a maximum embedded BLOB size.
MaxEmbeddedByteArrayFieldStrategy	Mapping for byte array fields on a dictionary that has a maximum embedded BLOB size.
MaxEmbeddedCharArrayFieldStrategy	Mapping for CLOB character array on a dictionary that has a maximum embedded CLOB size.
MaxEmbeddedClobFieldStrategy	Mapping for CLOB string on a dictionary that has a maximum embedded CLOB size.
MaxExpression	Denotes MAX(e) Expression.
Maze
MemberOfExpression	Denotes e1 MEMBER OF e2 Expression.
Members	Persistent attribute according to JPA 2.0 metamodel.
Members.CollectionAttributeImpl<X,E>	Represents attributes declared as java.util.Collection<E>.
Members.KeyAttributeImpl<X,K>	Represents the keys of java.util.Map<K,V> in managed type <X> as a pseudo-attribute of type java.util.Set<K>.
Members.ListAttributeImpl<X,E>	Represents attributes declared as java.util.List<E>.
Members.MapAttributeImpl<X,K,V>	Represents attributes declared as java.util.Map<K,V> in managed type <X>.
Members.Member<X,Y>	An attribute of a Java type.
Members.PluralAttributeImpl<X,C,E>	Root of multi-cardinality attribute.
Members.SetAttributeImpl<X,E>	Represents attributes declared as java.util.Set<E>.
Members.SingularAttributeImpl<X,T>	Represents single-valued persistent attributes.
MergedResult	Result that merges multiple result delegates.
MergedResult.ResultComparator	Comparator for ordering result rows.
MergedResultObjectProvider	A result object provider that merges multiple result object provider delegates.
Message	A very simple persistent entity that holds a "message", has a "created" field that is initialized to the time at which the object was created, and an id field that is initialized to the current time.
MetaDataCacheMaintenance	Performs maintenance tasks on the metadata caches accessible via the CacheMarshaller architecture.
MetaDataContext	Allows us to access configuration through metadata in a generic way.
MetaDataDefaults	Populates new metadata with default values.
MetaDataException	Exception type reserved for missing or invalid metadata.
MetaDataFactory	The MetaDataRepository uses implementations of this interface to load and store metadata.
MetaDataFilter	Filters metadata resources.
MetaDataFilter.Resource	Information about a metadata resource.
MetaDataInheritanceComparator	Comparator that keeps metadatas in inheritance order.
MetaDataIterator	Iterator over metadata resources.
MetaDataIteratorChain	Metadata iterator that combines several iterators.
MetaDataModes	Mode constants used to track the initialization status of metadata.
MetaDataParser	Interface for metadata parsers.
MetaDataPlusMappingFactory	Combines two internal MetaDataFactory instances -- one for metadata, one for mappings -- into a single MetaDataFactory facade.
MetadataProcessor<T,M>	Collection of generic utility functions for extracting persistence related metadata from user specified metadata available in various source environment.
MetaDataRepository	Repository of and factory for persistent metadata.
MetaDataRepositoryValue	A PluginValue that interacts with the CacheMarshaller to cache the metadata repository between executions.
MetaDataSerializer	Interface for meta data serializers.
MetaDataTag	Set of metadata tags used in JPA.
MetaDataTool	Tool for generating default metadata.
MetaDataTool.Flags	Run flags.
MetaDataToolTask	Executes the metadata tool on the specified files.
MetaDataToolTask.Action
MetamodelHelper	Static utility for analyzing persistent metadata model using JPA 2.0.
MetamodelHelper
MetamodelHelper.AttributeCategory	Attribute Category makes a finer distinction over PersistentAttributeType declared in Attribute.PersistentAttributeType such as id, version, lob or enum.
MetamodelHelper.AttributeComparator	Compares attribute by their qualification.
MetamodelHelper.AttributeComparator	Compares attribute by their category and within the same category by name.
MetamodelHelper.EntityComparator	Compares EntityType by their dependency of derived targets.
MetamodelImpl	Adapts JPA Metamodel to OpenJPA meta-data repository.
MetamodelView	Graphical View of a JPA 2.0 Metamodel.
MethodLifecycleCallbacks	Callback adapter that invokes a callback method via reflection.
MethodStoreQuery	A query that is executed by a user-defined method.
MinExpression	Denotes MIN(e) Expression.
MinusExpression	Denotes (e1 - e2) Expression.
MixedLockLevels	Defines lock levels used for MixedLockManager.
MixedLockLevelsHelper	Helper methods translate between JPA-defined lock mode and OpenJPA internal lock levels.
MixedLockManager	Mixed lock manager implements both optimistic and pessimistic locking semantics in parallel to the JPA 2.0 specification.
MultiClassLoader	Class loader type that can be configured to delegate to multiple internal class loaders.
MultiColumnVersionStrategy	Uses multiple version numbers spanning multiple columns for optimistic versioning.
MultiLoaderClassResolver	A simple ClassResolver that uses multiple class loaders to resolve classes.
MultiLogFactory	A LogFactory implementation to pass events through multiple LogFactory implementations(such as log4j and LogPanelFactory).
MultiQueryMetaData	Extends QueryMetaData to allow multiple result class or mapping names.
MultiQueryMetaData.Parameter	A parameter
MultiQueryMetaData.Parameter.Mode
MySQLDictionary	Dictionary for MySQL.
NameSet	Name sets track what names have been taken, ignoring case.
NanoPrecisionTimestampVersionStrategy	Uses a timestamp for optimistic versioning with nanosecond precision.
NativeJDBCSeq	JDBCSeq implementation that uses a database sequence to generate numbers.
NewInstance	Denotes NEW fully.qualified.class.name(arg1, arg2,...)
Node
NoneClassStrategy	Strategy for classes that aren't mapped.
NoneDiscriminatorStrategy	No-op Discriminator strategy.
NoneFieldStrategy	An unmapped field.
NoneLockManager	A lock manager that does not perform any locking.
NoneLogFactory	A log factory implementation that does not do any logging, as quickly as possible.
NoneLogFactory.NoneLog	No-op log.
NoneMappingDefaults	No-op mapping defaults.
NoneMetaDataFactory	No-op metadata I/O to prevent attempts to load other classes.
NoneOrphanedKeyAction	Does nothing when an orphaned key is discovered.
NoneStrategyInstaller	Clears all mapping information from classes and installs none strategies.
NoneVersionStrategy	No-op version strategy.
NonPersistentMetaData	Metadata about a persistence-aware type.
Nonpolymorphic	Indicates that the annotated relation is not entirely polymorphic.
NonpolymorphicType	Nonpolymorphic settings.
NonUniqueResultException	Unique query returned multipl results.
NonUniqueResultException	Exception type thrown when a query was configured to return a single result, and multiple results were found.
NoOpCacheMarshaller	Implementation of CacheMarshaller that does nothing.
NoResultException	Unique query returned no results.
NoResultException	Exception type thrown when a query was configured to return a single result, and no result was found.
Normalizer	Static utility class used for operating on string based identifiers.
NotEqualExpression	Denotes (e1 !
NoTransactionException	Exception type thrown when attempting a transactional operation without an active transaction.
Null	A literal null value in a filter.
NullableAggregateUnaryOp	OPENJPA-1794 An aggregate unary operation that can indicate whether a null value from the data store should be returned as null.
NullIf	An in-memory representation of a nullif expression
NullIfExpression	NullIf expression.
NumberVersionStrategy	Uses a version number for optimistic versioning.
ObjectData	In-memory form of data in datastore backing a single persistent object.
ObjectExistsException	Exception type reserved for conflicts with existing objects.
ObjectFactory<T>	An interface to create objects that are used by result processing.
ObjectFormatter<T>	A parameterized interface defines the protocol for converting managed persistence instances or a persistent domain model into a form suitable for transport to a language-neutral client such as an web browser.
ObjectId	Identity type appropriate for object primary key fields and shared id classes.
ObjectIdClassStrategy	Class mapping for embedded object id fields.
ObjectIdStateManager	State manager used to access state of embedded object id primary key fields.
ObjectIdValueHandler	Handler for embedded object id fields.
ObjectNotFoundException	Exception type reserved for failed object lookups.
ObjectValue	An object Value.
OpCallbacks	Allows facades to control the particulars of persistence operations through callbacks.
OpenBookService	A simple service to select Books, purchase them and manage their inventory.
OpenJPAConfiguration	Defines the properties necessary to configure runtime properties and connect to a data source.
OpenJPAConfigurationImpl	Implementation of the OpenJPAConfiguration interface.
OpenJPACriteriaBuilder	OpenJPA-specific extension to JPA 2.0 Criteria Query Builder API.
OpenJPACriteriaQuery<T>	OpenJPA-specific extension to JPA 2.0 Criteria Query API.
OpenJPADirectoriesEnhancer
OpenJpaEnhancerMojo	Processes Application model classes and enhances them by running OpenJPA Enhancer tool.
OpenJPAEntityManager	Interface implemented by OpenJPA entity managers.
OpenJPAEntityManagerFactory	Interface implemented by OpenJPA entity manager factories.
OpenJPAEntityManagerFactorySPI
OpenJPAEntityManagerSPI
OpenJPAEntityTransaction	Extension of the JPA EntityTransaction interface.
OpenJPAEnum<E extends java.lang.Enum<?>>	An interface to define conversion of a facade based enum to a kernel integer constant.
OpenJPAException	Exception type for all OpenJPA exceptions.
OpenJPAExtension
OpenJPAId	Identity class extended by built-in OpenJPA identity objects.
OpenJPAPersistence	Static helper methods for JPA users.
OpenJPAPersistenceUtil
OpenJPAProductDerivation	Adds datastore based extension to ProductDerivation.
OpenJPAQuery<X>	Interface implemented by OpenJPA queries.
OpenJPAQueryBuilder	Builds dynamic query
OpenJPAQuerySPI<X>
OpenJPASavepoint	Represents a savepoint where operations afterwards can be rolled back and restored to this point
OpenJpaSchemaMojo	Executes the schema generation via the OpenJPA MappingTool.
OpenJpaSqlMojo	Executes the SQL generation via the OpenJPA MappingTool.
OpenJPAStateManager	Interface implemented by OpenJPA state managers.
OpenJPASupport	Enables in place enhancement for entities listed or found by scanning in test classpath.
OpenJpaTestEnhancerMojo	Processes Application model test classes and enhances them by running OpenJPA Enhancer tool.
OpenJPAVersion	This class contains version information for OpenJPA.
OpenJPAVersionAndConfigurationTypeValidationPolicy	Compute validity based on whether or not the cached data is from the same version of Kodo as the current install.
OperationOrderUpdateManager	Update manager that writes SQL in object-level operation order.
OperatorPath	A path resulting from KEY() or VALUE() operation on an existing path.
OptimisticException	Exception type for optimistic concurrency violations.
OptimisticLockException	Optimistic concurrency violation.
Options	A specialization of the Properties map type with the added abilities to read application options from the command line and to use bean patterns to set an object's properties via command-line the stored mappings.
OracleDictionary	Dictionary for Oracle.
Order	Order a field.
OrderableItem	Denotes an item of ORDER BY clause.
OrderBy
OrderByItem	Instances of this interface can be used as orderBy arguments.
OrderColumn	Surrogate order column.
OrderedBidiMap<K,V>	Defines a map that allows bidirectional lookup between key and values and retains and provides access to an ordering.
OrderedIterator<E>	Defines an iterator that operates over an ordered container.
OrderedMap<K,V>	Defines a map that maintains order and allows both forward and backward iteration through that order.
OrderedMap<K,V>	A Map with predictable iteration order.
OrderedMapIterator<K,V>	Defines an iterator that operates over an ordered Map.
OrderingMergedResultObjectProvider	Merged result object provider specialization that extracts ordering values from results for comparison.
OrphanedKeyAction	Perform an action when OpenJPA detects an orphaned key in the database.
OrPredicate	Denotes (e1 OR e2) predicate.
OSGiManagedRuntime	Implementation of the ManagedRuntime interface that listens for an OSGi service with interface jakarta.transaction.TransactionManager to create a TransactionManager for controlling transactions.
PagingResultObjectProvider	Object provider implementation that fetches one page of results at a a time as it scrolls.
Param	A parameter in a filter.
Param.ParamExpState	Expression state.
Parameter	A query parameter.
ParameterExpression	Denotes a parameter in a query.
ParameterImpl<T>	A user-defined parameter of a query.
ParameterTemplate	A template that allows parameter substitutions.
ParseException	Signifies that a lexical error occurred when parsing the JPQL statement.
ParseException	Exception type for parse errors.
ParseTokenListener	A token processor to render the ANTLR tokens.
PartitionedDataCache	A partitioned data cache maintains a set of partitions that are DataCache themselves.
Path	A path represents a traversal into fields of a candidate object.
PathExpression	Interface for operations over objects reached via paths
PathFinder	A* Algorithm to find rectilinear path through a Maze.
PathOperator	Operator that combines two components to form a path.
PCClassFileTransformer	Transformer that makes persistent classes implement the PersistenceCapable interface at runtime.
PCClassFileTransformer.Reentrant
PCData	Holds data about a single persistence capable instance.
PCDataGenerator	Generates PCData instances which avoid primitive wrappers to optimize memory use and performance at the cost of slightly higher startup time.
PCDataGenerator.DynamicPCData	Dynamic PCDatas generated will implement this interface to simplify initialization.
PCDataImpl	Default PCData implementation.
PCEnhancer	Bytecode enhancer used to enhance persistent classes from metadata.
PCEnhancer.AuxiliaryEnhancer	Plugin interface for additional enhancement.
PCEnhancer.Flags	Run flags.
PCEnhancerAgent	Java agent that makes persistent classes work with OpenJPA at runtime.
PCEnhancerTask	Executes the enhancer on the specified files.
PCPath	A path represents a traversal into fields of a candidate object.
PCPath.PathExpState	Expression state.
PCRegistry	Tracks registered persistence-capable classes.
PCRegistry.RegisterClassListener	Listener for persistent class registration events.
PCResultObjectProvider	Variant of ResultObjectProvider that populates a OpenJPAStateManager object in an application-defined manner.
PCState	Base class for all lifecycle states.
PCSubclassValidator	Validates that a given type meets the JPA contract, plus a few OpenJPA-specific additions for subclassing / redefinition: must have an accessible no-args constructor must be a public or protected class must not be final must not extend an enhanced class all persistent data represented by accessible setter/getter methods (persistent properties) if versioning is to be used, exactly one persistent property for the numeric version data When using property access, the backing field for a persistent property must be: private set only in the designated setter, in the constructor, or in Object.clone(), readObject(ObjectInputStream), or Externalizable.readExternal(ObjectInput). read only in the designated getter and the constructor.
PersistenceActivator	Used to discover/resolve JPA providers in an OSGi environment.
PersistenceCapable	The interface that persistent instances will implement.
PersistenceException	General persistence exception.
PersistenceExceptions	Converts from OpenJPA to persistence exception types.
PersistenceMappingDefaults	Supplies default mapping information in accordance with JPA spec.
PersistenceMappingFactory	MetaDataFactory for JPA mapping information.
PersistenceMetaDataDefaults	JPA-based metadata defaults.
PersistenceMetaDataFactory	MetaDataFactory for JPA metadata.
PersistenceProductDerivation	Sets JPA specification defaults and parses JPA specification XML files.
PersistenceProductDerivation.ConfigurationParser	SAX handler capable of parsing an JPA persistence.xml file.
PersistenceProductDerivation.ConfigurationProviderImpl	Custom configuration provider.
PersistenceProviderImpl	Bootstrapping class that allows the creation of a stand-alone EntityManager.
PersistenceStrategy	Set of field persistence strategies used in JPA.
PersistenceUnitInfoImpl	Implementation of the PersistenceUnitInfo interface used by OpenJPA when parsing persistence configuration information.
PersistenceUnitInfoImpl.ClassResolverImpl	Simple class resolver built around the persistence unit loader.
Persistent	Metadata annotation for a persistent field.
PersistentCollection	Metadata annotation for a persistent collection field.
PersistentMap	Metadata annotation for a persistent map field.
PersistListener	Listener for newly-persisted instances.
PessimisticLockException	Pessimistic concurrency violation.
PessimisticLockManager	Lock manager that uses exclusive database locks.
Phone
PlainTokenRenderer	A default implementation of TokenRenderer that simply prints the token.
PluginListValue	A list of plugins.
PluginValue	A plugin Value consisting of plugin name and properties.
PlusExpression	Denotes (e1 + e2) Expression.
PNonTransDeletedState	Lifecycle state.
PointbaseDictionary	Dictionary for Pointbase Embedded.
PostDeleteListener
PostgresDictionary	Dictionary for PostgreSQL.
PostgresDictionary.PostgresConnection	Connection wrapper to work around the postgres empty result set bug.
PostgresDictionary.PostgresPreparedStatement	Statement wrapper to work around the postgres empty result set bug.
PostPersistListener
PowerPointViewer	Displays and navigates PowerPoint slides.
Predicate	Interface used to define compound predicates.
PredicateOperand	Interface for constructing where-clause and having-clause conditions.
PreparedQuery	A prepared query associates a compiled query to a parsed state that can be executed possibly with more efficiency.
PreparedQueryCache	A cache to create and maintain prepared queries.
PreparedQueryCache.Exclusion	A structure to describe the strength and reason for excluding a query from the cache.
PreparedQueryCacheImpl	An implementation of the cache of prepared queries.
PreparedQueryCacheImpl.StrongExclusion	Strong exclusion.
PreparedQueryCacheImpl.WeakExclusion	Weak exclusion.
PreparedQueryCacheInstrument
PreparedQueryCacheJMXInstrument	A JMX-specific instrument for the query cache
PreparedQueryCacheJMXInstrumentMBean
PreparedQueryImpl	Implements PreparedQuery for SQL queries.
PreparedQueryViewer	A specialized table to display statistics of queries.
PreparedResultObjectProvider	A Select-oriented Result Object Provider whose Select has been executed outside its own scope.
PreparedSQLStoreQuery	A executor for Prepared SQL Query.
PreparedSQLStoreQuery.PreparedSQLExecutor	Executor of a prepared query uses the QueryExpressions of the original query available via the PreparedQuery.
PreparedStatementManager	Manages prepared statement execution.
PreparedStatementManagerImpl	Basic prepared statement manager implementation.
PrimaryKey	Represents a table primary key.
PrimaryRow	Primary table row that tracks foreign keys and auto-inc columns.
PrimitiveFieldStrategy	Direct mapping from a primitive value to a column.
ProcessingException	Specialized RuntimException thrown by JEST commands.
ProductDerivation	Hooks for deriving products with additional functionality.
ProductDerivation	Derives configuration for Slice.
ProductDerivations	Utilities for running product derivations.
PropertiesCommand	Represents configuration properties in HTML.
PropertiesReverseCustomizer	Simple ReverseCustomizer that uses a properties file to to allow customization of basic class and field properties.
PropertyHelper	A set of static utility functions to read properties from file, manage properties with multi-part keys, array style properties etc.
PrototypeFactory<K,T>	A factory for a specific type of objects registered by a key.
Proxies	Utility methods for managing proxies.
Proxy	Interface implemented by all proxy types to allow setting and nulling of their owning instance.
ProxyBean	Interface implemented by all generated custom types, which use JavaBean conventions for copying state.
ProxyCalendar	Interface implemented by all generated proxies on Calendar types.
ProxyCollection	Interface implemented by all proxy collection types.
ProxyCollections	Utility methods used by collection proxies.
ProxyCollections.ProxyIterator	Marker interface for a proxied iterator.
ProxyCollections.ProxyListIterator	Marker interface for a proxied list iterator.
ProxyDate	Interface implemented by all generated proxies on Date types.
ProxyManager	Manager for copying and proxying second class objects.
ProxyManagerImpl	Default implementation of the ProxyManager interface.
ProxyMap	Interface implemented by proxies on Map types.
ProxyMaps	Utility methods used by map proxies.
ProxyMaps.ProxyEntrySet	Marker interface for a proxy entry set.
PurchaseOrder	A persistent entity to demonstrate Master in a Master-Details or Composite pattern for persistent domain model.
PurchaseOrder.Status	Enumerates the status of a Purchase Order.
QualifiedDBIdentifier	This class extends DBIdentifier to provide support for qualified identifiers such as schema qualified tables and table qualified columns.
Query	OpenJPA query interface.
QueryBuilder	Factory interface for query definition objects
QueryBuilderImpl	The factory for QueryDefinition.
QueryCache	Interface that must be implemented by any level 2 query cache used by OpenJPA.
QueryCacheInstrument	Interface for providing instrumented data cache metrics and operations.
QueryCacheJMXInstrument	A JMX-specific instrument for the query cache
QueryCacheJMXInstrumentMBean	Simple MBean interface for providing instrumented query cache metrics and operations.
QueryCacheStoreQuery	A StoreQuery implementation that caches the OIDs involved in the query, and can determine whether or not the query has been dirtied.
QueryCacheStoreQuery.CachedList	Result list implementation for a cached query result.
QueryCompilationCacheValue	A cache of compiled queries.
QueryContext	A query execution context.
QueryDecorator	Decorates an executable query.
QueryDecorator	Decorates an executable query.
QueryDefinition	Interface for construction of query definitions
QueryDefinitionImpl	Implements QueryDefinition.
QueryException	Exception indicating that a query timeout occurred.
QueryExpressions	Struct to hold the state of a parsed expression query.
QueryExpressionsState	Struct to hold the state of a query expressions instance.
QueryFlushModes	Constants for determining when to flush before queries.
QueryHints	Standard query hint keys.
QueryImpl	Implementation of the Query interface.
QueryImpl<X>	Implementation of Query interface.
QueryImpl.Compilation	Struct of compiled query properties.
QueryImpl.PackingResultObjectProvider	Result object provider that packs results before returning them.
QueryKey	This class stores information about a particular invocation of a query.
QueryLanguages	Constants and utilities for query languages.
QueryMetaData	Holds metadata about named queries.
QueryOperations	Query operation constants.
QueryOperationType	The possible operations that a query can perform.
QueryParameterBinder	Decorates a query by binding parameters.
QueryResult	A query result.
QueryResultCache	Query result cache.
QueryResultCacheImpl	Implements Query result cache via delegation to QueryCache.
QueryResultCallback	A callabck is used when a query results in multiple non-identical result sets.
QueryResultMapping	Mapping of a query result set to scalar and/or persistence-capable object-level values.
QueryStatistics<T>	Records query execution statistics.
QueryStatistics.Default<T>	A default implementation.
QueryStatistics.None<T>	A do-nothing implementation.
QueryTargetPolicy	Policy to select one or more of the physical databases referred as slice in which a given query will be executed.
QueryTimeoutException	Query timeout violation.
RandomAccessResultList	Random-access result list implementation.
Randomizer	A set of static utility functions for simulating pseudo-randomness.
Range<N extends java.lang.Number>	A simple numeric range.
RangeExpression	Denotes a range used by e1 BETWEEN x AND y operation.
RangeResultObjectProvider	Prevents a view of a given range of indices from the delegate result object provider.
Raw	Represents a raw SQL string for passing to Row.setObject.
ReadOnly	Marks a field read-only.
RedefinedAttribute	Custom Attribute to mark that this class already got redefined.
RedefinitionHelper	Helper methods for managed types that use method redefinition for field tracking.
ReentrantSliceLock	A reentrant lock that lets a child to work with the parent's lock.
ReferenceHashMap	Map in which the key, value, or both may be weak/soft references.
ReferenceHashSet	A set whose values may be stored as weak or soft references.
ReferenceIdentityMap<K,V>	A Map implementation that allows mappings to be removed by the garbage collector and matches keys and values based on == not equals().
ReferenceMap<K,V>	A Map implementation that allows mappings to be removed by the garbage collector.
ReferenceMap	A Map type that can hold its keys, values, or both with weak or soft references.
ReferentialIntegrityException	Exception type reserved for violations of integrity constraints.
Reflectable	Annotates a getter method or field so reflection utility to control whether the annotated member is recorded during scanning for bean-style method or field.
ReflectingPersistenceCapable	Implementation of the PersistenceCapable interface that can handle the persistence-capable contract for instances that were not enhanced before class load time.
Reflection	Reflection utilities used to support and augment enhancement.
RefreshStrategyInstaller	Attempts to install using the given mapping information.
RegistryManagedRuntime	Implementation of the ManagedRuntime interface that uses the TransactionSynchronizationRegistry interface (new in JTA 1.1) to create a TransactionManager facade for controlling transactions.
RelationCollectionInverseKeyFieldStrategy	Maps a relation to a collection of other objects using an inverse foreign key in the related object table.
RelationCollectionTableFieldStrategy	Maps a collection of related objects through an association table.
RelationFieldStrategy	Mapping for a single-valued relation to another entity.
RelationHandlerMapTableFieldStrategy	Mapping for a map whose keys are relations to other persistent objects and whose values are controlled by a ValueHandler.
RelationId	Callback to store a relation after the object id has been assigned.
RelationMapInverseKeyFieldStrategy	Uses an inverse foreign key in the table of the map value to determine map values.
RelationMapTableFieldStrategy	Uses an association table to hold map values.
RelationRelationMapTableFieldStrategy	Mapping for a map whose keys and values are both relations to other persistent objects.
RelationStrategies	Helper methods for relation mappings.
RelationToManyInverseKeyFieldStrategy	Maps a relation to a set of other objects using an inverse foreign key in the related object table.
RelationToManyTableFieldStrategy	Maps a set of related objects through an association table.
RemoteCommitEvent	Event type to hold the IDs of additions, updates, and deletes.
RemoteCommitEventManager	Manager that can be used to track and notify RemoteCommitListeners on remote commit events.
RemoteCommitListener	An entity that wishes to be notified when Brokers associated with remote BrokerFactories commit.
RemoteCommitProvider	An entity that is responsible for communicating commit notification to other RemoteCommitEventManagers.
RemoteCommitProviderValue	Value type used to represent a RemoteCommitProvider.
ReplicationPolicy	Policy to select one or more of the physical databases referred as slice in which a given persistent instance will be persisted.
ReplicationPolicy.Default	Implements a default replication policy to replicate the given instance across all available slices.
ReportingSQLException	A SQLException that contains information about the Statement SQL that caused the exception.
ReservedWords	Utility to test validity of identifier or parameter name.
ResettableIterator<E>	Defines an iterator that can be reset back to an initial state.
ResettableListIterator<E>	Defines a list iterator that can be reset back to an initial state.
Resolver	A Resolver is used to resolve listeners and class or entity names that appear in a query.
ResourceMetaDataIterator	Iterator over a given metadata resource.
RestoreState	State restore constants.
RestoreStateType	The possible settings for the restore behavior after transaction rollback of an OpenJPAEntityManager.
Result	A result from the execution of a query or stored procedure.
ResultList<E>	List interface that represents a potentially lazy ResultList instantiation.
ResultListIterator	Wrapper iterator that will return false for hasNext() if the owning ResultList has been closed.
ResultObjectProvider	Interface that allows lazy/custom instantiation of input objects.
ResultObjectProviderIterator	Iterator wrapped around a ResultObjectProvider.
ResultPacker	Helper class to pack results into the result class set on the query.
ResultSetResult	Base Result implementation wrapped around a result set.
ResultSetType	Type of result set to use.
ResultShape<T>	Describes the shape of a query result.
ResultShapePacker	Packs result by delegation to a ResultShape.
ReverseCustomizer	Plugin in interface to customize the output of the ReverseMappingTool.
ReverseMappingTool	Reverse-maps a schema into class mappings and the associated java code.
ReverseMappingTool.Flags	Holder for run flags.
ReverseMappingToolTask	Executes the ReverseMappingTool on the specified XML files.
ReverseMappingToolTask.AccessType
ReverseMappingToolTask.Level
RollbackException	Rollback occurred on attempt to commit.
RootPath	Denotes root domain instance representing a persistent type.
RoundButton	A Circular Swing Button.
Row	Logical representation of a table row for insert/update/delete.
RowImpl	Basic Row implementation.
RowManager	Manages rows during an insert/update/delete process.
RowManagerImpl	Manages SQL rows during an insert/update/delete process.
RuntimeExceptionTranslator	Interface used by many facade helpers to translate exceptions.
RuntimeStrategyInstaller	Installer that attempts to use the given mapping information, and fails if it does not work.
RuntimeUnenhancedClassesModes	Possible values for the openjpa.RuntimeUnenhancedClasses configuration setting.
SaveFieldManager	FieldManager type used to store information for rollback.
SavepointManager	A manager for handling savepoints.
Schema	Represents a database schema.
SchemaFactory	Factory for SchemaGroups.
SchemaGenerationAction
SchemaGenerationSource
SchemaGenerator	The SchemaGenerator creates Schemas matching the current database.
SchemaGenerator.Event	An event corresponding to the generation of a schema object.
SchemaGenerator.Listener	A listener for a potentially lengthy schema generation process.
SchemaGroup	Represents a grouping of schemas used in a database.
SchemaParser	Interface class for parers that read schema information.
Schemas	Helper class to deal with schemas.
SchemaSerializer	Interface for schema serializers.
SchemaTool	The SchemaTool is used to manage the database schema.
SchemaTool.Flags	Run flags.
SchemaToolTask	Executes the SchemaTool on the specified XML schema definition files.
SchemaToolTask.Action
ScrollingTextPane	A TextPane where text that scrolls as new text is appended.
SecondaryRow	Secondary table row that tracks foreign keys to auto-inc columns.
Select	Abstraction of a SQL SELECT statement.
SelectConstructor	Turns parsed queries into selects.
SelectExecutor	Interface for configuring and executing a SQL select.
SelectImpl	Standard Select implementation.
SelectImpl.SelectResult	A Result implementation wrapped around this select.
SelectImpl.Selects	Helper class to track selected columns, with fast contains method.
SelectItem	SelectItem instances are used in specifying the query's select list.
SelectResultObjectProvider	Abstract provider implementation wrapped around a Select.
Seq	Internal OpenJPA sequence interface.
Sequence	Represents a database sequence.
SequenceMapping	Specialization of sequence metadata for ORM.
SequenceMetaData	Metadata about a named sequence.
SequenceMetaData.SequenceFactory	Allow facades to supply adapters from a spec sequence type to the OpenJPA sequence type.
SeqValue	Value type used to represent a sequence.
Serialization	Helper class to serialize and deserialize persistent objects, subtituting oids into the serialized stream and subtituting the persistent objects back during deserialization.
Serialization.ClassResolvingObjectInputStream
Serialization.PersistentObjectInputStream	Object input stream that replaces oids with their objects.
Serialization.PersistentObjectOutputStream	Object output stream that replaces persistent objects with their oids.
ServiceFactory	A container of persistence units.
Services	Utility classes to locate services, as defined in the Jar File Specification.
ShoppingCart	A non-persistent entity holds the content of a shopping session for a Customer.
ShortId	OpenJPAId subclass appropriate for short fields.
SimpleCase	An in-memory representation of a simple case expression
SimpleCaseExpression	Simple case expression.
SimpleDriverDataSource	Non-pooling driver data source.
SimpleNode	Base node implementation for all JPQL nodes.
SimpleRegex	Allows for simple regex style testing of strings.
SimpleResultList	An almost stateless ResultList designed for use with result object providers backed by efficient random-access data structures, such as the ListResultObjectProvider.
SingleJVMRemoteCommitProvider	Single-JVM-only implementation of RemoteCommitProvider that listens for object modifications and propagates those changes to other SingleJVMRemoteCommitProviders in the same JVM.
Sized	A sized value.
SizedMap	A Map type that maintains a maximum size, automatically removing entries when the maximum is exceeded.
SizeExpression	Denotes SIZE(e) Expression.
SLF4JLogFactory	LogFactory implementation that delegates to the SLF4J framework.
SLF4JLogFactory.LogAdapter	Adapts a Log4J logger to the Log interface.
Slice	Represents a database slice of immutable logical name, a configuration and status.
Slice.Status
SliceImplHelper	Utility methods to determine the target slices for a persistence capable instance by calling back to user-specified distribution policy.
SliceInfo	Holder of slice names where a persistent instance is stored.
SlicePersistence	A helper to determine the slice identifier of an instance.
SliceStoreManager	A specialized JDBCStoreManager for a slice.
SliceThread	A thread to execute operation against each database slice.
SoftRandomAccessResultList	Specialization of the RandomAccessResultList that only maintains soft references to instantiated objects.
SolidDBDictionary	Dictionary for SolidDB database.
SortedBidiMap<K,V>	Defines a map that allows bidirectional lookup between key and values and retains both keys and values in sorted order.
SourceAnnotationHandler	Extracts persistent metadata information by analyzing available annotation in *.java source files.
SourceCode	A utility to help writing Java Source code dynamically.
SourceCode.ACCESS
SourceCodeBrowser	Browses source code.
SourceCodeViewer	An internal viewer for HTML formatted source code.
SourceRenderer	Renders Java Source Code.
SourceTracker	Interface that can optionally be implemented by metadata to include the source file from which the metadata was originally parsed.
SourceTrackers	Utility class for performing common operations on SourceTrackers.
Specification	An immutable representation of a Specification supported by OpenJPA.
SpecificationPlugin	A plug-in for Specification that enforces certain overwriting rules.
SQLBuffer	Buffer for SQL statements that can be used to create java.sql.PreparedStatements.
SQLEmbed	Simple listener which embeds its SQL argument into the query.
SQLErrorCodeReader	Parses XML content of SQL Error State codes to populate error codes for a given Database Dictionary.
SQLExceptions	Helper class for converting a SQLException into the appropriate OpenJPA type.
SQLExpression	Deprecated. Use SQLEmbed directly
SQLFactory	Factory for SQL constructs.
SQLFactoryImpl	Default factory for SQL abstraction constructs.
SQLFormatter	Converts single-line SQL strings into nicely-formatted multi-line, indented statements.
SQLLogger	Logs SQL statement to a graphic console.
SQLServerDictionary	Dictionary for Microsoft SQL Server.
SQLStoreQuery	A SQL query.
SQLStoreQuery.SQLExecutor	Executes the filter as a SQL query.
SQLValue	Deprecated. Use SQLEmbed directly
Sqrt	Square root.
SquareRootExpression	Denotes SQRT(e) Expression.
StateComparisonVersionStrategy	Uses a state image to determine whether concurrency violations take place.
StateComparisonVersionStrategy.CustomUpdate	Row implementation we use to pass to versionable mappings so they can set up the where conditions we need to add to update statements.
StateManager	Internal state manager for managed instances.
StateManagerImpl	Implementation of the OpenJPAStateManager interface for use with this runtime.
StatusBar
StoreCache	Represents the L2 cache over the data store.
StoreCacheImpl	Implements the L2 cache over the data store via delegation to DataCache.
StoreCollectionFieldStrategy	Base class for strategies that are stored as a collection, even if their field value is something else.
StoreContext	Represents a set of managed objects and their environment.
StoredProcedure	Holds metadata about a Database Stored Procedure.
StoredProcedure.PARAM	An enumeration on type of parameter for a Stored Procedure.
StoredProcedure.SQL
StoredProcedureQuery	Executes a stored procedure.
StoredProcedureQueryImpl	Implements Store Procedure based query for JPA facade.
StoreException	Base exception for data store errors.
StoreFacadeTypeRegistry	Repository of store-specific facade classes.
StoreListener	Listener for when persistent instances are stored to the database.
StoreManager	Interface to be implemented by data store mechanisms to interact with this runtime.
StoreQuery	Component that executes queries against the datastore.
StoreQuery.Executor	An executor provides a uniform interface to the mechanism for executing either an in-memory or datastore query.
StoreQuery.Range	A query result range.
Strategy	Interface implemented by all mapping strategies.
Strategy	Mapping strategy.
StrategyInstaller	Installs mapping strategies.
StringContains	Deprecated. Use matches() instead.
StringDistance	Utilities for calculating string distance.
StringFieldStrategy	Direct mapping from a string value to a column.
StringId	OpenJPAId subclass appropriate for String fields.
StringLength	Returns the number of characters in a string.
StringListValue	A comma-separated list of string values.
StringUtil
StringValue	A string Value.
SubclassFetchMode	Determines how to eager-fetch subclass data.
SubclassJoinDiscriminatorStrategy	Discriminator strategy that outer joins to all possible subclass tables to determine the class of an instance.
SubQ	A subquery.
Subquery	Query value representing a subquery.
Subquery	Instances of this interface can be used as subqueries.
Substring	Take a substring of a string.
SubStringExpression	Denotes SUBSTR(a,i1,i2) Expression.
SuffixMetaDataFilter	Filters metadata iteration based on resource name suffix.
SumExpression	Denotes SUM(e) Expression.
SunOneManagedRuntime	ManagedRuntime implementation for SunONE.
SuperclassDiscriminatorStrategy	Discriminator strategy that delegates to superclass discriminator.
SuperclassVersionStrategy	Version strategy that delegates to the suerpclass version.
SupplyPage	A page to view and supply low inventory items.
SwingHelper	Assorted utility methods.
SybaseDictionary	Dictionary for Sybase.
SybaseDictionary.SybaseConnection	Connection wrapper to cache the Connection.getCatalog() result, which takes a very long time with the Sybase Connection (and which we frequently invoke).
Table	Represents a database table.
TableJDBCSeq	JDBCSeq implementation that uses a database table for sequence number generation.
TableJDBCSeq.Status	Helper struct to hold status information.
TableSchemaFactory	Factory that uses an XML schema definition stored in a database table to record the system schema.
TargetFetchConfiguration	A fetch configuration that is aware of special hint to narrow its operation on subset of slices.
TCPRemoteCommitProvider	TCP-based implementation of RemoteCommitProvider that listens for object modifications and propagates those changes to other RemoteCommitProviders over TCP sockets.
TemporaryClassLoader	ClassLoader implementation that allows classes to be temporarily loaded and then thrown away.
TextProcessingUtility
TextStyles
TimeSeededSeq	A simplistic implementation of a Seq used to provide datastore ids.
TimesExpression	Denotes (e1*e2) Expression.
TimestampHelper	Helper base class attempts to return java.sql.Timestamp object with nanosecond precision.
TimestampVersionStrategy	Uses a timestamp for optimistic versioning.
Token	Describes the input token stream.
TokenMgrError	Token Manager Error.
TokenRenderer	Renders a runtime ANTLR token.
TokenReplacedStream	Reads from an input stream and writes to an output stream after replacing matched tokens by their counterpart.
TokenReplacedStream.Pattern
ToLowerCase	Lower-cases a string.
ToUpperCase	Upper-cases a string.
TransactionEvent	A transactional event.
TransactionEventManager	Manager that can be used to track and notify transaction listeners of transaction-related events.
TransactionListener	Interface for listening to all TransactionEvents.
TransactionRequiredException	Transaction required.
TraversableResolverImpl	OpenJPA optimized TraversableResolver Default implementation/behavior asks all discovered providers - jakarta.persistence.Persistence.getPersistenceUtil().isLoaded( traversableObject, traversableProperty.getName());
TreeBidiMap<K extends java.lang.Comparable<K>,V extends java.lang.Comparable<V>>	Red-Black tree-based implementation of BidiMap where all objects added implement the Comparable interface.
Trim	Returns the number of characters in a string.
TrimExpression	Denotes TRIM(e1,x) Expression.
TrimSpec	Used to specify the trimming of strings
TupleFactory	A factory for tuples such that all instances created by a factory instance share the same TupleElements to save memory consumption.
TupleImpl	Tuple holds a set of values corresponding to a set of TupleElement.
Type	Indicates the persistent type of a field, if different than the declared type.
TypeBasedCacheDistributionPolicy	A cache distribution policy based on the type of the managed objects.
TypedProperties	A specialization of the Properties map type with added convenience methods to retrieve and set options as primitive values.
TypeExpression	Denotes TYPE(e) Expression.
TypeLit	A type literal value.
Types	Persistent Type according to JPA 2.0.
Types.Basic<X>	Basic non-relational types of a persistent attribute such as long or java.util.Date.
Types.Embeddable<X>	An embedded, not independently identifiable type.
Types.Entity<X>	An entity type that is independently identifiable.
Types.Identifiable<X>	Represents an abstract persistent type that has a persistent identity.
Types.MappedSuper<X>	A abstract, independently identifiable persistent type.
Types.PseudoEntity<X>	A pseudo managed type used to represent keys of a java.util.Map as a pseudo attribute.
TypesChangedEvent	An event indicating that instances of given persistent types have been modified.
TypesChangedListener	An entity that wishes to be notified when types change.
UnaryConditionalOperator	Enumeration of operator that operates on a single expression to generate a predicate.
UnaryFunctionalOperator	Enumeration of operator that operates on a single expression to generate another expression.
UnaryMinusExpression	Denotes (-e) Expression.
UnaryOperator	Enumeration of Operator that operate on a single expression.
Union	SQL UNION.
Union.Selector	A callback used to create the selects in a SQL union.
Unique	Represents a unique constraint.
Unique	Unique constraint definition.
UniqueResultObjectProvider	Aggregates individual single query results from different databases.
Unmodifiable	Marker interface for collections, maps and iterators that are unmodifiable.
UnmodifiableCollection<E>	Decorates another Collection to ensure it can't be altered.
UnmodifiableEntrySet<K,V>	Decorates a map entry Set to ensure it can't be altered.
UnmodifiableIterator<E>	Decorates an iterator such that it cannot be modified.
UnmodifiableList<E>	Decorates another List to ensure it can't be altered.
UnmodifiableListIterator<E>	Decorates a list iterator such that it cannot be modified.
UnmodifiableMapEntry<K,V>	A Map.Entry that throws UnsupportedOperationException when setValue is called.
UnmodifiableOrderedMap<K,V>	Decorates another OrderedMap to ensure it can't be altered.
UnmodifiableOrderedMapIterator<K,V>	Decorates an ordered map iterator such that it cannot be modified.
UnmodifiableSet<E>	Decorates another Set to ensure it can't be altered.
UnsupportedException	Exception type for attempts to perform unsupported operations.
UntypedPCValueHandler	Handler for unknown persistence-capable object fields that stores stringified oids.
UpdateAction	Action to take when a field's value is changed.
UpdateListener
UpdateManager	This interface is used to customize the way that updates are made to database records.
UpdateStrategies	Strategies for persistent value updates.
UpperExpression	Denotes UPPER(e) Expression.
URIUtils
URLMetaDataIterator	Iterator over the metadata resource represented by a URL.
User
UserException	Base exception type for user errors.
UUIDGenerator	UUID value generator.
UUIDHexSeq	Sequence for generating 32-character hex UUID strings.
UUIDStringSeq	Sequence for generating 16-character UUID strings.
UUIDType4HexSeq	Sequence for generating 32-character hex Type 4 UUID strings.
UUIDType4StringSeq	Sequence for generating 16-character UUID strings.
Val	A Value represents any non-operator in a query filter, including constants, variables, and object fields.
Val	An in-memory representation of a Value.
ValidatingErrorHandler	ErrorHandler implementation which overrides the default behavior of ignoring parse errors to throw a SAXException instead.
ValidatingLifecycleEventManager	An extension of LifecycleEventManager which adds validation capabilities for specific lifecycle events.
ValidationException
ValidationUnavailableException
ValidationUtils	Validation helper routines and wrappers to remove runtime dependencies on the Bean Valdiation APIs or a implementation.
Validator	Basic validation interface which defines the contract for event based validation.
ValidatorImpl
Value	Interface for any non-operator in a query filter, including constants, variables, and object fields.
Value	A configuration value.
ValueExpression	Denotes VALUE(e) Expression.
ValueHandler	Maps a value to a relational schema.
ValueListener	Components can listen on Value objects for changes directly.
ValueMapDiscriminatorStrategy	Maps metadata-given values to classes.
ValueMapping	Specialization of value metadata for relational databases.
ValueMappingImpl	Standalone ValueMapping implementation.
ValueMappingInfo	Information about the mapping from a field value to the schema, in raw form.
ValueMetaData	Holds metadata on a value; this could be a field value, key value, or element value.
ValueMetaDataImpl	Default ValueMetaData implementation.
ValueStrategies	Strategies for persistent value generation.
ValueTableJDBCSeq	Specialization of the TableJDBCSeq that maintains multiple sequence counts.
VarArgsExpression	A expression that holds an array of Expressions.
Version	Handles optimistic lock versioning for a class.
VersionColumn	Surrogate version column.
VersionColumns	Allows the specification of multiple version columns for complex versioning.
VersionLockManager	LockManager implementation that provides support for version checking and version updating when locks are acquired.
VersionMappingInfo	Information about the mapping from a version indicator to the schema, in raw form.
VersionStrategy	Handles optimistic lock versioning for a class.
VersionStrategy	Version mapping strategy.
VerticalClassStrategy	Mapping for subclasses that join to their superclass table.
Visitable	An element of query that is convertible to a JPQL String given a aliasing scheme.
WASManagedRuntime	ManagedRuntime implementation that allows synchronization with a WebSphere managed transaction.
WASRegistryManagedRuntime	WASRegistryManagedRuntime provides WebSphere specific extensions to RegistryManagedRuntime.
WhenClause	Denotes WHEN ...
WhenCondition	Value produced by a when_clause of a case expression.
WhenCondition
WhenScalar	Value produced by a when_clause of a case expression.
WhenScalar
WildcardMatch	Deprecated. Use matches() instead.
WindowResultList	ResultList implementation that uses a forward-scrolling window of results.
WLSManagedRuntime	ManagedRuntime implementation that directly accesses the transaction manager via WebLogic Server helper classes.
WrappedException	Identifiable exception type which wraps an internal runtime exception.
XEmbeddedMapping	Embedded mapping information.
XJoinColumn	Extended join column.
XJoinColumns	Allows the specification of multiple columns for compound joins.
XMappingOverride	Allows override of complex embedded or superclass mappings.
XMappingOverrides	Allows override of complex embedded or superclass mappings.
XMLClassMetaData
XMLConfiguration	Configuration implementation for the XML file store.
XMLFactory	The XMLFactory produces validating and non-validating DOM level 2 and SAX level 2 parsers and XSL transformers through JAXP.
XMLFieldMetaData	Contains metadata about an xml element or attribute
XMLFileHandler	Stores ObjectData objects by serializing a collection of them into and out of an XML file.
XMLFormatter	Marshals a root instance and its persistent closure as an XML element.
XMLMetaData	Describe metadata about an xml type.
XMLMetaDataParser	Custom SAX parser used by the system to quickly parse metadata files.
XMLMetaDataSerializer	Abstract base type for serlializers that transfer groups of objects to XML.
XMLPersistenceMappingParser	Custom SAX parser used by the system to parse persistence mapping files.
XMLPersistenceMappingSerializer	Serializes persistence mapping to XML.
XMLPersistenceMetaDataParser	Custom SAX parser used by the system to quickly parse persistence metadata files.
XMLPersistenceMetaDataParser.localDBIdentifiers
XMLPersistenceMetaDataSerializer	Serializes persistence metadata back to XML.
XMLSchemaParser	Custom SAX parser used to parse Schema objects.
XMLSchemaParser.UniqueInfo	Used to hold unique constraint info before it is resolved.
XMLSchemaSerializer	Serializes Schemas to XML matching the document type definition defined by the XMLSchemaParser.
XMLStore	Represents a store of object data encoded in XML.
XMLStoreManager	Store manager to a back-end consisting of XML files.
XMLValueHandler	Base class for xml value handlers.
XMLVersionParser	Custom non-validating SAX parser which can be used to get the version and schema location attributes from the root node.
XMLWriter	The XMLWriter is a writer type for pretty-printing XML.
XROP	Gets multiple Result Object Providers each with different mapping.
XSecondaryTable	Extended secondary table.
XSecondaryTables	Allows the specification of multiple secondary tables.
XTable	Extended table.
ZipFileMetaDataIterator	Iterator over all metadata resources in a given zip file.
ZipStreamMetaDataIterator	Iterator over all metadata resources in a given zip input stream.