All Classes

Class	Description
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.
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.
AbstractExpressionBuilder	Abstract base class to help build expressions.
AbstractExpressionVisitor	No-op abstract visitor meant for easy extension.
AbstractLifecycleListener	Abstract implementation of the LifecycleListener interface which delegates events to a single method.
AbstractLockManager	Abstract LockManager implementation.
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
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.
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.
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.
AbstractRemoteCommitProvider	Abstract implementation of RemoteCommitProvider.
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.
AbstractTransactionListener	Abstract implementation of the TransactionListener interface that provides no-op implementations of all methods.
AbstractValidator	Abstract validation class which provides base validation methods.
AccessCode	Represents access styles for members of a class and field through a 5-bit integer.
AggregateListener	An aggregate listener aggregates data produced by an ExpressionQuery.
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.
Arguments	Multiple arguments to a function call.
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.
AttributeTranslator	Instances of this interface can convert a positional index for a FieldMetaData that uses property access into the underlying field name.
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.
AutoClear	State clearing constants.
AutoDetach	Bit flags for when to automatically detach the entire persistence context.
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.
BCClassWriter
BeanLifecycleCallbacks	Performs a callback method on a cached bean instance.
BeginTransactionListener	Notified when transactions begin.
BigDecimalId
BigIntegerId
BlacklistClassResolver
BooleanId	OpenJPAId subclass appropriate for boolean fields.
Bootstrap	Helper methods for acquiring BrokerFactory objects
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.
BytecodeWriter	Control how enhanced bytecode is written.
ByteId	OpenJPAId subclass appropriate for byte fields.
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.
CallbackException	Exception type thrown when an error occurs in a callback.
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.
ChangeTracker	Interface for components that track changes to containers at a fine-grained level.
CharId	OpenJPAId subclass appropriate for char fields.
ClassLoaderProxyService	Service to load classes dynamically at runtime.
ClassMetaData	Contains metadata about a persistent type.
ClassNodeTracker	Helper class to transit from BCClass to ASM
ClassRedefiner	Redefines the method bodies of existing classes.
ClassResolver	Interface to customize the loading of classes under OpenJPA.
ClassResolverImpl	Default class resolver implementation.
ClassWriterTracker	Helper to keep track of generated methods when using ASM ClassWriter.
ClearableScheduler	Cron-style clearable eviction.
ClearListener	Listener for when persistent state is cleared from an instance.
Coalesce	An in-memory representation of a coalesce expression
CodeGenerator	Generates Java class code from metadata.
CollectionChangeTracker	Change tracker that can be used for collections.
CollectionChangeTrackerImpl	Default CollectionChangeTracker.
Compatibility	Struct encompassing backwards-compatibility options.
ConcurrentDataCache	A DataCache implementation that is optimized for concurrent access.
ConcurrentQueryCache	A QueryCache implementation that is optimized for concurrent access.
ConnectionRetainModes	Connection retain mode constants.
Constant	Interface for any query constant value.
Context	JPQL / Criteria Query Context
DataCache	Interface that must be implemented by any level 2 cache used by OpenJPA.
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
DateId	OpenJPAId subclass appropriate for Date fields.
DefaultCacheDistributionPolicy	A default implementation that selects the cache by the type of the given managed instance.
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.
DelegatingDataCache	Delegating data cache that can also perform exception translation for use in facades.
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.
DelegatingMetaDataFactory	Base class for factory instances that use a delegate.
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.
DelegatingSeq	Delegating sequence that can also perform exception translation for use in facades.
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.
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.
DirtyListener	Listener for when a persistent instance becomes dirty.
DistinctResultList<E>	An immutable list that imposes uniqueness on its member.
DoubleId	OpenJPAId subclass appropriate for double fields.
DynamicPersistenceCapable	Instances that implement this marker interface are dynamically-generated subtypes of managed types that were loaded before being enhanced.
DynamicStorage	Interface for dynamically generated classes.
DynamicStorageGenerator	Factory for creating new DynamicStorage classes.
DynamicTCPRemoteCommitProvider
EndTransactionListener	Notified when transactions end.
EnhancementClassLoader	A special ClassLoader to handle classes currently under bytecode enhancement.
EnhancementProject	Keep track of classes under enhancement.
ExceptionInfo	Interface supplying additional exception information.
ExceptionOrphanedKeyAction	Throw a ObjectNotFoundException when an orphaned key is discovered.
Exceptions	Utility methods for externalizing and handling exceptions.
Exp	An in-memory representation of an Expression.
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.
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.
Extensions	Vendor extensions.
Extent<T>	Representation of all members of a persistent class.
ExtentImpl<T>	Representation of all members of a persistent class.
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.
FetchGroup	Captures fetch group meta-data.
FieldConsumer	Consumes persistent field values.
FieldManager	Manages persistent fields.
FieldMetaData	Metadata for a managed class field.
FieldMetaData.MemberProvider	Serializable wrapper around a Method or Field.
FieldSupplier	Supplies persistent field values.
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.
FilterListener	A filter listener extends expression filters with custom functionality.
Filters	Helper methods for dealing with query filters.
FinalizingBrokerImpl	Subtype of BrokerImpl that automatically closes itself during finalization.
FindCallbacks	Allows facades to control the particulars of the find operation through callbacks.
FinderCache<K,V,R>	A cache to create and maintain finder queries.
FinderQuery<K,V,R>	A finder query is a query for an instance of a class by its primary key.
FloatId	OpenJPAId subclass appropriate for float fields.
FlushTransactionListener	Notified on transaction flush.
GeneralException	General exception type.
GeneratedClasses	Utility methods when generating classes, including at runtime.
Id	Datastore identity type.
ImplHelper	Helper for OpenJPA back-ends.
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.
InstrumentationFactory	Factory for obtaining an Instrumentation instance.
InstrumentationManager	Managers of instrumentation providers must implement this interface.
InstrumentationManagerImpl	An implementation of an instrumentation manager.
InternalException	Exception type for internal errors.
IntId	OpenJPAId subclass appropriate for int fields.
InvalidStateException	Exception type thrown when attempting to execute an operation that is not allowed by the current state.
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.
JavaCharStream	An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (with java-like unicode escape processing).
JavaTypes	Type constants for managed fields.
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.
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.
JPQLParser	Parser for JPQL queries.
JPQLTokenManager	Token Manager.
JPQLTreeConstants
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.
Literal	Interface for any literal value.
LoadListener	Listener for when state is loaded into a persistent instnace.
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.
LogOrphanedKeyAction	Log a message when an orphaned key is discovered.
LongId	OpenJPAId subclass appropriate for long fields.
LRSProxy	Marker interface for large result set proxies.
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.
ManagedRuntime	This interface must be implemented by concrete plugins to application servers in order to integrate the OpenJPA runtime in a managed environment.
MapChangeTracker	Change tracker that can be used for maps.
MapChangeTrackerImpl	Default MapChangeTracker.
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.
MetaDataInheritanceComparator	Comparator that keeps metadatas in inheritance order.
MetaDataModes	Mode constants used to track the initialization status of metadata.
MetaDataRepository	Repository of and factory for persistent metadata.
MetaDataRepositoryValue	A PluginValue that interacts with the CacheMarshaller to cache the metadata repository between executions.
MetaDataTool	Tool for generating default metadata.
MetaDataTool.Flags	Run flags.
MetaDataToolTask	Executes the metadata tool on the specified files.
MetaDataToolTask.Action
MethodLifecycleCallbacks	Callback adapter that invokes a callback method via reflection.
MethodStoreQuery	A query that is executed by a user-defined method.
MixedLockLevels	Defines lock levels used for MixedLockManager.
MultiLoaderClassResolver	A simple ClassResolver that uses multiple class loaders to resolve classes.
MultiQueryMetaData	Extends QueryMetaData to allow multiple result class or mapping names.
MultiQueryMetaData.Parameter	A parameter
MultiQueryMetaData.Parameter.Mode
Node
NoneLockManager	A lock manager that does not perform any locking.
NoneMetaDataFactory	No-op metadata I/O to prevent attempts to load other classes.
NoneOrphanedKeyAction	Does nothing when an orphaned key is discovered.
NonPersistentMetaData	Metadata about a persistence-aware type.
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	Exception type thrown when a query was configured to return a single result, and no result was found.
NoTransactionException	Exception type thrown when attempting a transactional operation without an active transaction.
NullIf	An in-memory representation of a nullif expression
ObjectExistsException	Exception type reserved for conflicts with existing objects.
ObjectFactory<T>	An interface to create objects that are used by result processing.
ObjectId	Identity type appropriate for object primary key fields and shared id classes.
ObjectIdStateManager	State manager used to access state of embedded object id primary key fields.
ObjectNotFoundException	Exception type reserved for failed object lookups.
OpCallbacks	Allows facades to control the particulars of persistence operations through callbacks.
OpenJPAConfiguration	Defines the properties necessary to configure runtime properties and connect to a data source.
OpenJPAConfigurationImpl	Implementation of the OpenJPAConfiguration interface.
OpenJPAException	Exception type for all OpenJPA exceptions.
OpenJPAId	Identity class extended by built-in OpenJPA identity objects.
OpenJPAProductDerivation	Adds datastore based extension to ProductDerivation.
OpenJPASavepoint	Represents a savepoint where operations afterwards can be rolled back and restored to this point
OpenJPAStateManager	Interface implemented by OpenJPA state managers.
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.
OptimisticException	Exception type for optimistic concurrency violations.
Order	Order a field.
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.
OSGiManagedRuntime	Implementation of the ManagedRuntime interface that listens for an OSGi service with interface jakarta.transaction.TransactionManager to create a TransactionManager for controlling transactions.
Parameter	A query parameter.
ParseException	Signifies that a lexical error occurred when parsing the JPQL statement.
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.
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.
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.
PersistenceCapable	The interface that persistent instances will implement.
PersistListener	Listener for newly-persisted instances.
PNonTransDeletedState	Lifecycle state.
PostDeleteListener
PostPersistListener
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.
PreparedQueryCacheInstrument
PreparedQueryCacheJMXInstrument	A JMX-specific instrument for the query cache
PreparedQueryCacheJMXInstrumentMBean
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.
Query	OpenJPA query interface.
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.
QueryException	Exception indicating that a query timeout occurred.
QueryExpressions	Struct to hold the state of a parsed expression query.
QueryFlushModes	Constants for determining when to flush before queries.
QueryHints	Standard query hint keys.
QueryImpl	Implementation of the 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.
QueryResult	A query result.
QueryResultCallback	A callabck is used when a query results in multiple non-identical result sets.
QueryStatistics<T>	Records query execution statistics.
QueryStatistics.Default<T>	A default implementation.
QueryStatistics.None<T>	A do-nothing implementation.
RedefinedAttribute	Custom Attribute to mark that this class already got redefined.
RedefinitionHelper	Helper methods for managed types that use method redefinition for field tracking.
ReferentialIntegrityException	Exception type reserved for violations of integrity constraints.
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.
RegistryManagedRuntime	Implementation of the ManagedRuntime interface that uses the TransactionSynchronizationRegistry interface (new in JTA 1.1) to create a TransactionManager facade for controlling transactions.
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.
Resolver	A Resolver is used to resolve listeners and class or entity names that appear in a query.
RestoreState	State restore constants.
ResultPacker	Helper class to pack results into the result class set on the query.
ResultShape<T>	Describes the shape of a query result.
ResultShapePacker	Packs result by delegation to a ResultShape.
RuntimeExceptionTranslator	Interface used by many facade helpers to translate exceptions.
RuntimeUnenhancedClassesModes	Possible values for the openjpa.RuntimeUnenhancedClasses configuration setting.
SaveFieldManager	FieldManager type used to store information for rollback.
SavepointManager	A manager for handling savepoints.
SchemaGenerationAction
SchemaGenerationSource
Seq	Internal OpenJPA sequence interface.
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.
ShortId	OpenJPAId subclass appropriate for short fields.
SimpleCase	An in-memory representation of a simple case expression
SimpleNode	Base node implementation for all JPQL nodes.
SingleJVMRemoteCommitProvider	Single-JVM-only implementation of RemoteCommitProvider that listens for object modifications and propagates those changes to other SingleJVMRemoteCommitProviders in the same JVM.
Specification	An immutable representation of a Specification supported by OpenJPA.
SpecificationPlugin	A plug-in for Specification that enforces certain overwriting rules.
StateManager	Internal state manager for managed instances.
StateManagerImpl	Implementation of the OpenJPAStateManager interface for use with this runtime.
StoreContext	Represents a set of managed objects and their environment.
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.
StringContains	Deprecated. Use matches() instead.
StringId	OpenJPAId subclass appropriate for String fields.
Subquery	Query value representing a subquery.
SunOneManagedRuntime	ManagedRuntime implementation for SunONE.
TCPRemoteCommitProvider	TCP-based implementation of RemoteCommitProvider that listens for object modifications and propagates those changes to other RemoteCommitProviders over TCP sockets.
TimeSeededSeq	A simplistic implementation of a Seq used to provide datastore ids.
Token	Describes the input token stream.
TokenMgrError	Token Manager Error.
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.
TypeBasedCacheDistributionPolicy	A cache distribution policy based on the type of the managed objects.
TypesChangedEvent	An event indicating that instances of given persistent types have been modified.
TypesChangedListener	An entity that wishes to be notified when types change.
UnsupportedException	Exception type for attempts to perform unsupported operations.
UpdateListener
UpdateStrategies	Strategies for persistent value updates.
UserException	Base exception type for user errors.
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	An in-memory representation of a Value.
ValidatingLifecycleEventManager	An extension of LifecycleEventManager which adds validation capabilities for specific lifecycle events.
ValidationException
ValidationUnavailableException
Validator	Basic validation interface which defines the contract for event based validation.
Value	Interface for any non-operator in a query filter, including constants, variables, and object fields.
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.
VersionLockManager	LockManager implementation that provides support for version checking and version updating when locks are acquired.
WASManagedRuntime	ManagedRuntime implementation that allows synchronization with a WebSphere managed transaction.
WASRegistryManagedRuntime	WASRegistryManagedRuntime provides WebSphere specific extensions to RegistryManagedRuntime.
WhenCondition
WhenScalar
WildcardMatch	Deprecated. Use matches() instead.
WLSManagedRuntime	ManagedRuntime implementation that directly accesses the transaction manager via WebLogic Server helper classes.
WrappedException	Identifiable exception type which wraps an internal runtime exception.
XMLClassMetaData
XMLFieldMetaData	Contains metadata about an xml element or attribute
XMLMetaData	Describe metadata about an xml type.