|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
BrokerFactory
that must be subclassed for a specific runtime.DataCache implementation that provides various
statistics, logging, and timeout functionality common across cache
implementations.FieldManager for easy subclassing.LifecycleListener interface
which delegates events to a single method.LockManager implementation.AbstractLRSProxyCollection.iterator() may perform a database
query.AbstractLRSProxyMap.get(java.lang.Object) or AbstractLRSProxyMap.containsKey(java.lang.Object) may perform a
database query.MetaDataFactory that provides default implementations
of many methods.PCResultObjectProvider
that implements ResultObjectProvider.getResultObject()
by assembling the necessary information about the object to be loaded.ctx.
QueryCache implementation that provides various
statistics, logging, and timeout functionality common across cache
implementations.RemoteCommitProvider.BrokerFactory implementation for use with the
AbstractStoreManager.StoreQuery that implements most methods as no-ops.AbstractStoreQuery.AbstractExecutor that implements most methods as no-ops.TransactionListener interface
that provides no-op implementations of all methods.o (if any) that a field
is about to be accessed.
InverseManager.ACTION_EXCEPTION action
InverseManager.ACTION_MANAGE action
InverseManager.ACTION_WARN action
List.addAll(int, Collection).
Collection.addAll(java.util.Collection).
group to the set of fetch group names to
use when loading objects.
groups to the set of fetch group names to
use when loading objects.
field to the set of fully-qualified field names to
use when loading objects.
fields to the set of fully-qualified field names to
use when loading objects.
PCRegistry.RegisterClassListener.
Collection.add(Object) on super.
Vector#addElement(Object) on super.
LinkedList#addLast(Object) on super.
RemoteCommitListener interface.
RemoteCommitListener interface.
Queue#offer(Object) on super.
Queue#poll on super.
Map.put(K, V) on super.
List.remove(int) on super.
Collection.remove(java.lang.Object) on super.
Queue#remove on super.
Map.remove(java.lang.Object) on super.
Vector#removeElement on super.
LinkedList#removeFirst on super.
LinkedList#removeLast on super.
List.set(int, E) on super.
Vector#setElementAt on super.
Properties#setProperty on super.
type.
meta.
Object[] of field values with one extra index containing a
BitSet of loaded fields.PersistenceCapable.
FieldMetaData that uses property access into the underlying
field name.ManagedRuntime interface that searches
through a set of known JNDI locations and method invocations to locate the
appropriate mechanism for obtaining a TransactionManager.List.add(int,Object) on super.
Collection.add(Object) on super.
Vector#addElement(Object) on super.
LinkedList#addFirst(Object) on super.
LinkedList#addLast(Object) on super.
Map.clear() on super.
Vector#insertElementAt(Object,int) on super.
Properties#load on super.
Properties#loadXML on super.
Queue#offer(Object) on super.
Queue#poll on super.
Map.put(K, V) on super.
List.remove(int) on super.
Collection.remove(java.lang.Object) on super.
Queue#remove on super.
Map.remove(java.lang.Object) on super.
Vector#removeElement on super.
Vector#removeElementAt(int) on super.
LinkedList#removeFirst on super.
LinkedList#removeLast on super.
List.set(int, E) on super.
Vector#setElementAt on super.
Properties#setProperty on super.
BindVariableExpression for map key sets.BindVariableExpression for map value collections.BrokerFactory objectsBrokerFactory has been fully created.
Broker instances.BrokerFactory is created.EventManager responsible for notifying listeners of
BrokerFactoryEvents.BrokerFactoryEvent objects.BrokerFactory.Broker.PluginValue that can efficiently create BrokerImpl
instances.OpenJPAId subclass appropriate for byte fields.CacheMap.CacheMap(boolean, int, int, float, int)
instead.
SizedMap.overflowRemoved(java.lang.Object, java.lang.Object) in the cache map.
CacheMarshaller implementation that writes data
to a specified file and reads data from a specified file or URL.false.
true if modifications to any of the
classes in changed results in a possible
invalidation of this query; otherwise returns
false.
OpenJPAId subclass appropriate for char fields.StateManagerImpl.setLoaded(boolean) method with a value of false.
fmd for
the instance managed by sm and its inverses.
val to the instance
managed by sm.
StateManagerImpl.saveFields(boolean).
CollectionChangeTracker.v1 and v2 to Comparable, and
invokes v1.compareTo (v2).
DataCache implementation that is optimized for concurrent
access.QueryCache implementation that is optimized for concurrent
access.true if this cache contains data
corresponding to oid; otherwise returns
false.
Integer.MAX_VALUE.
Integer.MAX_VALUE.
Message to send to the topic.
StoreContext that this result object
provider will load objects into.
PCData implementation for data caching.PCDataGenerator instance which generates properly
synchronized instances suitable for use in the cache.PCData implementation for data caching.OpenJPAId subclass appropriate for Date fields.Broker.delete(java.lang.Object, org.apache.openjpa.kernel.OpCallbacks) with the given instance.
OpenJPAStateManager designed to retrieve
values from a detached instance, including when managed by a
DetachedStateManager.StateManagerImpl.dirtyCheck() if the argument is a
StateManagerImpl.
_pc is dirty.
OpenJPAId subclass appropriate for double fields.DynamicStorage classes.Configurable.endConfiguration() must invoke this method.
Configurable.endConfiguration() must invoke this method.
BrokerFactory has been fully created.
Broker.evict(java.lang.Object, org.apache.openjpa.kernel.OpCallbacks) with the given instance.
Extent.
ObjectNotFoundException when an orphaned key is discovered.find methods of this interface.
ResultObjectProvider that can return all instances
of type, optionally including subclasses as defined
by subclasses.
Expression.Expressions in its native query language.ExpressionQuery.QueryExpressions instance.ExpressionStoreQuery.DataStoreExecutor.executeQuery(org.apache.openjpa.kernel.StoreQuery, java.lang.Object[], org.apache.openjpa.kernel.StoreQuery.Range) method.Method or Field.ResultShape.BrokerImpl that automatically closes itself during
finalization.finder queries.OpenJPAId subclass appropriate for float fields.states based on the objects' current
states, and delegates to
AbstractStoreManager.flush(Collection,Collection,Collection,Collection,Collection).
false.
JavaTypes constant.
ValueMetaData.CASCADE_IMMEDIATE.
PCDataGenerator.DynamicPCData instance for the given oid and metadata.
DynamicStorage instance with the given
array of JavaTypes constants and the given object as
the user key for generation.
AggregateListeners to use.
AutoClear constant.
AutoDetach which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetach flags.
services.
FieldMetaData.backingMember(java.lang.reflect.Member).
BrokerFactory class to use.
BrokerFactoryEventManager
associated with this configuration.
BrokerImpl extension to create.
BytecodeWriter to write to or null if none.
QueryCache that this object is associated with.
CacheMarshaller should store.
CacheMap that this cache is using.
CacheMap that this cache is using.
CacheMarshallers to use.
null if an
extent was specified instead of a collection.
null if a
collection was specified instead of an extent.
null if this information is not available / not relevant.
Throwable from ExceptionInfo.getNestedThrowables()
in order to conform to Throwable.getCause() in Java 1.4+.
Throwable from OpenJPAException.getNestedThrowables()
in order to conform to Throwable.getCause() in Java 1.4+.
ClassResolver to use for custom
class loading.
ClassResolver to use.
null.
ApplicationIdTool.run() method has not been called.
CodeGenerator.generateCode() has not
been called.
eval'ing the value of this expression.
ConnectionRetainModes.CONN_RETAIN_ALWAYS
ConnectionRetainModes.CONN_RETAIN_TRANS
ConnectionRetainModes.CONN_RETAIN_DEMAND
StoreContext that this store manager is
associated with.
DataCache to use for level-2 data store caching.
DataCacheMode
cls.getDeclaredMethods(), and returns the method
that matches the name and param arguments.
ClassMetaData.ACCESS_UNKNOWN access type.
DetachState constant.
EncryptionProvider.
Long.MAX_VALUE for no limit.
ExpressionFactory to use to create an expression to
be executed against an extent.
FetchConfigurations.
FetchConfigurations.
Constants.
meta that use field access,
or null if a list of fields is unobtainable.
PersistenceCapable class.
PersistenceCapable class.
Reflectable.
FilterListeners to use.
QueryFlushModes.FLUSH_TRUE,
QueryFlushModes.FLUSH_FALSE, or
QueryFlushModes.FLUSH_WITH_CONNECTION, as determined
by parsing the string returned by OpenJPAConfiguration.getFlushBeforeQueries().
cache.
Seq for the datastore identity values of the
specified persistent class, or null if the class' identity cannot be
represented as a sequence.
BrokerFactory
from properties.
Localizer to use for translating
error messages.
LockLevels.LOCK_NONE if not locked.
ManagedRuntime to use for managed
environments.
CacheMarshaller to use for caching metadata of id
id.
CacheMarshaller to use for caching metadata of id
id.
MetaDataFactory to use.
MetaDataRepository to use.
FieldMetaData.NULL_UNSET: no value supplied
FieldMetaData.NULL_NONE: leave null values as null in the data store
FieldMetaData.NULL_EXCEPTION: throw an exception if this field is null
at commit
FieldMetaData.NULL_DEFAULT: use the database default if this field is
null at commit
Defaults to FieldMetaData.NULL_UNSET.
StoreContext.getDirtyObjects().
orderIndexth ordering
expression in Query#getOrderingClauses from the
given result object.
PCState
type.
PersistenceCapable instance that provides access to
the instance managed by this state manager.
PersistenceCapable
class, or null if none.
Broker.preFlush()
when a savepoint is set.
Platform
property listing the runtime platform, such as:
OpenJPA JDBC Edition: Oracle Database
meta that use property access,
or null if a list of methods is unobtainable.
ProxyManager to use for second
class object proxies.
ProxyManager to use.
QueryContext for which this resolver was created
DataCache.
RemoteCommitProvider that this manager uses.
RestoreState constant.
QueryContext.setResultType(java.lang.Class), or null if none.
RuntimeUnenhancedClassesModes.SUPPORTED
RuntimeUnenhancedClassesModes.UNSUPPORTED
RuntimeUnenhancedClassesModes.WARN
Seq.
Seq.
StoreFacadeTypeRegistry instance associated with this
configuration.
this.
ChangeTrackers
to try to cut down on data store operations at the cost of some extra
bookkeeping overhead.
TransactionManager.
TransactionManager in JNDI.
Object if
the type is unknown.
null if none
has been set.
FieldMetaDatas to Constants.
FieldMetaData to update
Constants, in cases where this query is for a bulk update.
validate parameter of false.
validate parameter
of true.
o.
Seq for the generated values of the specified
field, or null if the field is not generated.
o.
JavaTypes constant.
StoreException by default.
QueryKey.equals(java.lang.Object)
method defined above.
? character.
OpenJPAId.toString() call on another
instance.
OpenJPAId.toString() call on another
instance.
OpenJPAId.toString() call on another
instance.
OpenJPAId.toString() call on another
instance.
String.indexOf(int) function on
the given target with the given args.
DataCacheManager.
DataCacheManager.
SavepointManager implementation which stores all data in memory.Instrumentation instance.OpenJPAId subclass appropriate for int fields.ManagedRuntime interface that uses
a static method call to find the TransactionManager. public boolean isXXX()
public Boolean isXXX()
Broker.close() has been invoked, though the broker might
remain open until the current managed transaction completes.
true if obj is a detached object
(one that can be reattached to a Broker via a call to
Broker.attach(java.lang.Object, boolean, org.apache.openjpa.kernel.OpCallbacks)); otherwise returns false.
public T getXXX() where T is any non-void type. public T isXXX() where T is boolean or Boolean.broker.
public T getXXX()
where T is any non-void type.
ObjectId.
className is the name for a
dynamically-created persistence-capable subclass.
true if the given class is already registered.
RemoteCommitProvider that
listens for object modifications and propagates those changes to
other RemoteCommitProviders over a JMS topic.ManagedRuntime interface that uses JNDI to
find the TransactionManager.SimpleNode that is used by JPQL.Map.keySet().
LifecycleEvents.AbstractStoreManager.initialize(org.apache.openjpa.kernel.OpenJPAStateManager, org.apache.openjpa.kernel.PCState, org.apache.openjpa.kernel.FetchConfiguration, java.lang.Object) invocation.
StoreManager.initialize(org.apache.openjpa.kernel.OpenJPAStateManager, org.apache.openjpa.kernel.PCState, org.apache.openjpa.kernel.FetchConfiguration, java.lang.Object) or StoreManager.load(org.apache.openjpa.kernel.OpenJPAStateManager, java.util.BitSet, org.apache.openjpa.kernel.FetchConfiguration, int, java.lang.Object))
depending on each state manager's state.
TransactionManager interface.FetchConfiguration for the broker.
Multithreaded flag is set to true.
VersionLockManager.lockInternal(org.apache.openjpa.kernel.OpenJPAStateManager, int, int, java.lang.Object, boolean) after traversing to owning
instance (if embedded) and assuring that the instance is persistent,
is not new, and is not already locked at a higher level.
LockManager.lock(org.apache.openjpa.kernel.OpenJPAStateManager, int, int, java.lang.Object) with each element of the collection
FetchConfiguration for the broker.
VersionLockManager.getVersionCheckOnReadLock()
and VersionLockManager.getVersionUpdateOnWriteLock().
openjpa.DataCache.
openjpa.Enhance.
openjpa.MetaData.
openjpa.Query.
openjpa.Runtime.
openjpa.Tool.
OpenJPAId subclass appropriate for long fields.MapChangeTracker.ValueMetaData.setValueMappedBy(java.lang.String) to denote that the map key
is mapped by the primary key field of the value.
CacheMarshaller architecture.MetaDataRepository uses implementations of this interface
to load and store metadata.PluginValue that interacts with the CacheMarshaller
to cache the metadata repository between executions.ClassResolver that uses multiple class loaders to
resolve classes.default
contains clause, and the returned value will be reused
for any further instances of the variable in subexpression of the
filter string.
AbstractDataCache.keyRemoved(java.lang.Object, boolean).
Context object for use by this provider.
PCData implementation of the right type for
embedded instances.
BrokerFactory
from properties.
cls.
Number, String, or Boolean instance.
Map to be used for the primary managed object cache.
MetaDataFactory to use with a repository.
PersistenceCapable class.
PersistenceCapable class, using the String
form of the constructor.
Order for the given field and declaration.
parent.address.city
var.address.city
Number, String, or Boolean instance.
StoreContext.nontransactional(java.lang.Object, org.apache.openjpa.kernel.OpCallbacks) with the given
instance.
CacheMarshaller that does nothing.OpenJPAConfiguration interface.ExpressionParser for language, or
null if no expression parser exists in the system for
the specified language.
BrokerFactory detected that local data is out of date
with the data store.
PersistenceCapable interface at runtime.PCDataGenerator.DynamicPCData instances which avoid primitive wrappers
to optimize memory use and performance at the cost of slightly higher
startup time.PCDatas generated will implement this interface
to simplify initialization.PCData implementation.PCEnhancer.PCEnhancer(OpenJPAConfiguration, BCClass,
MetaDataRepository, ClassLoader) instead.
ResultObjectProvider that populates a
OpenJPAStateManager object in an application-defined manner.Object.clone(),
readObject(ObjectInputStream), or
Externalizable#readExternal(ObjectInput).
read only in the designated getter and the
constructor.
Broker.persist(java.lang.Object, org.apache.openjpa.kernel.OpCallbacks) with the given instance.
oid into the cache.
qk into the
cache.
factory in the pool under key.
prepared queries.classes, creates and registers a
new subclass that implements PersistenceCapable, and prepares
OpenJPA to handle new instances of the unenhanced type.
Calendar
types.Date
types.ProxyManager interface.Map types.Map.putAll(java.util.Map).
StoreQuery implementation that caches the OIDs involved in
the query, and can determine whether or not the query has been dirtied.query if no
cached results are available.
Query interface.o to a PersistenceCapable
instance appropriate for storing in _pc.
true if updates to data already in the
cache (either in AbstractDataCache.commit(java.util.Collection, java.util.Collection, java.util.Collection, java.util.Collection) or the AbstractDataCache.update(org.apache.openjpa.datacache.DataCachePCData))
should be put back into the cache.
classes, this method will redefine
all the element's methods such that field accesses are intercepted
in-line.
PersistenceCapable interface that can handle
the persistence-capable contract for instances that were not enhanced
before class load time.ManagedRuntime interface that uses
the TransactionSynchronizationRegistry interface (new in JTA 1.1)
to create a TransactionManager facade for controlling transactions.TransactionManager and Transaction facade
that delegates the appropriate methods to the internally-held
TransactionSynchronizationRegistry.Broker#makeTransient with the given instance.
broker from any internal data structures.
RemoteCommitListeners on remote commit events.RemoteCommitEventManagers.RemoteCommitProvider.key is pinned into the cache, the pin is
cleared and the object is removed.
Collection.removeAll(java.util.Collection).
groups from the set of fetch group names
to use when loading objects.
fields from the set of fully-qualified field names
to use when loading objects.
PCRegistry.RegisterClassListener.
JavaTypes constant for the given field
FetchConfiguration.FETCH_REF field.
LifecycleEvent.
StateManagerImpl.saveFields(boolean), or to default values if never saved.
Collection.retainAll(java.util.Collection).
PCResultObjectProviders.openjpa.RuntimeUnenhancedClasses
configuration setting.OpenJPAStateManagers as necessary.
AggregateListeners to use.
AutoDetach flags.
AutoDetach which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetach which indicate when persistent
managed objects should be automatically detached in-place.
null.
BrokerFactory class to use.
BrokerImpl extension to create.
BytecodeWriter to write the bytecode to or null if none.
CacheMarshallers to use.
ClassResolver to use for custom
class loading.
ClassResolver to use.
ConnectionRetainModes.CONN_RETAIN_ALWAYS
ConnectionRetainModes.CONN_RETAIN_TRANS
ConnectionRetainModes.CONN_RETAIN_DEMAND
DataCache to use for level-2 data store caching.
DataCacheMode
OpenJPAConfiguration.setDataCacheTimeout(int).
OpenJPAConfiguration.setDynamicDataStructs(boolean).
EncryptionProvider.
OpenJPAConfiguration.setFetchBatchSize(int).
FetchConfigurations.
FetchConfigurations.
Files of metadata files or directories supplied by user.
Files of metadata files or
directories supplied by user via auto-configuration.
FilterListeners to use.
QueryFlushModes.FLUSH_TRUE,
QueryFlushModes.FLUSH_FALSE, or
QueryFlushModes.FLUSH_WITH_CONNECTION.
Query.
setHint(key, value, value).
OpenJPAConfiguration.setIgnoreChanges(boolean).
InitialContext
constructor for JNDI lookups.
OpenJPAConfiguration.setLockTimeout(int).
ManagedRuntime to use for managed
environments.
OpenJPAConfiguration.setMaxFetchDepth(int).
MetaDataFactory to use.
MetaDataRepository to use.
OpenJPAConfiguration.setMultithreaded(boolean).
OpenJPAConfiguration.setNontransactionalRead(boolean).
OpenJPAConfiguration.setNontransactionalWrite(boolean).
FieldMetaData.NULL_UNSET: no value supplied
FieldMetaData.NULL_NONE: leave null values as null in the data store
FieldMetaData.NULL_EXCEPTION: throw an exception if this field is null
at commit
FieldMetaData.NULL_DEFAULT: use the database default if this field is
null at commit
Defaults to FieldMetaData.NULL_UNSET.
OpenJPAConfiguration.setOptimistic(boolean).
StoreContext.getDirtyObjects().
Broker.preFlush()
when a savepoint is set.
ProxyManager to use for second
class object proxies.
ProxyManager to use.
DataCache.
DataCache.
OpenJPAConfiguration.setRetainState(boolean).
OpenJPAConfiguration.setRetryClassRegistration(boolean).
RuntimeUnenhancedClassesModes.SUPPORTED
RuntimeUnenhancedClassesModes.UNSUPPORTED
RuntimeUnenhancedClassesModes.WARN
Seq.
Seq.
JumpInstructions to the given instruction,
clearing the collection in the process.
ChangeTrackers
to try to cut down on data store operations at the cost of some extra
bookkeeping overhead.
TransactionManager.
TransactionManager in JNDI.
URLs of metadata files or jars supplied by user.
URLs of metadata files or jars
supplied by user via auto-configuration.
OpenJPAStateManager.
OpenJPAStateManager.
validate parameter of false.
validate parameter
of true.
CacheMarshaller.ValidationPolicy that this marshaller should use.
OpenJPAId subclass appropriate for short fields.RemoteCommitProvider
that listens for object modifications and propagates those changes
to other SingleJVMRemoteCommitProviders in the same JVM.SizedMap.overflowRemoved(java.lang.Object, java.lang.Object) in the soft map.
OpenJPAStateManager interface for use
with this runtime.o into the cache.
matches() instead.OpenJPAId subclass appropriate for String fields.Subquery.String.substring(int) function on
the given target with the given args.
ManagedRuntime implementation for SunONE.true.
RemoteCommitProvider that
listens for object modifications and propagates those changes to
other RemoteCommitProviders over TCP sockets.Seq used
to provide datastore ids.className is a dynamically-created persistence-capable
subclass name, returns the name of the class that it subclasses.
StoreContext.nontransactional(java.lang.Object, org.apache.openjpa.kernel.OpCallbacks) with the given
instance.
TransactionEvents.oid from the cache.
key into the cache.
FieldMetaData,Value for update statements.
OpenJPAStateManager.
OpenJPAStateManager.
Value.ValueMetaData implementation.Map.values().
LockManager implementation that provides support
for version checking and version updating when locks are acquired.ManagedRuntime implementation that allows synchronization with a
WebSphere managed transaction.RegistryManagedRuntime.matches() instead.ManagedRuntime implementation that directly accesses the
transaction manager via WebLogic Server helper classes.Writer.
pc to oos, handling internal-form
serialization.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||