Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.openjpa.kernel
Class BrokerImpl

    java.lang.Object
      org.apache.openjpa.kernel.BrokerImpl

All Implemented Interfaces:
  Serializable, Cloneable, Synchronization, CallbackModes, AutoClear, AutoDetach, Broker, ConnectionRetainModes, DetachState, FindCallbacks, LockLevels, RestoreState, StoreContext, Closeable

Direct Known Subclasses:
  FinalizingBrokerImpl

    public class BrokerImpl

extends Object
implements Broker, FindCallbacks, Cloneable, Serializable

Concrete `Broker`. The broker handles object-level behavior, but leaves all interaction with the data store to a `StoreManager` that must be supplied at initialization.

Author:
  Abe White
See Also:
  Serialized Form

Nested Class Summary
`static class` | `BrokerImpl.StateManagerId` Unique id for state managers of new datastore instances without assigned object ids.
`(package private) static class` | `BrokerImpl.TransactionalCache` Transactional cache that holds soft refs to clean instances.

Field Summary
`protected static int` | `FLUSH_COMMIT` Flush in preparation of commit.
`protected static int` | `FLUSH_INC` Incremental flush.
`protected static int` | `FLUSH_LOGICAL` Run persistence-by-reachability and other flush-time operations without accessing the database.
`protected static int` | `FLUSH_ROLLBACK` Flush to check consistency of cache, then immediately rollback changes.
`(package private) static int` | `STATUS_COMMIT_NEW`
`(package private) static int` | `STATUS_INIT`
`(package private) static int` | `STATUS_OID_ASSIGN`
`(package private) static int` | `STATUS_TRANSIENT`

Fields inherited from interface org.apache.openjpa.kernel.StoreContext
`EXCLUDE_ALL, OID_ALLOW_NEW, OID_COPY, OID_NODELETED, OID_NOVALIDATE`

Fields inherited from interface org.apache.openjpa.kernel.ConnectionRetainModes
`CONN_RETAIN_ALWAYS, CONN_RETAIN_DEMAND, CONN_RETAIN_TRANS`

Fields inherited from interface org.apache.openjpa.kernel.DetachState
`DETACH_ALL, DETACH_FETCH_GROUPS, DETACH_FGS, DETACH_LOADED`

Fields inherited from interface org.apache.openjpa.kernel.LockLevels
`LOCK_NONE, LOCK_READ, LOCK_WRITE`

Fields inherited from interface org.apache.openjpa.kernel.RestoreState
`RESTORE_ALL, RESTORE_IMMUTABLE, RESTORE_NONE`

Fields inherited from interface org.apache.openjpa.kernel.AutoClear
`CLEAR_ALL, CLEAR_DATASTORE`

Fields inherited from interface org.apache.openjpa.kernel.AutoDetach
`DETACH_CLOSE, DETACH_COMMIT, DETACH_NONE, DETACH_NONTXREAD, DETACH_ROLLBACK, names, values`

Fields inherited from interface org.apache.openjpa.event.CallbackModes
`CALLBACK_FAIL_FAST, CALLBACK_IGNORE, CALLBACK_LOG, CALLBACK_RETHROW, CALLBACK_ROLLBACK`

Constructor Summary
`BrokerImpl()`

Method Summary
`(package private) void` | `addDereferencedDependent(StateManagerImpl sm)` Add a dereferenced dependent object to the persistence manager's cache.
`void` | `addLifecycleListener(Object listener, Class[] classes)` Register a listener for lifecycle-related events on the specified classes.
`(package private) void` | `addToPendingTransaction(StateManagerImpl sm)` Notify the broker that the given state manager should be added to the set of instances that will become transactional on the next transaction
`(package private) void` | `addToTransaction(StateManagerImpl sm)` Notify the broker that the given state manager should be added to the set of instances involved in the current transaction.
`void` | `addTransactionListener(Object tl)` Register a listener for transaction-related events.
`void` | `afterCompletion(int status)`
`void` | `assertActiveTransaction()` Throw an exception if there is no active transaction.
`void` | `assertNontransactionalRead()` Throw an exception if there is no transaction active and nontransactional reading is not enabled.
`void` | `assertOpen()` Throw an exception if the context is closed.
`protected PersistenceCapable` | `assertPersistenceCapable(Object obj)` Return the given instance as a `PersistenceCapable`.
`void` | `assertWriteOperation()` Throw an exception if a write operation is not permitted (there is no active transaction and nontransactional writing is not enabled).
`protected void` | `assignObjectId(Object cache, Object id, StateManagerImpl sm)` Assign the object id to the cache.
`Object` | `attach(Object obj, boolean copyNew, OpCallbacks call)` Import the specified detached object into the broker.
`Object[]` | `attachAll(Collection objs, boolean copyNew, OpCallbacks call)` Import the specified objects into the broker.
`void` | `beforeCompletion()`
`void` | `begin()` Begin a transaction.
`boolean` | `beginOperation(boolean syncTrans)` Begin a logical operation.
`void` | `beginStore()` Begin a data store transaction.
`boolean` | `cancelAll()` Cancel all pending data store statements.
`protected void` | `checkForDuplicateId(Object id, Object obj, ClassMetaData meta)` This method makes sure we don't already have the instance cached
`Object` | `clone()`
`void` | `close()` Close the broker.
`void` | `commit()` Commit the current transaction.
`void` | `commitAndResume()` Issue a commit and then start a new transaction.
`(package private) OpenJPAStateManager` | `copy(OpenJPAStateManager copy, PCState state)` If not already cached, create an empty copy of the given state manager in the given state.
`void` | `delete(Object obj, OpCallbacks call)` Delete the given object.
`(package private) void` | `delete(Object obj, StateManagerImpl sm, OpCallbacks call)` Internal delete.
`void` | `deleteAll(Collection objs, OpCallbacks call)` Delete the given objects.
`Object` | `detach(Object obj, OpCallbacks call)` Detach the specified object from the broker.
`Object[]` | `detachAll(Collection objs, OpCallbacks call)` Detach the specified objects from the broker.
`void` | `detachAll(OpCallbacks call)` Detach all objects in place.
`void` | `detachAll(OpCallbacks call, boolean flush)` Detach all objects in place, with the option of performing a flush before doing the detachment.
`void` | `dirtyType(Class cls)` Mark the given class as dirty within the current transaction.
`OpenJPAStateManager` | `embed(Object obj, Object id, OpenJPAStateManager owner, ValueMetaData ownerMeta)` Make the given instance embedded.
`boolean` | `endOperation()` Mark the operation over.
`protected void` | `endTransaction(int status)` End the current transaction, making appropriate state transitions.
`void` | `evict(Object obj, OpCallbacks call)` Evict the given object.
`void` | `evictAll(Collection objs, OpCallbacks call)` Evict the given objects.
`void` | `evictAll(Extent extent, OpCallbacks call)` Evict all persistent-clean and persistent-nontransactional instances in the given `Extent`.
`void` | `evictAll(OpCallbacks call)` Evict all clean objects.
`Iterator` | `extentIterator(Class type, boolean subclasses, FetchConfiguration fetch, boolean ignoreChanges)` Return an iterator over all instances of the given type.
`Object` | `find(Object oid, boolean validate, FindCallbacks call)` Find the persistence object with the given oid.
`Object` | `find(Object oid, FetchConfiguration fetch, BitSet exclude, Object edata, int flags)` Return the object with the given oid.
`protected Object` | `find(Object oid, FetchConfiguration fetch, BitSet exclude, Object edata, int flags, FindCallbacks call)` Internal finder.
`Object[]` | `findAll(Collection oids, boolean validate, FindCallbacks call)` Return the objects with the given oids.
`Object[]` | `findAll(Collection oids, FetchConfiguration fetch, BitSet exclude, Object edata, int flags)` Return the objects with the given oids.
`protected Object[]` | `findAll(Collection oids, FetchConfiguration fetch, BitSet exclude, Object edata, int flags, FindCallbacks call)` Internal finder.
`Object` | `findCached(Object oid, FindCallbacks call)` Return the instance for the given oid/object , or null if not found in the L1 cache.
`(package private) boolean` | `fireLifecycleEvent(Object src, Object related, ClassMetaData meta, int eventType)` Fire given lifecycle event, handling any exceptions appropriately.
`void` | `flush()` Flush all transactional instances to the data store.
`protected void` | `flush(int reason)` Flush the transactional state to the data store.
`protected void` | `free()` Free the resources used by this persistence manager.
`(package private) void` | `gatherCascadeRefresh(Object obj, OpCallbacks call)` Gathers all objects reachable through cascade-refresh relations into the operating set.
`boolean` | `getAllowReferenceToSiblingContext()` Affirms if this context will allow its managed instances to refer instances that are managed by other contexts.
`int` | `getAutoClear()` Whether objects clear when entering transactions.
`int` | `getAutoDetach()` Bit flags marked in `AutoDetach` which indicate when persistent managed objects should be automatically detached in-place.
`Broker` | `getBroker()` Return the broker for this context, if possible.
`BrokerFactory` | `getBrokerFactory()` Return the factory that produced this broker.
`boolean` | `getCacheFinderQuery()`
`boolean` | `getCachePreparedQuery()` Affirms if this receiver is caching prepared queries.
`ClassLoader` | `getClassLoader()` Return the current thread's class loader at the time this context was obtained.
`OpenJPAConfiguration` | `getConfiguration()` Return the configuration associated with this context.
`Object` | `getConnection()` Return the connection in use by the context, or a new connection if none.
`Object` | `getConnectionFactory()` Return the 'JTA' ConnectionFactory, looking it up from JNDI if needed.
`Object` | `getConnectionFactory2()` Return the 'NonJTA' ConnectionFactory, looking it up from JNDI if needed.
`String` | `getConnectionFactory2Name()` Return the 'NonJTA' ConnectionFactoryName.
`String` | `getConnectionFactoryName()` Return the 'JTA' connectionFactoryName
`String` | `getConnectionPassword()` Return the connection password.
`int` | `getConnectionRetainMode()` Return the connection retain mode for this broker.
`String` | `getConnectionUserName()` Return the connection user name.
`Collection` | `getDeletedTypes()` Return the set of classes that have been deleted in the current transaction.
`int` | `getDetachState()` Detach mode constant to determine which fields are part of the detached graph.
`Collection` | `getDirtyObjects()` Return a list of current dirty instances.
`protected Collection` | `getDirtyStates()` Return a copy of all dirty state managers.
`boolean` | `getEvictFromDataCache()` Whether to also evict an object from the store cache when it is evicted through this broker.
`FetchConfiguration` | `getFetchConfiguration()` Return the (mutable) fetch configuration for loading objects from this context.
`Seq` | `getIdentitySequence(ClassMetaData meta)` Returns a `Seq` for the datastore identity values of the specified persistent class, or null if the class' identity cannot be represented as a sequence.
`boolean` | `getIgnoreChanges()` Whether to take into account changes in the transaction when executing a query or iterating an extent.
`(package private) RuntimeExceptionTranslator` | `getInstanceExceptionTranslator()`
`InverseManager` | `getInverseManager()` Return the inverse manager in use.
`LifecycleEventManager` | `getLifecycleEventManager()` Give state managers access to the lifecycle event manager.
`int` | `getLifecycleListenerCallbackMode()` The callback mode for handling exceptions from lifecycle event listeners.
`int` | `getLockLevel(Object o)` Return the lock level of the specified object.
`LockManager` | `getLockManager()` Return the lock manager in use.
`Collection` | `getManagedObjects()` Return a list of all managed instances.
`ManagedRuntime` | `getManagedRuntime()` Return the managed runtime in use.
`protected Collection` | `getManagedStates()` Return a copy of all managed state managers.
`boolean` | `getMultithreaded()` Whether the broker or its managed instances are used in a multithreaded environment.
`boolean` | `getNontransactionalRead()` Whether to allow nontransactional access to persistent state.
`boolean` | `getNontransactionalWrite()` Whether to allow nontransactional changes to persistent state.
`Object` | `getObjectId(Object obj)` Return the oid of the given instance.
`Class<?>` | `getObjectIdType(Class<?> cls)` Return the application or datastore identity class the given persistent class uses for object ids.
`protected Set<Object>` | `getOperatingSet()` Gets the unmodifiable set of instances being operated.
`boolean` | `getOptimistic()` Whether to use optimistic transactional semantics.
`boolean` | `getOrderDirtyObjects()` Whether to maintain the order in which objects are dirtied for `StoreContext.getDirtyObjects()`.
`Collection` | `getPendingTransactionalObjects()` Return a list of instances which will become transactional upon the next transaction.
`protected Collection` | `getPendingTransactionalStates()` Return a copy of all state managers which will become transactional upon the next transaction.
`Collection` | `getPersistedTypes()` Return the set of classes that have been made persistent in the current transaction.
`boolean` | `getPopulateDataCache()` Whether objects accessed during this transaction will be added to the store cache.
`boolean` | `getPostLoadOnMerge()` Force sending a @PostLoad lifecycle event while merging.
`boolean` | `getPrintParameters()`
`Map<String,Object>` | `getProperties()` Get current configuration property values used by this instance.
`int` | `getRestoreState()` Whether to restore an object's original state on rollback.
`boolean` | `getRetainState()` Whether objects retain their persistent state on transaction commit.
`Throwable` | `getRollbackCause()` Returns the Throwable that caused the transaction to be marked for rollback.
`boolean` | `getRollbackOnly()` Return whether the current transaction has been marked for rollback.
`OpenJPAStateManager` | `getStateManager(Object obj)` Return the state manager for the given instance.
`protected StateManagerImpl` | `getStateManagerImpl(Object obj, boolean assertThisContext)` Return the state manager for the given instance, or null.
`protected StateManagerImpl` | `getStateManagerImplById(Object oid, boolean allowNew)` Return the state manager for the given oid.
`DelegatingStoreManager` | `getStoreManager()` Return the store manager in use.
`Set<String>` | `getSupportedProperties()` Gets the property names that can be used to corresponding setter methods of this receiver to set its value.
`boolean` | `getSuppressBatchOLELogging()` Return whether this Broker will generate verbose optimistic lock exceptions when batching operations.
`Synchronization` | `getSynchronization()`
`boolean` | `getSyncWithManagedTransactions()` Whether to check for a global transaction upon every managed, non-transactional operation.
`Collection` | `getTransactionalObjects()` Return a list of current transaction instances.
`protected Collection<StateManagerImpl>` | `getTransactionalStates()` Return a copy of all transactional state managers.
`int` | `getTransactionListenerCallbackMode()` The callback mode for handling exceptions from transaction event listeners.
`Collection<Object>` | `getTransactionListeners()` Gets an umodifiable collection of currently registered lsteners.
`Collection` | `getUpdatedTypes()` Return the set of classes for objects that have been modified in the current transaction.
`Object` | `getUserObject(Object key)` Get the value for the specified key from the map of user objects.
`Seq` | `getValueSequence(FieldMetaData fmd)` Returns a `Seq` for the generated values of the specified field, or null if the field is not generated.
`Object` | `getVersion(Object obj)` Returns the current version indicator for `o`.
`boolean` | `hasConnection()` Whether the broker has a dedicated connection based on the configured connection retain mode and transaction status.
`void` | `initialize(AbstractBrokerFactory factory, DelegatingStoreManager sm, boolean managed, int connMode, boolean fromDeserialization)` Initialize the persistence manager.
`void` | `initialize(AbstractBrokerFactory factory, DelegatingStoreManager sm, boolean managed, int connMode, boolean fromDeserialization, boolean fromWriteBehindCallback)`
`protected StateManagerImpl` | `initialize(StateManagerImpl sm, boolean load, FetchConfiguration fetch, Object edata)` Initialize a newly-constructed state manager.
`boolean` | `isActive()` Whether a logical transaction is active.
`boolean` | `isCached(List<Object> oids)` Indicate whether the oid can be found in the StoreContext's L1 cache or in the StoreManager cache.
`boolean` | `isClosed()` Whether the broker is closed.
`boolean` | `isCloseInvoked()` Whether `Broker.close()` has been invoked, though the broker might remain open until the current managed transaction completes.
`boolean` | `isDeleted(Object obj)` Return whether the given object is deleted.
`boolean` | `isDetached(Object obj)` Returns `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`.
`boolean` | `isDetached(Object obj, boolean find)` This method makes a best effort to determine if the provided object is detached.
`boolean` | `isDetachedNew()` Whether to treat relations to detached instances during persist operations as new or as pseudo-hollow instances.
`boolean` | `isDirty(Object obj)` Return whether the given object is dirty.
`protected boolean` | `isFlushing()`
`boolean` | `isFromWriteBehindCallback()`
`boolean` | `isLoading(Object o)`
`boolean` | `isManaged()` Whether this context is using managed transactions.
`boolean` | `isNew(Object obj)` Return whether the given object is a newly-created instance registered with `broker`.
`boolean` | `isPersistent(Object obj)` Return whether the given object is persistent.
`(package private) boolean` | `isSerializing()` Whether or not this broker is in the midst of being serialized.
`boolean` | `isStoreActive()` Whether a data store transaction is active.
`boolean` | `isTrackChangesByType()` Whether memory usage is reduced during this transaction at the expense of tracking changes at the type level instead of the instance level, resulting in more aggressive cache invalidation.
`boolean` | `isTransactional(Object obj)` Return whether the given object is transactional.
`(package private) boolean` | `isTransactionEnding()` Return whether the current transaction is ending, i.e.
`void` | `lock()` Synchronizes on an internal lock if the `Multithreaded` flag is set to true.
`void` | `lock(Object obj, int level, int timeout, OpCallbacks call)` Ensure that the given instance is locked at the given lock level.
`void` | `lock(Object obj, OpCallbacks call)` Ensure that the given instance is locked at the current lock level, as set in the `FetchConfiguration` for the broker.
`void` | `lockAll(Collection objs, int level, int timeout, OpCallbacks call)` Ensure that the given instances are locked at the given lock level.
`void` | `lockAll(Collection objs, OpCallbacks call)` Ensure that the given instances are locked at the current lock level, as set in the `FetchConfiguration` for the broker.
`Extent` | `newExtent(Class type, boolean subclasses)` Return an extent of the given class, optionally including subclasses.
`Object` | `newInstance(Class cls)` Create a new instance of type `cls`.
`protected Map<?,?>` | `newManagedObjectCache()` Create a `Map` to be used for the primary managed object cache.
`Object` | `newObjectId(Class<?> cls, Object val)` Create a new object id instance from the given value.
`Query` | `newQuery(String lang, Class cls, Object query)` Create a new query from the given data, with the given candidate class and language.
`Query` | `newQuery(String lang, Object query)` Create a new query in the given language.
`protected QueryImpl` | `newQueryImpl(String lang, StoreQuery sq)` Create a new query.
`protected StateManagerImpl` | `newStateManagerImpl(Object oid, ClassMetaData meta)` Create a state manager for the given oid and metadata.
`void` | `nontransactional(Object obj, OpCallbacks call)` Make the given object non-transactional.
`void` | `nontransactionalAll(Collection objs, OpCallbacks call)` Make the given objects nontransactional.
`void` | `persist(Object obj, boolean explicit, OpCallbacks call)` Persist the given object.
`OpenJPAStateManager` | `persist(Object obj, Object id, boolean explicit, OpCallbacks call)` Persist the given object.
`OpenJPAStateManager` | `persist(Object obj, Object id, boolean explicit, OpCallbacks call, boolean fireEvent)` Persist the given object.
`OpenJPAStateManager` | `persist(Object obj, Object id, OpCallbacks call)` Make the given instance persistent.
`void` | `persist(Object obj, OpCallbacks call)` Persist the given object.
`void` | `persistAll(Collection objs, boolean explicit, OpCallbacks call)` Persist the given objects.
`void` | `persistAll(Collection objs, OpCallbacks call)` Persist the given objects.
`void` | `popFetchConfiguration()` Pops the fetch configuration from the top of the stack, making the next one down the active one.
`void` | `preFlush()` Run pre-flush actions on transactional objects, including persistence-by-reachability, inverse relationship management, deletion of dependent instances, and instance callbacks.
`Object` | `processArgument(Object oid)` Process find argument.
`Object` | `processReturn(Object oid, OpenJPAStateManager sm)` Process operation return value.
`FetchConfiguration` | `pushFetchConfiguration()` Pushes a new fetch configuration that inherits from the current fetch configuration onto a stack, and makes the new configuration the active one.
`FetchConfiguration` | `pushFetchConfiguration(FetchConfiguration fc)` Pushes the fetch configuration argument onto a stack, and makes the new configuration the active one.
`Object` | `putUserObject(Object key, Object val)` Put the specified key-value pair into the map of user objects.
`void` | `refresh(Object obj, OpCallbacks call)` Refresh the state of the given object.
`void` | `refreshAll(Collection objs, OpCallbacks call)` Refresh the state of the given objects.
`protected void` | `refreshInternal(Collection objs, OpCallbacks call)` This method is called with the full set of objects reachable via cascade-refresh relations from the user-given instances.
`protected void` | `refreshInternal(Object obj, OpCallbacks call)` Optimization for single-object refresh.
`void` | `release(Object obj, OpCallbacks call)` Release the given object from management.
`void` | `releaseAll(Collection objs, OpCallbacks call)` Release the given objects from management.
`void` | `releaseSavepoint()` Release the last set savepoint and any resources associated with it.
`void` | `releaseSavepoint(String savepoint)` Release the savepoint and any resources associated with it.
`(package private) void` | `removeDereferencedDependent(StateManagerImpl sm)` Remove the given previously dereferenced dependent object from the cache.
`(package private) void` | `removeFromPendingTransaction(StateManagerImpl sm)` Notify the persistence manager that the given state manager should be removed from the set of instances involved in the next transaction.
`(package private) void` | `removeFromTransaction(StateManagerImpl sm)` Notify the persistence manager that the given state manager should be removed from the set of instances involved in the current transaction.
`void` | `removeLifecycleListener(Object listener)` Remove a listener for lifecycle-related events.
`void` | `removeTransactionListener(Object tl)` Remove a listener for transaction-related events.
`void` | `retrieve(Object obj, boolean dfgOnly, OpCallbacks call)` Immediately load the given object's persistent fields.
`void` | `retrieveAll(Collection objs, boolean dfgOnly, OpCallbacks call)` Retrieve the given objects' persistent state.
`void` | `rollback()` Rollback the current transaction.
`void` | `rollbackAndResume()` Issue a rollback and then start a new transaction.
`void` | `rollbackToSavepoint()` Rollback the current transaction to the last savepoint.
`void` | `rollbackToSavepoint(String savepoint)` Rollback the current transaction to the given savepoint name.
`void` | `setAllowReferenceToSiblingContext(boolean allow)` Affirms if this context will allow its managed instances to refer instances that are managed by other contexts.
`void` | `setAuthentication(String user, String pass)` Set the persistence manager's authentication.
`void` | `setAutoClear(int val)` Whether objects clear when entering transactions.
`void` | `setAutoDetach(int detachFlags)` Sets automatic detachment option.
`void` | `setAutoDetach(int detachFlag, boolean on)` Bit flags marked in `AutoDetach` which indicate when persistent managed objects should be automatically detached in-place.
`void` | `setCacheFinderQuery(boolean flag)`
`void` | `setCachePreparedQuery(boolean flag)` Sets whether this receiver will cache prepared queries during its lifetime.
`void` | `setConnectionFactory2Name(String connectionFactory2Name)` Set the 'NonJTA' ConnectionFactoryName.
`void` | `setConnectionFactoryName(String connectionFactoryName)` Set the 'JTA' ConnectionFactoryName.
`void` | `setDetachedNew(boolean isNew)` Whether to treat relations to detached instances as new.
`void` | `setDetachState(int mode)` Detach mode constant to determine which fields are part of the detached graph.
`(package private) void` | `setDirty(StateManagerImpl sm, boolean firstDirty)` Notification that the given instance has been dirtied.
`void` | `setEvictFromDataCache(boolean evict)` Whether to also evict an object from the store cache when it is evicted through this broker.
`void` | `setIgnoreChanges(boolean val)` Whether to take into account changes in the transaction when executing a query or iterating an extent.
`void` | `setImplicitBehavior(OpCallbacks call, RuntimeExceptionTranslator ex)` Set the broker's behavior for implicit actions such as flushing, automatic detachment, and exceptions thrown by managed instances outside a broker operation.
`void` | `setLifecycleListenerCallbackMode(int mode)` The callback mode for handling exceptions from lifecycle event listeners.
`void` | `setMultithreaded(boolean multithreaded)` Whether the broker or its managed instances are used in a multithreaded environment.
`void` | `setNontransactionalRead(boolean val)` Whether to allow nontransactional access to persistent state.
`void` | `setNontransactionalWrite(boolean val)` Whether to allow nontransactional changes to persistent state.
`void` | `setOptimistic(boolean val)` Whether to use optimistic transactional semantics.
`void` | `setOrderDirtyObjects(boolean order)` Whether to maintain the order in which objects are dirtied for `StoreContext.getDirtyObjects()`.
`void` | `setPopulateDataCache(boolean cache)` Whether to populate the store cache with objects used by this transaction.
`void` | `setPostLoadOnMerge(boolean allow)` Set to `true` if the merge operation should trigger a @PostLoad lifecycle event.
`void` | `setRestoreState(int val)` Whether to restore an object's original state on rollback.
`void` | `setRetainState(boolean val)` Whether objects retain their persistent state on transaction commit.
`void` | `setRollbackOnly()` Mark the current transaction for rollback.
`void` | `setRollbackOnly(Throwable cause)` Mark the current transaction for rollback with the specified cause of the rollback.
`void` | `setSavepoint(String name)` Set a transactional savepoint where operations after this savepoint will be rolled back.
`protected void` | `setStateManager(Object id, StateManagerImpl sm, int status)` Set the cached StateManager for the instance that had the given oid.
`void` | `setSuppressBatchOLELogging(boolean b)` Set whether this Broker will generate verbose optimistic lock exceptions when batching operations.
`void` | `setSynchronization(Synchronization sync)`
`void` | `setSyncWithManagedTransactions(boolean sync)` Whether to check for a global transaction upon every managed, non-transactional operation.
`void` | `setTrackChangesByType(boolean largeTransaction)` If a large number of objects will be created, modified, or deleted during this transaction setting this option to true will reduce memory usage if you perform periodic flushes by tracking changes at the type level instead of the instance level, resulting in more aggressive cache invalidation.
`void` | `setTransactionListenerCallbackMode(int mode)` The callback mode for handling exceptions from transaction event listeners.
`boolean` | `syncWithManagedTransaction()` Attempt to synchronize with a current managed transaction, returning true if successful, false if no managed transaction is active.
`void` | `transactional(Object obj, boolean updateVersion, OpCallbacks call)` Make the given instances transactional.
`void` | `transactionalAll(Collection objs, boolean updateVersion, OpCallbacks call)` Make the given instances transactional.
`void` | `unlock()` Releases the internal lock.
`void` | `validateChanges()` Validate the changes made in this transaction, reporting any optimistic violations, constraint violations, etc.

Methods inherited from class java.lang.Object
`equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### FLUSH_INC

    protected static final int FLUSH_INC

  Incremental flush.

  See Also:
    Constant Field Values

### FLUSH_COMMIT

    protected static final int FLUSH_COMMIT

  Flush in preparation of commit.

  See Also:
    Constant Field Values

### FLUSH_ROLLBACK

    protected static final int FLUSH_ROLLBACK

  Flush to check consistency of cache, then immediately rollback changes.

  See Also:
    Constant Field Values

### FLUSH_LOGICAL

    protected static final int FLUSH_LOGICAL

  Run persistence-by-reachability and other flush-time operations without accessing the database.

  See Also:
    Constant Field Values

### STATUS_INIT

    static final int STATUS_INIT

See Also:
  Constant Field Values

### STATUS_TRANSIENT

    static final int STATUS_TRANSIENT

See Also:
  Constant Field Values

### STATUS_OID_ASSIGN

    static final int STATUS_OID_ASSIGN

See Also:
  Constant Field Values

### STATUS_COMMIT_NEW

    static final int STATUS_COMMIT_NEW

See Also:
  Constant Field Values

Constructor Detail

### BrokerImpl

    public BrokerImpl()

Method Detail

### setAuthentication

    public void setAuthentication(String user,
                                  String pass)

  Set the persistence manager's authentication. This is the first method called after construction.

  Parameters:
    `user` - the username this broker represents; used when pooling brokers to make sure that a request to the factory for a connection with an explicit user is delegated to a suitable broker
    `pass` - the password for the above user

### initialize

    public void initialize(AbstractBrokerFactory factory,
                           DelegatingStoreManager sm,
                           boolean managed,
                           int connMode,
                           boolean fromDeserialization)

  Initialize the persistence manager. This method is called automatically by the factory before use.

  Parameters:
    `factory` - the factory used to create this broker
    `sm` - a concrete StoreManager implementation to handle interaction with the data store
    `managed` - the transaction mode
    `connMode` - the connection retain mode
    `fromDeserialization` - whether this call happened because of a deserialization or creation of a new BrokerImpl.

### initialize

    public void initialize(AbstractBrokerFactory factory,
                           DelegatingStoreManager sm,
                           boolean managed,
                           int connMode,
                           boolean fromDeserialization,
                           boolean fromWriteBehindCallback)

### getOperatingSet

    protected Set<Object> getOperatingSet()

  Gets the unmodifiable set of instances being operated.

### clone

    public Object clone()
                 throws CloneNotSupportedException

  Overrides:
    `clone` in class `Object`
  Throws:
    `CloneNotSupportedException`

### newManagedObjectCache

    protected Map<?,?> newManagedObjectCache()

  Create a `Map` to be used for the primary managed object cache. Maps oids to state managers. By default, this creates a `ReferenceMap` with soft values.

### getBroker

    public Broker getBroker()

  Description copied from interface: `StoreContext`
  Return the broker for this context, if possible. Note that a broker will be unavailable in remote contexts, and this method may return null.

  Specified by:
    `getBroker` in interface `StoreContext`

### setImplicitBehavior

    public void setImplicitBehavior(OpCallbacks call,
                                    RuntimeExceptionTranslator ex)

  Description copied from interface: `Broker`
  Set the broker's behavior for implicit actions such as flushing, automatic detachment, and exceptions thrown by managed instances outside a broker operation. A broker's implicit behavior can only be set once; after the first invocation with non-null arguments, subsequent invocations of this method are ignored.

  Specified by:
    `setImplicitBehavior` in interface `Broker`

### getInstanceExceptionTranslator

    RuntimeExceptionTranslator getInstanceExceptionTranslator()

### getBrokerFactory

    public BrokerFactory getBrokerFactory()

  Description copied from interface: `Broker`
  Return the factory that produced this broker.

  Specified by:
    `getBrokerFactory` in interface `Broker`

### getConfiguration

    public OpenJPAConfiguration getConfiguration()

  Description copied from interface: `StoreContext`
  Return the configuration associated with this context.

  Specified by:
    `getConfiguration` in interface `StoreContext`

### getFetchConfiguration

    public FetchConfiguration getFetchConfiguration()

  Description copied from interface: `StoreContext`
  Return the (mutable) fetch configuration for loading objects from this context.

  Specified by:
    `getFetchConfiguration` in interface `StoreContext`

### pushFetchConfiguration

    public FetchConfiguration pushFetchConfiguration()

  Description copied from interface: `StoreContext`
  Pushes a new fetch configuration that inherits from the current fetch configuration onto a stack, and makes the new configuration the active one.

  Specified by:
    `pushFetchConfiguration` in interface `StoreContext`
  Returns:
    the new fetch configuration

### pushFetchConfiguration

    public FetchConfiguration pushFetchConfiguration(FetchConfiguration fc)

  Description copied from interface: `StoreContext`
  Pushes the fetch configuration argument onto a stack, and makes the new configuration the active one.

  Specified by:
    `pushFetchConfiguration` in interface `StoreContext`
  Returns:
    the new fetch configuration

### popFetchConfiguration

    public void popFetchConfiguration()

  Description copied from interface: `StoreContext`
  Pops the fetch configuration from the top of the stack, making the next one down the active one. This returns void to avoid confusion, since fetch configurations tend to be used in method-chaining patterns often.

  Specified by:
    `popFetchConfiguration` in interface `StoreContext`

### getConnectionRetainMode

    public int getConnectionRetainMode()

  Description copied from interface: `Broker`
  Return the connection retain mode for this broker.

  Specified by:
    `getConnectionRetainMode` in interface `Broker`

### isManaged

    public boolean isManaged()

  Description copied from interface: `StoreContext`
  Whether this context is using managed transactions.

  Specified by:
    `isManaged` in interface `StoreContext`

### getManagedRuntime

    public ManagedRuntime getManagedRuntime()

  Description copied from interface: `Broker`
  Return the managed runtime in use.

  Specified by:
    `getManagedRuntime` in interface `Broker`

### getClassLoader

    public ClassLoader getClassLoader()

  Description copied from interface: `StoreContext`
  Return the current thread's class loader at the time this context was obtained.

  Specified by:
    `getClassLoader` in interface `StoreContext`

### getStoreManager

    public DelegatingStoreManager getStoreManager()

  Description copied from interface: `StoreContext`
  Return the store manager in use. This will be a wrapper around the native store manager, which you can retrieve via `DelegatingStoreManager.getInnermostDelegate()`.

  Specified by:
    `getStoreManager` in interface `StoreContext`

### getLockManager

    public LockManager getLockManager()

  Description copied from interface: `StoreContext`
  Return the lock manager in use.

  Specified by:
    `getLockManager` in interface `StoreContext`

### getInverseManager

    public InverseManager getInverseManager()

  Description copied from interface: `Broker`
  Return the inverse manager in use.

  Specified by:
    `getInverseManager` in interface `Broker`

### getConnectionUserName

    public String getConnectionUserName()

  Description copied from interface: `StoreContext`
  Return the connection user name.

  Specified by:
    `getConnectionUserName` in interface `StoreContext`

### getConnectionPassword

    public String getConnectionPassword()

  Description copied from interface: `StoreContext`
  Return the connection password.

  Specified by:
    `getConnectionPassword` in interface `StoreContext`

### getMultithreaded

    public boolean getMultithreaded()

  Description copied from interface: `Broker`
  Whether the broker or its managed instances are used in a multithreaded environment.

  Specified by:
    `getMultithreaded` in interface `Broker`

### setMultithreaded

    public void setMultithreaded(boolean multithreaded)

  Description copied from interface: `Broker`
  Whether the broker or its managed instances are used in a multithreaded environment.

  Specified by:
    `setMultithreaded` in interface `Broker`

### getIgnoreChanges

    public boolean getIgnoreChanges()

  Description copied from interface: `Broker`
  Whether to take into account changes in the transaction when executing a query or iterating an extent.

  Specified by:
    `getIgnoreChanges` in interface `Broker`

### setIgnoreChanges

    public void setIgnoreChanges(boolean val)

  Description copied from interface: `Broker`
  Whether to take into account changes in the transaction when executing a query or iterating an extent.

  Specified by:
    `setIgnoreChanges` in interface `Broker`

### getNontransactionalRead

    public boolean getNontransactionalRead()

  Description copied from interface: `Broker`
  Whether to allow nontransactional access to persistent state.

  Specified by:
    `getNontransactionalRead` in interface `Broker`

### setNontransactionalRead

    public void setNontransactionalRead(boolean val)

  Description copied from interface: `Broker`
  Whether to allow nontransactional access to persistent state.

  Specified by:
    `setNontransactionalRead` in interface `Broker`

### getNontransactionalWrite

    public boolean getNontransactionalWrite()

  Description copied from interface: `Broker`
  Whether to allow nontransactional changes to persistent state.

  Specified by:
    `getNontransactionalWrite` in interface `Broker`

### setNontransactionalWrite

    public void setNontransactionalWrite(boolean val)

  Description copied from interface: `Broker`
  Whether to allow nontransactional changes to persistent state.

  Specified by:
    `setNontransactionalWrite` in interface `Broker`

### getOptimistic

    public boolean getOptimistic()

  Description copied from interface: `Broker`
  Whether to use optimistic transactional semantics.

  Specified by:
    `getOptimistic` in interface `Broker`

### setOptimistic

    public void setOptimistic(boolean val)

  Description copied from interface: `Broker`
  Whether to use optimistic transactional semantics.

  Specified by:
    `setOptimistic` in interface `Broker`

### getRestoreState

    public int getRestoreState()

  Description copied from interface: `Broker`
  Whether to restore an object's original state on rollback.

  Specified by:
    `getRestoreState` in interface `Broker`

### setRestoreState

    public void setRestoreState(int val)

  Description copied from interface: `Broker`
  Whether to restore an object's original state on rollback.

  Specified by:
    `setRestoreState` in interface `Broker`

### getRetainState

    public boolean getRetainState()

  Description copied from interface: `Broker`
  Whether objects retain their persistent state on transaction commit.

  Specified by:
    `getRetainState` in interface `Broker`

### setRetainState

    public void setRetainState(boolean val)

  Description copied from interface: `Broker`
  Whether objects retain their persistent state on transaction commit.

  Specified by:
    `setRetainState` in interface `Broker`

### getAutoClear

    public int getAutoClear()

  Description copied from interface: `Broker`
  Whether objects clear when entering transactions.

  Specified by:
    `getAutoClear` in interface `Broker`

### setAutoClear

    public void setAutoClear(int val)

  Description copied from interface: `Broker`
  Whether objects clear when entering transactions.

  Specified by:
    `setAutoClear` in interface `Broker`

### getAutoDetach

    public int getAutoDetach()

  Description copied from interface: `Broker`
  Bit flags marked in `AutoDetach` which indicate when persistent managed objects should be automatically detached in-place.

  Specified by:
    `getAutoDetach` in interface `Broker`

### setAutoDetach

    public void setAutoDetach(int detachFlags)

  Sets automatic detachment option.
  If the given flag contains `AutoDetach.DETACH_NONE` option, then no other option can be specified.

  Specified by:
    `setAutoDetach` in interface `Broker`

### setAutoDetach

    public void setAutoDetach(int detachFlag,
                              boolean on)

  Description copied from interface: `Broker`
  Bit flags marked in `AutoDetach` which indicate when persistent managed objects should be automatically detached in-place.

  Specified by:
    `setAutoDetach` in interface `Broker`

### getDetachState

    public int getDetachState()

  Description copied from interface: `StoreContext`
  Detach mode constant to determine which fields are part of the detached graph. Defaults to `DetachState.DETACH_LOADED`.

  Specified by:
    `getDetachState` in interface `StoreContext`

### setDetachState

    public void setDetachState(int mode)

  Description copied from interface: `StoreContext`
  Detach mode constant to determine which fields are part of the detached graph. Defaults to `DetachState.DETACH_LOADED`.

  Specified by:
    `setDetachState` in interface `StoreContext`

### isDetachedNew

    public boolean isDetachedNew()

  Description copied from interface: `Broker`
  Whether to treat relations to detached instances during persist operations as new or as pseudo-hollow instances.

  Specified by:
    `isDetachedNew` in interface `Broker`

### setDetachedNew

    public void setDetachedNew(boolean isNew)

  Description copied from interface: `Broker`
  Whether to treat relations to detached instances as new.

  Specified by:
    `setDetachedNew` in interface `Broker`

### getSyncWithManagedTransactions

    public boolean getSyncWithManagedTransactions()

  Description copied from interface: `Broker`
  Whether to check for a global transaction upon every managed, non-transactional operation. Defaults to false.

  Specified by:
    `getSyncWithManagedTransactions` in interface `Broker`

### setSyncWithManagedTransactions

    public void setSyncWithManagedTransactions(boolean sync)

  Description copied from interface: `Broker`
  Whether to check for a global transaction upon every managed, non-transactional operation. Defaults to false.

  Specified by:
    `setSyncWithManagedTransactions` in interface `Broker`

### getEvictFromDataCache

    public boolean getEvictFromDataCache()

  Description copied from interface: `Broker`
  Whether to also evict an object from the store cache when it is evicted through this broker.

  Specified by:
    `getEvictFromDataCache` in interface `Broker`

### setEvictFromDataCache

    public void setEvictFromDataCache(boolean evict)

  Description copied from interface: `Broker`
  Whether to also evict an object from the store cache when it is evicted through this broker.

  Specified by:
    `setEvictFromDataCache` in interface `Broker`

### getPopulateDataCache

    public boolean getPopulateDataCache()

  Description copied from interface: `StoreContext`
  Whether objects accessed during this transaction will be added to the store cache. Defaults to true.

  Specified by:
    `getPopulateDataCache` in interface `StoreContext`

### setPopulateDataCache

    public void setPopulateDataCache(boolean cache)

  Description copied from interface: `StoreContext`
  Whether to populate the store cache with objects used by this transaction. Defaults to true.

  Specified by:
    `setPopulateDataCache` in interface `StoreContext`

### isTrackChangesByType

    public boolean isTrackChangesByType()

  Description copied from interface: `StoreContext`
  Whether memory usage is reduced during this transaction at the expense of tracking changes at the type level instead of the instance level, resulting in more aggressive cache invalidation.

  Specified by:
    `isTrackChangesByType` in interface `StoreContext`

### setTrackChangesByType

    public void setTrackChangesByType(boolean largeTransaction)

  Description copied from interface: `StoreContext`
  If a large number of objects will be created, modified, or deleted during this transaction setting this option to true will reduce memory usage if you perform periodic flushes by tracking changes at the type level instead of the instance level, resulting in more aggressive cache invalidation. Upon transaction commit the data cache will have to more aggressively flush objects. The store cache will have to flush instances of objects for each class of object modified during the transaction. A side benefit of large transaction mode is that smaller update messages can be used for `RemoteCommitEvent`s. Defaults to false.

  Specified by:
    `setTrackChangesByType` in interface `StoreContext`

### getUserObject

    public Object getUserObject(Object key)

  Description copied from interface: `Broker`
  Get the value for the specified key from the map of user objects.

  Specified by:
    `getUserObject` in interface `Broker`

### putUserObject

    public Object putUserObject(Object key,
                                Object val)

  Description copied from interface: `Broker`
  Put the specified key-value pair into the map of user objects. Use a value of null to remove the key.

  Specified by:
    `putUserObject` in interface `Broker`

### getProperties

    public Map<String,Object> getProperties()

  Get current configuration property values used by this instance. This values are combination of the current configuration values overwritten by values maintained by this instance such as Optimistic flag.

  Specified by:
    `getProperties` in interface `Broker`
  Returns:
    the changed properties

### getSupportedProperties

    public Set<String> getSupportedProperties()

  Gets the property names that can be used to corresponding setter methods of this receiver to set its value.

  Specified by:
    `getSupportedProperties` in interface `Broker`

### addLifecycleListener

    public void addLifecycleListener(Object listener,
                                     Class[] classes)

  Description copied from interface: `Broker`
  Register a listener for lifecycle-related events on the specified classes. If the classes are null, all events will be propagated to the listener.

  Specified by:
    `addLifecycleListener` in interface `Broker`

### removeLifecycleListener

    public void removeLifecycleListener(Object listener)

  Description copied from interface: `Broker`
  Remove a listener for lifecycle-related events.

  Specified by:
    `removeLifecycleListener` in interface `Broker`

### getLifecycleListenerCallbackMode

    public int getLifecycleListenerCallbackMode()

  Description copied from interface: `Broker`
  The callback mode for handling exceptions from lifecycle event listeners.

  Specified by:
    `getLifecycleListenerCallbackMode` in interface `Broker`

### setLifecycleListenerCallbackMode

    public void setLifecycleListenerCallbackMode(int mode)

  Description copied from interface: `Broker`
  The callback mode for handling exceptions from lifecycle event listeners.

  Specified by:
    `setLifecycleListenerCallbackMode` in interface `Broker`

### getLifecycleEventManager

    public LifecycleEventManager getLifecycleEventManager()

  Give state managers access to the lifecycle event manager.

  Specified by:
    `getLifecycleEventManager` in interface `Broker`

### fireLifecycleEvent

    boolean fireLifecycleEvent(Object src,
                               Object related,
                               ClassMetaData meta,
                               int eventType)

  Fire given lifecycle event, handling any exceptions appropriately.

  Returns:
    whether events are being processed at this time

### addTransactionListener

    public void addTransactionListener(Object tl)

  Description copied from interface: `Broker`
  Register a listener for transaction-related events.

  Specified by:
    `addTransactionListener` in interface `Broker`

### removeTransactionListener

    public void removeTransactionListener(Object tl)

  Description copied from interface: `Broker`
  Remove a listener for transaction-related events.

  Specified by:
    `removeTransactionListener` in interface `Broker`

### getTransactionListeners

    public Collection<Object> getTransactionListeners()

  Description copied from interface: `Broker`
  Gets an umodifiable collection of currently registered lsteners.

  Specified by:
    `getTransactionListeners` in interface `Broker`

### getTransactionListenerCallbackMode

    public int getTransactionListenerCallbackMode()

  Description copied from interface: `Broker`
  The callback mode for handling exceptions from transaction event listeners.

  Specified by:
    `getTransactionListenerCallbackMode` in interface `Broker`

### setTransactionListenerCallbackMode

    public void setTransactionListenerCallbackMode(int mode)

  Description copied from interface: `Broker`
  The callback mode for handling exceptions from transaction event listeners.

  Specified by:
    `setTransactionListenerCallbackMode` in interface `Broker`

### setSuppressBatchOLELogging

    public void setSuppressBatchOLELogging(boolean b)

  Set whether this Broker will generate verbose optimistic lock exceptions when batching operations. Defaults to true.

  Parameters:
    `b` -

### getSuppressBatchOLELogging

    public boolean getSuppressBatchOLELogging()

  Return whether this Broker will generate verbose optimistic lock exceptions when batching operations.

### find

    public Object find(Object oid,
                       boolean validate,
                       FindCallbacks call)

  Description copied from interface: `StoreContext`
  Find the persistence object with the given oid. If `validate` is true, the broker will check the store for the object, and return null if it does not exist. If `validate` is false, this method never returns null. The broker will either return its cached instance, attempt to create a hollow instance, or throw an `ObjectNotFoundException` if unable to return a hollow instance.

  Specified by:
    `find` in interface `StoreContext`
    `validate` - if true, validate that the instance exists in the store and load fetch group fields, otherwise return any cached or hollow instance

### find

    public Object find(Object oid,
                       FetchConfiguration fetch,
                       BitSet exclude,
                       Object edata,
                       int flags)

  Description copied from interface: `StoreContext`
  Return the object with the given oid. If present, the cached instance will be returned. Otherwise, the instance will be initialized through the store as usual; however, in this case the store will be passed the given execution data, and the system will load the object according to the given fetch configuration (or the context's configuration, if the given one is null). Fields can optionally be excluded from required loading using the `exclude` mask. By default this method does not find new unflushed instances, validates, and does not throw an exception if a cached instance has been deleted concurrently. These options are controllable through the given `OID_XXX` flags.

  Specified by:
    `find` in interface `StoreContext`

### find

    protected Object find(Object oid,
                          FetchConfiguration fetch,
                          BitSet exclude,
                          Object edata,
                          int flags,
                          FindCallbacks call)

  Internal finder.

### initialize

    protected StateManagerImpl initialize(StateManagerImpl sm,
                                          boolean load,
                                          FetchConfiguration fetch,
                                          Object edata)

  Initialize a newly-constructed state manager.

### findAll

    public Object[] findAll(Collection oids,
                            boolean validate,
                            FindCallbacks call)

  Description copied from interface: `StoreContext`
  Return the objects with the given oids.

  Specified by:
    `findAll` in interface `StoreContext`
  Parameters:
    `oids` - the oids of the objects to return
  Returns:
    the objects that were looked up, in the same order as the oids parameter
  See Also:
    `StoreContext.find(Object,boolean,FindCallbacks)`

### findAll

    public Object[] findAll(Collection oids,
                            FetchConfiguration fetch,
                            BitSet exclude,
                            Object edata,
                            int flags)

  Description copied from interface: `StoreContext`
  Return the objects with the given oids.

  Specified by:
    `findAll` in interface `StoreContext`
  See Also:
    `StoreContext.find(Object,FetchConfiguration,BitSet,Object,int)`

### findAll

    protected Object[] findAll(Collection oids,
                               FetchConfiguration fetch,
                               BitSet exclude,
                               Object edata,
                               int flags,
                               FindCallbacks call)

  Internal finder.

### isLoading

    public boolean isLoading(Object o)

### findCached

    public Object findCached(Object oid,
                             FindCallbacks call)

  Description copied from interface: `StoreContext`
  Return the instance for the given oid/object , or null if not found in the L1 cache.

  Specified by:
    `findCached` in interface `StoreContext`
  Parameters:
    `oid` - the object's id
  Returns:
    the cached object, or null if not cached

### getObjectIdType

    public Class<?> getObjectIdType(Class<?> cls)

  Description copied from interface: `StoreContext`
  Return the application or datastore identity class the given persistent class uses for object ids.

  Specified by:
    `getObjectIdType` in interface `StoreContext`

### newObjectId

    public Object newObjectId(Class<?> cls,
                              Object val)

  Description copied from interface: `StoreContext`
  Create a new object id instance from the given value.

  Specified by:
    `newObjectId` in interface `StoreContext`
  Parameters:
    `cls` - the persistent class that uses this identity value
    `val` - an object id instance, stringified object id, or primary key value

### newStateManagerImpl

    protected StateManagerImpl newStateManagerImpl(Object oid,
                                                   ClassMetaData meta)

  Create a state manager for the given oid and metadata.

### begin

    public void begin()

  Description copied from interface: `Broker`
  Begin a transaction.

  Specified by:
    `begin` in interface `Broker`

### beginStore

    public void beginStore()

  Description copied from interface: `StoreContext`
  Begin a data store transaction.

  Specified by:
    `beginStore` in interface `StoreContext`

### commit

    public void commit()

  Description copied from interface: `Broker`
  Commit the current transaction.

  Specified by:
    `commit` in interface `Broker`

### rollback

    public void rollback()

  Description copied from interface: `Broker`
  Rollback the current transaction.

  Specified by:
    `rollback` in interface `Broker`

### syncWithManagedTransaction

    public boolean syncWithManagedTransaction()

  Description copied from interface: `Broker`
  Attempt to synchronize with a current managed transaction, returning true if successful, false if no managed transaction is active.

  Specified by:
    `syncWithManagedTransaction` in interface `Broker`

### commitAndResume

    public void commitAndResume()

  Description copied from interface: `Broker`
  Issue a commit and then start a new transaction. This is identical to:

       broker.commit (); broker.begin ();

  except that the broker's internal atomic lock is utilized, so this method can be safely executed from multiple threads.

  Specified by:
    `commitAndResume` in interface `Broker`
  See Also:
    `Broker.commit()`, `Broker.begin()`

### rollbackAndResume

    public void rollbackAndResume()

  Description copied from interface: `Broker`
  Issue a rollback and then start a new transaction. This is identical to:

       broker.rollback (); broker.begin ();

  except that the broker's internal atomic lock is utilized, so this method can be safely executed from multiple threads.

  Specified by:
    `rollbackAndResume` in interface `Broker`
  See Also:
    `Broker.rollback()`, `Broker.begin()`

### getRollbackOnly

    public boolean getRollbackOnly()

  Description copied from interface: `Broker`
  Return whether the current transaction has been marked for rollback.

  Specified by:
    `getRollbackOnly` in interface `Broker`

### getRollbackCause

    public Throwable getRollbackCause()

  Description copied from interface: `Broker`
  Returns the Throwable that caused the transaction to be marked for rollback.

  Specified by:
    `getRollbackCause` in interface `Broker`
  Returns:
    the Throwable, or null if none was given

### setRollbackOnly

    public void setRollbackOnly()

  Description copied from interface: `Broker`
  Mark the current transaction for rollback.

  Specified by:
    `setRollbackOnly` in interface `Broker`

### setRollbackOnly

    public void setRollbackOnly(Throwable cause)

  Description copied from interface: `Broker`
  Mark the current transaction for rollback with the specified cause of the rollback.

  Specified by:
    `setRollbackOnly` in interface `Broker`

### setSavepoint

    public void setSavepoint(String name)

  Description copied from interface: `Broker`
  Set a transactional savepoint where operations after this savepoint will be rolled back.

  Specified by:
    `setSavepoint` in interface `Broker`

### releaseSavepoint

    public void releaseSavepoint()

  Description copied from interface: `Broker`
  Release the last set savepoint and any resources associated with it. The given savepoint and any set after it will become invalid.

  Specified by:
    `releaseSavepoint` in interface `Broker`

### releaseSavepoint

    public void releaseSavepoint(String savepoint)

  Description copied from interface: `Broker`
  Release the savepoint and any resources associated with it. The given savepoint and any set after it will become invalid.

  Specified by:
    `releaseSavepoint` in interface `Broker`

### rollbackToSavepoint

    public void rollbackToSavepoint()

  Description copied from interface: `Broker`
  Rollback the current transaction to the last savepoint. Savepoints set after this one will become invalid.

  Specified by:
    `rollbackToSavepoint` in interface `Broker`

### rollbackToSavepoint

    public void rollbackToSavepoint(String savepoint)

  Description copied from interface: `Broker`
  Rollback the current transaction to the given savepoint name. Savepoints set after this one will become invalid.

  Specified by:
    `rollbackToSavepoint` in interface `Broker`

### flush

    public void flush()

  Description copied from interface: `Broker`
  Flush all transactional instances to the data store. This method may set the rollback only flag on the current transaction if it encounters an error.

  Specified by:
    `flush` in interface `Broker`

### preFlush

    public void preFlush()

  Description copied from interface: `Broker`
  Run pre-flush actions on transactional objects, including persistence-by-reachability, inverse relationship management, deletion of dependent instances, and instance callbacks. Transaction listeners are not invoked.

  Specified by:
    `preFlush` in interface `Broker`

### validateChanges

    public void validateChanges()

  Description copied from interface: `Broker`
  Validate the changes made in this transaction, reporting any optimistic violations, constraint violations, etc. In a datastore transaction or a flushed optimistic transaction, this method will act just like `Broker.flush()`. In an optimistic transaction that has not yet begun a datastore-level transaction, however, it will only report exceptions that would occur on flush, without retaining any datastore resources.

  Specified by:
    `validateChanges` in interface `Broker`

### isActive

    public boolean isActive()

  Description copied from interface: `StoreContext`
  Whether a logical transaction is active.

  Specified by:
    `isActive` in interface `StoreContext`

### isStoreActive

    public boolean isStoreActive()

  Description copied from interface: `StoreContext`
  Whether a data store transaction is active.

  Specified by:
    `isStoreActive` in interface `StoreContext`

### isTransactionEnding

    boolean isTransactionEnding()

  Return whether the current transaction is ending, i.e. in the 2nd phase of a commit or rollback

### beginOperation

    public boolean beginOperation(boolean syncTrans)

  Description copied from interface: `Broker`
  Begin a logical operation. This indicates to the broker the granularity of an operation which may require pre/post operation side-effects, such as non-tx detach. Will lock the broker until the `Broker.endOperation()` is called.

  Specified by:
    `beginOperation` in interface `Broker`
  Parameters:
    `syncTrans` - whether instances may be loaded/modified during this operation requiring a re-check of global tx
  Returns:
    whether this is the outermost operation on the stack

### endOperation

    public boolean endOperation()

  Mark the operation over. If outermost caller of stack, returns true and will detach managed instances if necessary.

  Specified by:
    `endOperation` in interface `Broker`
  Returns:
    whether this is the outermost operation on the stack

### getSynchronization

    public Synchronization getSynchronization()

### setSynchronization

    public void setSynchronization(Synchronization sync)

### beforeCompletion

    public void beforeCompletion()

  Specified by:
    `beforeCompletion` in interface `Synchronization`

### afterCompletion

    public void afterCompletion(int status)

  Specified by:
    `afterCompletion` in interface `Synchronization`

### flush

    protected void flush(int reason)

  Flush the transactional state to the data store. Subclasses that customize commit behavior should override this method. The method assumes that the persistence manager is locked, is not closed, and has an active transaction.

  Parameters:
    `reason` - one of `FLUSH_INC`, `FLUSH_COMMIT`, `FLUSH_ROLLBACK`, or `FLUSH_LOGICAL`
  Since:
    0.2.5

### endTransaction

    protected void endTransaction(int status)

  End the current transaction, making appropriate state transitions.

### persist

    public void persist(Object obj,
                        OpCallbacks call)

  Description copied from interface: `Broker`
  Persist the given object.

  Specified by:
    `persist` in interface `Broker`

### persist

    public OpenJPAStateManager persist(Object obj,
                                       Object id,
                                       OpCallbacks call)

  Description copied from interface: `Broker`
  Make the given instance persistent. Unlike other persist operations, this method does not immediately cascade to fields marked `ValueMetaData.CASCADE_IMMEDIATE`.

  Specified by:
    `persist` in interface `Broker`
  Parameters:
    `obj` - the instance to persist
    `id` - the id to give the state manager; may be null for default
  Returns:
    the state manager for the newly persistent instance

### persistAll

    public void persistAll(Collection objs,
                           OpCallbacks call)

  Description copied from interface: `Broker`
  Persist the given objects.

  Specified by:
    `persistAll` in interface `Broker`

### persistAll

    public void persistAll(Collection objs,
                           boolean explicit,
                           OpCallbacks call)

  Persist the given objects. Indicate whether this was an explicit persist (PNEW) or a provisonal persist (PNEWPROVISIONAL).

### persist

    public void persist(Object obj,
                        boolean explicit,
                        OpCallbacks call)

  Persist the given object. Indicate whether this was an explicit persist (PNEW) or a provisonal persist (PNEWPROVISIONAL)

### persist

    public OpenJPAStateManager persist(Object obj,
                                       Object id,
                                       boolean explicit,
                                       OpCallbacks call)

  Persist the given object. Indicate whether this was an explicit persist (PNEW) or a provisonal persist (PNEWPROVISIONAL). See `Broker` for details on this method.

### persist

    public OpenJPAStateManager persist(Object obj,
                                       Object id,
                                       boolean explicit,
                                       OpCallbacks call,
                                       boolean fireEvent)

  Persist the given object. Indicate whether this was an explicit persist (PNEW) or a provisonal persist (PNEWPROVISIONAL). See `Broker` for details on this method.

### deleteAll

    public void deleteAll(Collection objs,
                          OpCallbacks call)

  Description copied from interface: `Broker`
  Delete the given objects.

  Specified by:
    `deleteAll` in interface `Broker`

### delete

    public void delete(Object obj,
                       OpCallbacks call)

  Description copied from interface: `Broker`
  Delete the given object.

  Specified by:
    `delete` in interface `Broker`

### delete

    void delete(Object obj,
                StateManagerImpl sm,
                OpCallbacks call)

  Internal delete.

### releaseAll

    public void releaseAll(Collection objs,
                           OpCallbacks call)

  Description copied from interface: `Broker`
  Release the given objects from management. This operation is not recursive.

  Specified by:
    `releaseAll` in interface `Broker`

### release

    public void release(Object obj,
                        OpCallbacks call)

  Description copied from interface: `Broker`
  Release the given object from management. This operation is not recursive.

  Specified by:
    `release` in interface `Broker`

### embed

    public OpenJPAStateManager embed(Object obj,
                                     Object id,
                                     OpenJPAStateManager owner,
                                     ValueMetaData ownerMeta)

  Description copied from interface: `StoreContext`
  Make the given instance embedded.

  Specified by:
    `embed` in interface `StoreContext`
  Parameters:
    `obj` - the instance to embed; may be null to create a new instance
    `id` - the id to give the embedded state manager; may be null for default
    `owner` - the owning state manager
    `ownerMeta` - the value in which the object is embedded
  Returns:
    the state manager for the embedded instance

### copy

    OpenJPAStateManager copy(OpenJPAStateManager copy,
                             PCState state)

  If not already cached, create an empty copy of the given state manager in the given state.

### refreshAll

    public void refreshAll(Collection objs,
                           OpCallbacks call)

  Description copied from interface: `Broker`
  Refresh the state of the given objects.

  Specified by:
    `refreshAll` in interface `Broker`

### refresh

    public void refresh(Object obj,
                        OpCallbacks call)

  Description copied from interface: `Broker`
  Refresh the state of the given object.

  Specified by:
    `refresh` in interface `Broker`

### gatherCascadeRefresh

    void gatherCascadeRefresh(Object obj,
                              OpCallbacks call)

  Gathers all objects reachable through cascade-refresh relations into the operating set.

### refreshInternal

    protected void refreshInternal(Collection objs,
                                   OpCallbacks call)

  This method is called with the full set of objects reachable via cascade-refresh relations from the user-given instances.

### refreshInternal

    protected void refreshInternal(Object obj,
                                   OpCallbacks call)

  Optimization for single-object refresh.

### retrieveAll

    public void retrieveAll(Collection objs,
                            boolean dfgOnly,
                            OpCallbacks call)

  Description copied from interface: `StoreContext`
  Retrieve the given objects' persistent state. Unmanaged targets are ignored.

  Specified by:
    `retrieveAll` in interface `StoreContext`
    `dfgOnly` - indicator as to whether to retrieve only fields
  See Also:
    `StoreContext.retrieve(java.lang.Object, boolean, org.apache.openjpa.kernel.OpCallbacks)`

### retrieve

    public void retrieve(Object obj,
                         boolean dfgOnly,
                         OpCallbacks call)

  Description copied from interface: `StoreContext`
  Immediately load the given object's persistent fields. One might use this action to make sure that an instance's fields are loaded before transitioning it to transient. Note that this action is not recursive. Any related objects that are loaded will not necessarily have their fields loaded. Unmanaged target is ignored.

  Specified by:
    `retrieve` in interface `StoreContext`
    `dfgOnly` - indicator as to whether to retrieve only fields in the current fetch groups, or all fields
  See Also:
    `StoreContext.retrieve(java.lang.Object, boolean, org.apache.openjpa.kernel.OpCallbacks)`

### evictAll

    public void evictAll(OpCallbacks call)

  Description copied from interface: `Broker`
  Evict all clean objects.

  Specified by:
    `evictAll` in interface `Broker`

### evictAll

    public void evictAll(Collection objs,
                         OpCallbacks call)

  Description copied from interface: `Broker`
  Evict the given objects.

  Specified by:
    `evictAll` in interface `Broker`

### evictAll

    public void evictAll(Extent extent,
                         OpCallbacks call)

  Description copied from interface: `Broker`
  Evict all persistent-clean and persistent-nontransactional instances in the given `Extent`.

  Specified by:
    `evictAll` in interface `Broker`

### evict

    public void evict(Object obj,
                      OpCallbacks call)

  Description copied from interface: `Broker`
  Evict the given object.

  Specified by:
    `evict` in interface `Broker`

### detach

    public Object detach(Object obj,
                         OpCallbacks call)

  Description copied from interface: `Broker`
  Detach the specified object from the broker.

  Specified by:
    `detach` in interface `Broker`
  Parameters:
    `obj` - the instance to detach
  Returns:
    the detached instance

### detachAll

    public Object[] detachAll(Collection objs,
                              OpCallbacks call)

  Description copied from interface: `Broker`
  Detach the specified objects from the broker. The objects returned can be manipulated and re-attached with `Broker.attachAll(java.util.Collection, boolean, org.apache.openjpa.kernel.OpCallbacks)`. The detached instances will be unmanaged copies of the specified parameters, and are suitable for serialization and manipulation outside of a OpenJPA environment. When detaching instances, only fields in the current `FetchConfiguration` will be traversed. Thus, to detach a graph of objects, relations to other persistent instances must either be in the `default-fetch-group`, or in the current custom `FetchConfiguration`.

  Specified by:
    `detachAll` in interface `Broker`
  Parameters:
    `objs` - the instances to detach
  Returns:
    the detached instances

### detachAll

    public void detachAll(OpCallbacks call)

  Description copied from interface: `Broker`
  Detach all objects in place. A flush will be performed before detaching the entities.

  Specified by:
    `detachAll` in interface `Broker`

### detachAll

    public void detachAll(OpCallbacks call,
                          boolean flush)

  Description copied from interface: `Broker`
  Detach all objects in place, with the option of performing a flush before doing the detachment.

  Specified by:
    `detachAll` in interface `Broker`
  Parameters:
    `call` - Persistence operation callbacks
    `flush` - boolean value to indicate whether to perform a flush before detaching the entities (true, do the flush; false, don't do the flush)

### attach

    public Object attach(Object obj,
                         boolean copyNew,
                         OpCallbacks call)

  Description copied from interface: `Broker`
  Import the specified detached object into the broker.

  Specified by:
    `attach` in interface `Broker`
  Parameters:
    `obj` - instance to import
    `copyNew` - whether to copy new instances
  Returns:
    the re-attached instance

### attachAll

    public Object[] attachAll(Collection objs,
                              boolean copyNew,
                              OpCallbacks call)

  Description copied from interface: `Broker`
  Import the specified objects into the broker. Instances that were previously detached from this or another broker will have their changed merged into the persistent instances. Instances that are new will be persisted as new instances.

  Specified by:
    `attachAll` in interface `Broker`
  Parameters:
    `objs` - array of instances to import
    `copyNew` - whether to copy new instances
  Returns:
    the re-attached instances

### nontransactionalAll

    public void nontransactionalAll(Collection objs,
                                    OpCallbacks call)

  Description copied from interface: `StoreContext`
  Make the given objects nontransactional.

  Specified by:
    `nontransactionalAll` in interface `StoreContext`

### nontransactional

    public void nontransactional(Object obj,
                                 OpCallbacks call)

  Description copied from interface: `StoreContext`
  Make the given object non-transactional.

  Specified by:
    `nontransactional` in interface `StoreContext`

### transactionalAll

    public void transactionalAll(Collection objs,
                                 boolean updateVersion,
                                 OpCallbacks call)

  Make the given instances transactional.

  Specified by:
    `transactionalAll` in interface `StoreContext`
  Parameters:
    `objs` - instances to make transactional
    `updateVersion` - if true, the instance's version will be incremented at the next flush

### transactional

    public void transactional(Object obj,
                              boolean updateVersion,
                              OpCallbacks call)

  Make the given instances transactional.

  Specified by:
    `transactional` in interface `StoreContext`
  Parameters:
    `obj` - instance to make transactional
    `updateVersion` - if true, the instance's version will be incremented at the next flush

### newExtent

    public Extent newExtent(Class type,
                            boolean subclasses)

  Description copied from interface: `Broker`
  Return an extent of the given class, optionally including subclasses.

  Specified by:
    `newExtent` in interface `Broker`

### extentIterator

    public Iterator extentIterator(Class type,
                                   boolean subclasses,
                                   FetchConfiguration fetch,
                                   boolean ignoreChanges)

  Description copied from interface: `StoreContext`
  Return an iterator over all instances of the given type. The iterator should be closed with `ImplHelper.close(java.lang.Object)` when no longer needed. This method delegates to `StoreManager.executeExtent(org.apache.openjpa.meta.ClassMetaData, boolean, org.apache.openjpa.kernel.FetchConfiguration)`.

  Specified by:
    `extentIterator` in interface `StoreContext`

### newQuery

    public Query newQuery(String lang,
                          Class cls,
                          Object query)

  Description copied from interface: `Broker`
  Create a new query from the given data, with the given candidate class and language.

  Specified by:
    `newQuery` in interface `Broker`

### newQuery

    public Query newQuery(String lang,
                          Object query)

  Description copied from interface: `Broker`
  Create a new query in the given language.

  Specified by:
    `newQuery` in interface `Broker`

### newQueryImpl

    protected QueryImpl newQueryImpl(String lang,
                                     StoreQuery sq)

  Create a new query.

### getIdentitySequence

    public Seq getIdentitySequence(ClassMetaData meta)

  Description copied from interface: `Broker`
  Returns a `Seq` for the datastore identity values of the specified persistent class, or null if the class' identity cannot be represented as a sequence.

  Specified by:
    `getIdentitySequence` in interface `Broker`

### getValueSequence

    public Seq getValueSequence(FieldMetaData fmd)

  Description copied from interface: `Broker`
  Returns a `Seq` for the generated values of the specified field, or null if the field is not generated.

  Specified by:
    `getValueSequence` in interface `Broker`

### lock

    public void lock(Object obj,
                     OpCallbacks call)

  Description copied from interface: `Broker`
  Ensure that the given instance is locked at the current lock level, as set in the `FetchConfiguration` for the broker.

  Specified by:
    `lock` in interface `Broker`

### lock

    public void lock(Object obj,
                     int level,
                     int timeout,
                     OpCallbacks call)

  Description copied from interface: `Broker`
  Ensure that the given instance is locked at the given lock level.

  Specified by:
    `lock` in interface `Broker`
  Parameters:
    `obj` - the object to lock
    `level` - the lock level to use
    `timeout` - the number of milliseconds to wait for the lock before giving up, or -1 for no limit

### lockAll

    public void lockAll(Collection objs,
                        OpCallbacks call)

  Description copied from interface: `Broker`
  Ensure that the given instances are locked at the current lock level, as set in the `FetchConfiguration` for the broker.

  Specified by:
    `lockAll` in interface `Broker`

### lockAll

    public void lockAll(Collection objs,
                        int level,
                        int timeout,
                        OpCallbacks call)

  Description copied from interface: `Broker`
  Ensure that the given instances are locked at the given lock level.

  Specified by:
    `lockAll` in interface `Broker`
  Parameters:
    `objs` - the objects to lock
    `level` - the lock level to use
    `timeout` - the number of milliseconds to wait for the lock before giving up, or -1 for no limit

### cancelAll

    public boolean cancelAll()

  Description copied from interface: `Broker`
  Cancel all pending data store statements. If statements are cancelled while a flush is in progress, the transaction rollback only flag will be set.

  Specified by:
    `cancelAll` in interface `Broker`
  Returns:
    true if any statements were cancelled, false otherwise

### getConnection

    public Object getConnection()

  Description copied from interface: `StoreContext`
  Return the connection in use by the context, or a new connection if none.

  Specified by:
    `getConnection` in interface `StoreContext`

### hasConnection

    public boolean hasConnection()

  Description copied from interface: `StoreContext`
  Whether the broker has a dedicated connection based on the configured connection retain mode and transaction status.

  Specified by:
    `hasConnection` in interface `StoreContext`

### getManagedObjects

    public Collection getManagedObjects()

  Description copied from interface: `StoreContext`
  Return a list of all managed instances.

  Specified by:
    `getManagedObjects` in interface `StoreContext`

### getTransactionalObjects

    public Collection getTransactionalObjects()

  Description copied from interface: `StoreContext`
  Return a list of current transaction instances.

  Specified by:
    `getTransactionalObjects` in interface `StoreContext`

### getPendingTransactionalObjects

    public Collection getPendingTransactionalObjects()

  Description copied from interface: `StoreContext`
  Return a list of instances which will become transactional upon the next transaction.

  Specified by:
    `getPendingTransactionalObjects` in interface `StoreContext`

### getDirtyObjects

    public Collection getDirtyObjects()

  Description copied from interface: `StoreContext`
  Return a list of current dirty instances.

  Specified by:
    `getDirtyObjects` in interface `StoreContext`

### getOrderDirtyObjects

    public boolean getOrderDirtyObjects()

  Description copied from interface: `StoreContext`
  Whether to maintain the order in which objects are dirtied for `StoreContext.getDirtyObjects()`. Default is the store manager's decision.

  Specified by:
    `getOrderDirtyObjects` in interface `StoreContext`

### setOrderDirtyObjects

    public void setOrderDirtyObjects(boolean order)

  Description copied from interface: `StoreContext`
  Whether to maintain the order in which objects are dirtied for `StoreContext.getDirtyObjects()`. Default is the store manager's decision.

  Specified by:
    `setOrderDirtyObjects` in interface `StoreContext`

### getManagedStates

    protected Collection getManagedStates()

  Return a copy of all managed state managers.

### getTransactionalStates

    protected Collection<StateManagerImpl> getTransactionalStates()

  Return a copy of all transactional state managers.

### getDirtyStates

    protected Collection getDirtyStates()

  Return a copy of all dirty state managers.

### getPendingTransactionalStates

    protected Collection getPendingTransactionalStates()

  Return a copy of all state managers which will become transactional upon the next transaction.

### setStateManager

    protected void setStateManager(Object id,
                                   StateManagerImpl sm,
                                   int status)

  Set the cached StateManager for the instance that had the given oid. This method must not be called multiple times for new instances.

  Parameters:
    `id` - the id previously used by the instance
    `sm` - the state manager for the instance; if the state manager is transient, we'll stop managing the instance; if it has updated its oid, we'll re-cache under the new oid
    `status` - one of our STATUS constants describing why we're setting the state manager

### addToTransaction

    void addToTransaction(StateManagerImpl sm)

  Notify the broker that the given state manager should be added to the set of instances involved in the current transaction.

### removeFromTransaction

    void removeFromTransaction(StateManagerImpl sm)

  Notify the persistence manager that the given state manager should be removed from the set of instances involved in the current transaction.

### setDirty

    void setDirty(StateManagerImpl sm,
                  boolean firstDirty)

  Notification that the given instance has been dirtied. This notification is given when an object first transitions to a dirty state, and every time the object is modified by the user thereafter.

### addToPendingTransaction

    void addToPendingTransaction(StateManagerImpl sm)

  Notify the broker that the given state manager should be added to the set of instances that will become transactional on the next transaction

### removeFromPendingTransaction

    void removeFromPendingTransaction(StateManagerImpl sm)

  Notify the persistence manager that the given state manager should be removed from the set of instances involved in the next transaction.

### addDereferencedDependent

    void addDereferencedDependent(StateManagerImpl sm)

  Add a dereferenced dependent object to the persistence manager's cache. On flush, these objects will be deleted.

### removeDereferencedDependent

    void removeDereferencedDependent(StateManagerImpl sm)

  Remove the given previously dereferenced dependent object from the cache. It is now referenced.

### dirtyType

    public void dirtyType(Class cls)

  Description copied from interface: `Broker`
  Mark the given class as dirty within the current transaction.

  Specified by:
    `dirtyType` in interface `Broker`

### getPersistedTypes

    public Collection getPersistedTypes()

  Description copied from interface: `StoreContext`
  Return the set of classes that have been made persistent in the current transaction.

  Specified by:
    `getPersistedTypes` in interface `StoreContext`

### getUpdatedTypes

    public Collection getUpdatedTypes()

  Description copied from interface: `StoreContext`
  Return the set of classes for objects that have been modified in the current transaction.

  Specified by:
    `getUpdatedTypes` in interface `StoreContext`

### getDeletedTypes

    public Collection getDeletedTypes()

  Description copied from interface: `StoreContext`
  Return the set of classes that have been deleted in the current transaction.

  Specified by:
    `getDeletedTypes` in interface `StoreContext`

### isClosed

    public boolean isClosed()

  Description copied from interface: `Broker`
  Whether the broker is closed.

  Specified by:
    `isClosed` in interface `Broker`

### isCloseInvoked

    public boolean isCloseInvoked()

  Description copied from interface: `Broker`
  Whether `Broker.close()` has been invoked, though the broker might remain open until the current managed transaction completes.

  Specified by:
    `isCloseInvoked` in interface `Broker`

### close

    public void close()

  Description copied from interface: `Broker`
  Close the broker.

  Specified by:
    `close` in interface `Broker`
  Specified by:
    `close` in interface `Closeable`

### free

    protected void free()

  Free the resources used by this persistence manager.

### lock

    public void lock()

  Description copied from interface: `StoreContext`
  Synchronizes on an internal lock if the `Multithreaded` flag is set to true. Make sure to call `StoreContext.unlock()` in a finally clause of the same method.

  Specified by:
    `lock` in interface `StoreContext`

### unlock

    public void unlock()

  Description copied from interface: `StoreContext`
  Releases the internal lock.

  Specified by:
    `unlock` in interface `StoreContext`

### newInstance

    public Object newInstance(Class cls)

  Description copied from interface: `Broker`
  Create a new instance of type `cls`. If `cls` is an interface or an abstract class whose abstract methods follow the JavaBeans convention, this method will create a concrete implementation according to the metadata that defines the class. Otherwise, if `cls` is a managed type, this will return an instance of the specified class.

  Specified by:
    `newInstance` in interface `Broker`

### getObjectId

    public Object getObjectId(Object obj)

  Description copied from interface: `StoreContext`
  Return the oid of the given instance.

  Specified by:
    `getObjectId` in interface `StoreContext`

### getLockLevel

    public int getLockLevel(Object o)

  Description copied from interface: `StoreContext`
  Return the lock level of the specified object.

  Specified by:
    `getLockLevel` in interface `StoreContext`

### getVersion

    public Object getVersion(Object obj)

  Description copied from interface: `StoreContext`
  Returns the current version indicator for `o`.

  Specified by:
    `getVersion` in interface `StoreContext`

### isDirty

    public boolean isDirty(Object obj)

  Description copied from interface: `StoreContext`
  Return whether the given object is dirty.

  Specified by:
    `isDirty` in interface `StoreContext`

### isTransactional

    public boolean isTransactional(Object obj)

  Description copied from interface: `StoreContext`
  Return whether the given object is transactional.

  Specified by:
    `isTransactional` in interface `StoreContext`

### isPersistent

    public boolean isPersistent(Object obj)

  Description copied from interface: `StoreContext`
  Return whether the given object is persistent.

  Specified by:
    `isPersistent` in interface `StoreContext`

### isNew

    public boolean isNew(Object obj)

  Description copied from interface: `StoreContext`
  Return whether the given object is a newly-created instance registered with `broker`.

  Specified by:
    `isNew` in interface `StoreContext`

### isDeleted

    public boolean isDeleted(Object obj)

  Description copied from interface: `StoreContext`
  Return whether the given object is deleted.

  Specified by:
    `isDeleted` in interface `StoreContext`

### isDetached

    public boolean isDetached(Object obj)

  Description copied from interface: `Broker`
  Returns `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`.

  Specified by:
    `isDetached` in interface `Broker`

### isDetached

    public boolean isDetached(Object obj,
                              boolean find)

  This method makes a best effort to determine if the provided object is detached.

  Parameters:
    `obj` -
    `find` - - If true, as a last resort this method will check whether or not the provided object exists in the DB. If it is in the DB, the provided object is detached.
  Returns:
    - True if the provided obj is detached, false otherwise.

### getStateManager

    public OpenJPAStateManager getStateManager(Object obj)

  Description copied from interface: `StoreContext`
  Return the state manager for the given instance. Includes objects made persistent in the current transaction. If `obj` is not a managed type or is managed by another context, throw an exception.

  Specified by:
    `getStateManager` in interface `StoreContext`

### getStateManagerImpl

    protected StateManagerImpl getStateManagerImpl(Object obj,
                                                   boolean assertThisContext)

  Return the state manager for the given instance, or null.

  Parameters:
    `assertThisContext` - if true, thow an exception if the given object is managed by another broker

### getStateManagerImplById

    protected StateManagerImpl getStateManagerImplById(Object oid,
                                                       boolean allowNew)

  Return the state manager for the given oid.

  Parameters:
    `allowNew` - if true, objects made persistent in the current transaction will be included in the search; if multiple new objects match the given oid, it is undefined which will be returned

### assertPersistenceCapable

    protected PersistenceCapable assertPersistenceCapable(Object obj)

  Return the given instance as a `PersistenceCapable`. If the instance is not manageable throw the proper exception.

### assertOpen

    public void assertOpen()

  Throw an exception if the context is closed. The exact message and content of the exception varies whether TRACE is enabled or not.

  Specified by:
    `assertOpen` in interface `Broker`

### assertActiveTransaction

    public void assertActiveTransaction()

  Description copied from interface: `Broker`
  Throw an exception if there is no active transaction.

  Specified by:
    `assertActiveTransaction` in interface `Broker`

### assertNontransactionalRead

    public void assertNontransactionalRead()

  Description copied from interface: `Broker`
  Throw an exception if there is no transaction active and nontransactional reading is not enabled.

  Specified by:
    `assertNontransactionalRead` in interface `Broker`

### assertWriteOperation

    public void assertWriteOperation()

  Description copied from interface: `Broker`
  Throw an exception if a write operation is not permitted (there is no active transaction and nontransactional writing is not enabled).

  Specified by:
    `assertWriteOperation` in interface `Broker`

### processArgument

    public Object processArgument(Object oid)

  Description copied from interface: `FindCallbacks`
  Process find argument. Throw proper `OpenJPAException` for illegal value.

  Specified by:
    `processArgument` in interface `FindCallbacks`
  Returns:
    the id to look up, or null to ignore this argument

### processReturn

    public Object processReturn(Object oid,
                                OpenJPAStateManager sm)

  Description copied from interface: `FindCallbacks`
  Process operation return value.

  Specified by:
    `processReturn` in interface `FindCallbacks`
  Returns:
    the object to return

### isSerializing

    boolean isSerializing()

  Whether or not this broker is in the midst of being serialized.

  Since:
    1.1.0

### getPrintParameters

    public boolean getPrintParameters()

  Returns:
    The value of openjpa.ConnectionFactoryProperties.PrintParameters. Default is false.

### assignObjectId

    protected void assignObjectId(Object cache,
                                  Object id,
                                  StateManagerImpl sm)

  Assign the object id to the cache. Exception will be thrown if the id already exists in the cache.

### checkForDuplicateId

    protected void checkForDuplicateId(Object id,
                                       Object obj,
                                       ClassMetaData meta)

  This method makes sure we don't already have the instance cached

### getCachePreparedQuery

    public boolean getCachePreparedQuery()

  Description copied from interface: `Broker`
  Affirms if this receiver is caching prepared queries.

  Specified by:
    `getCachePreparedQuery` in interface `Broker`

### setCachePreparedQuery

    public void setCachePreparedQuery(boolean flag)

  Description copied from interface: `Broker`
  Sets whether this receiver will cache prepared queries during its lifetime. The cache configured at BrokerFactory level is not affected by setting it inactive for this receiver.

  Specified by:
    `setCachePreparedQuery` in interface `Broker`

### getCacheFinderQuery

    public boolean getCacheFinderQuery()

### setCacheFinderQuery

    public void setCacheFinderQuery(boolean flag)

### isFromWriteBehindCallback

    public boolean isFromWriteBehindCallback()

### getConnectionFactoryName

    public String getConnectionFactoryName()

  Return the 'JTA' connectionFactoryName

  Specified by:
    `getConnectionFactoryName` in interface `StoreContext`

### setConnectionFactoryName

    public void setConnectionFactoryName(String connectionFactoryName)

  Set the 'JTA' ConnectionFactoryName. Input will be trimmed to null before being stored.

  Specified by:
    `setConnectionFactoryName` in interface `StoreContext`

### getConnectionFactory2Name

    public String getConnectionFactory2Name()

  Return the 'NonJTA' ConnectionFactoryName.

  Specified by:
    `getConnectionFactory2Name` in interface `StoreContext`

### setConnectionFactory2Name

    public void setConnectionFactory2Name(String connectionFactory2Name)

  Set the 'NonJTA' ConnectionFactoryName. Input will be trimmed to null before being stored.

  Specified by:
    `setConnectionFactory2Name` in interface `StoreContext`

### getConnectionFactory

    public Object getConnectionFactory()

  Return the 'JTA' ConnectionFactory, looking it up from JNDI if needed.

  Specified by:
    `getConnectionFactory` in interface `StoreContext`
  Returns:
    the JTA connection factory or null if connectionFactoryName is blank.

### getConnectionFactory2

    public Object getConnectionFactory2()

  Return the 'NonJTA' ConnectionFactory, looking it up from JNDI if needed.

  Specified by:
    `getConnectionFactory2` in interface `StoreContext`
  Returns:
    the NonJTA connection factory or null if connectionFactoryName is blank.

### isCached

    public boolean isCached(List<Object> oids)

  Description copied from interface: `StoreContext`
  Indicate whether the oid can be found in the StoreContext's L1 cache or in the StoreManager cache.

  Specified by:
    `isCached` in interface `StoreContext`
  Parameters:
    `oids` - List of ObjectIds for PersistenceCapables which may be found in memory.
  Returns:
    true if the oid is available in memory (cached) otherwise false.

### getAllowReferenceToSiblingContext

    public boolean getAllowReferenceToSiblingContext()

  Description copied from interface: `StoreContext`
  Affirms if this context will allow its managed instances to refer instances that are managed by other contexts.

  Specified by:
    `getAllowReferenceToSiblingContext` in interface `StoreContext`
  Returns:
    false by default.

### setAllowReferenceToSiblingContext

    public void setAllowReferenceToSiblingContext(boolean allow)

  Description copied from interface: `StoreContext`
  Affirms if this context will allow its managed instances to refer instances that are managed by other contexts. Note: Some specification (such as JPA) does not warranty predictable behavior when strict group-like property of a persistent context (where managed instances can only refer to instances managed by the same context). Please be aware of consequences when the flag is set to true.

  Specified by:
    `setAllowReferenceToSiblingContext` in interface `StoreContext`

### isFlushing

    protected boolean isFlushing()

### getPostLoadOnMerge

    public boolean getPostLoadOnMerge()

  Description copied from interface: `StoreContext`
  Force sending a @PostLoad lifecycle event while merging.

  Specified by:
    `getPostLoadOnMerge` in interface `StoreContext`
  Returns:
    `false` by default

### setPostLoadOnMerge

    public void setPostLoadOnMerge(boolean allow)

  Description copied from interface: `StoreContext`
  Set to `true` if the merge operation should trigger a @PostLoad lifecycle event.

  Specified by:
    `setPostLoadOnMerge` in interface `StoreContext`
  Parameters:
    `allow` - PostLoad lifecycle events to be triggered on a merge operation

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2006-2013 Apache Software Foundation. All Rights Reserved.