Overview | Package | Class | Tree | Deprecated | Index | Help
| SolarMetric Kodo JDO 3.2.4 generated on January 7 2005
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## kodo.runtime
Class PersistenceManagerImpl

    java.lang.Object
      |
      +--kodo.runtime.PersistenceManagerImpl

All Implemented Interfaces:
  com.solarmetric.util.Closeable, Connection, KodoPersistenceManager, KodoPersistenceManagerSPI, LocalTransaction, LocalTransaction, PersistenceManager, com.solarmetric.profile.ProfilingAgentProvider, com.solarmetric.profile.ProfilingEnvironment, Synchronization, Transaction

public class PersistenceManagerImpl
extends Object
implements KodoPersistenceManagerSPI

Concrete `PersistenceManager` for use with this common runtime. The PersistenceManager handles JDO-specific behavior, but leaves all interaction with the data store to a `StoreManager` that must be supplied at initialization.

All options defined in the JDO 1.0 specification are supported, with the exception of non durable identity and changing primary keys.

Field Summary
`protected static int` | `FLUSH_COMMIT` Flush in preparation of commit.
`protected static int` | `FLUSH_INC` Incremental flush.
`protected static int` | `FLUSH_ROLLBACK` Flush to check consistency of cache, then immediately rollback changes.

Fields inherited from interface kodo.runtime.KodoPersistenceManagerSPI
`EXCLUDE_ALL`

Fields inherited from interface kodo.runtime.KodoPersistenceManager
`CONN_RETAIN_DEMAND, CONN_RETAIN_PM, CONN_RETAIN_TRANS, DETACH_ALL, DETACH_FGS, DETACH_LOADED, LOCK_NONE, LOCK_READ, LOCK_WRITE, LOOKUP_CHECK, LOOKUP_HOLLOW`

Constructor Summary
`PersistenceManagerImpl()`

Method Summary
`void` | `afterCompletion(int status)`
`void` | `assertActiveTransaction()` Throw an exception if there is no active transaction.
`protected kodo.runtime.StateManagerImpl` | `assertManaged(Object pc)` Throw an exception if the given object is not managed; otherwise return its state manager.
`void` | `assertNontransactionalRead()` Throw an exception if there is no transaction active and nontransactional reading is not enabled.
`void` | `assertOpen()` Throw an exception if this persistence manager has been closed.
`Object` | `attach(Object pc)` JDO 2.0 Preview.
`Collection` | `attachAll(Collection pcs)` JDO 2.0 Preview.
`Object[]` | `attachAll(Object[] pcs)` JDO 2.0 Preview.
`void` | `beforeCompletion()`
`void` | `begin()`
`boolean` | `cancelAll()` Cancel all pending data store statements.
`void` | `checkConsistency()` JDO 2.0 Preview.
`void` | `close()`
`void` | `commit()`
`void` | `commitAndResume()` Issue a commit and then start a new transaction.
`Interaction` | `createInteraction()`
`Transaction` | `currentTransaction()`
`void` | `deletePersistent(Object pc)`
`void` | `deletePersistentAll(Collection pcs)`
`void` | `deletePersistentAll(Object[] pcs)`
`Object` | `detach(Object pc)` JDO 2.0 Preview.
`Collection` | `detachAll(Collection pcs)` JDO 2.0 Preview.
`Object[]` | `detachAll(Object[] pcs)` JDO 2.0 Preview.
`protected void` | `endTransaction(int status)` End the current transaction, making appropriate state transitions.
`void` | `evict(Object pc)`
`void` | `evictAll()`
`void` | `evictAll(Class cls)` Evict all persistent-clean and persistent-nontransactional instances in the extent of the given class (including subclasses).
`void` | `evictAll(Collection pcs)`
`void` | `evictAll(Extent extent)` Evict all persistent-clean and persistent-nontransactional instances in the given `Extent`.
`void` | `evictAll(Object[] pcs)`
`protected void` | `finalize()` Close on finalize.
`void` | `flush()` JDO 2.0 Preview.
`protected void` | `flushInternal(int reason)` Flush the transactional state to the data store.
`protected void` | `free()` Free the resources used by this persistence manager.
`Object` | `getCachedObjectById(Object oid)` Return the cached instance for the given oid/object, or null if not cached.
`ClassLoader` | `getClassLoader()` Return the current thread's class loader at the time this persistence manager was obtained from the persistence manager factory.
`boolean` | `getCloseOnManagedCommit()` Whether to really close in a managed environment if the close method has been called and the transaction subsequently ends.
`JDOConfiguration` | `getConfiguration()` Return the configuration associated with this persistence manager.
`Object` | `getConnection()` Return the connection in use by the persistence manager, or a new connection if none.
`String` | `getConnectionPassword()` Return the connection password.
`int` | `getConnectionRetainMode()` Return the connection retain mode for this persistence manager.
`String` | `getConnectionUserName()` Return the connection user name.
`int` | `getDetachFields()` Detach mode constant to determine which fields are part of the detached graph.
`boolean` | `getDetachOnClose()` Whether to detach all persistent managed objects when the persistence manager closes.
`Collection` | `getDirtyClasses()` Return the set of classes that have been made dirty in the current transaction.
`boolean` | `getEvictFromDataCache()` Whether to also evict an object from the data cache when it is evicted through the persistence manager.
`Extent` | `getExtent(Class type, boolean subclasses)`
`FetchConfiguration` | `getFetchConfiguration()` Return the (mutable) fetch configuration for loading objects from this persistence manager.
`boolean` | `getIgnoreCache()`
`InverseManager` | `getInverseManager()` Return the inverse manager in use.
`LocalTransaction` | `getLocalTransaction()`
`LockManager` | `getLockManager()` Return the lock manager in use.
`Log` | `getLog()`
`Collection` | `getManagedObjects()` Return a list of all managed instances.
`ManagedRuntime` | `getManagedRuntime()` Return the managed runtime in use.
`protected Collection` | `getManagedStates()`
`ConnectionMetaData` | `getMetaData()`
`boolean` | `getMultithreaded()`
`boolean` | `getNontransactionalRead()`
`boolean` | `getNontransactionalWrite()`
`Object` | `getObjectById(Object oid, boolean validate)`
`Object` | `getObjectById(Object oid, FetchConfiguration fetch, BitSet exclude, Object context)` Return the object with the given oid.
`Object` | `getObjectById(Object oid, FetchConfiguration fetch, BitSet exclude, Object context, boolean validate, boolean copyOid, boolean allowNew)` Return the object with the given oid.
`Object` | `getObjectId(Object pc)`
`Class` | `getObjectIdClass(Class cls)`
`int` | `getObjectLookupMode()` Whether to return hollow objects from `PersistenceManager.getObjectById(java.lang.Object, boolean)` when the validate parameter is false.
`Object[]` | `getObjectsById(Object[] oids, boolean validate)` JDO 2.0 Preview.
`Object[]` | `getObjectsById(Object[] oids, FetchConfiguration fetch, BitSet exclude, Object context)` Return the objects with the given oids.
`protected Object[]` | `getObjectsById(Object[] oids, FetchConfiguration fetch, BitSet exclude, Object context, boolean validate, boolean copyOids, boolean allowNew)`
`boolean` | `getOptimistic()`
`PersistenceManager` | `getPersistenceManager()`
`PersistenceManagerFactory` | `getPersistenceManagerFactory()`
`com.solarmetric.profile.ProfilingAgent` | `getProfilingAgent()`
`boolean` | `getRestoreValues()`
`ResultSetInfo` | `getResultSetInfo()`
`boolean` | `getRetainValues()`
`boolean` | `getRetainValuesInOptimistic()` Per-persistence manager configuration of whether to retain values when entering an optimistic transaction.
`boolean` | `getRollbackOnly()` JDO 2.0 Preview.
`KodoStateManager` | `getState(Object oid)` Return the state manager for the instance with the given oid.
`KodoStateManager` | `getStateManager(Object pc)` Return the state manager for the given instance.
`protected kodo.runtime.StateManagerImpl` | `getStateManager(Object pc, Object oid, boolean allowNew)` Return the StateManager for the instance with the given id.
`StoreManager` | `getStoreManager(boolean unwrap)` Return the store manager in use.
`Synchronization` | `getSynchronization()`
`Object` | `getTransactionalObjectId(Object pc)`
`Collection` | `getTransactionalObjects()` Return a list of current transaction instances.
`protected Collection` | `getTransactionalStates()` Return a copy of all transactional state managers.
`Object` | `getUserObject()`
`Object` | `getUserObject(Object key)` JDO 2.0 Preview.
`void` | `initialize(PersistenceManagerFactoryImpl factory, StoreManager sm, String user, String pass, boolean managed, int connMode)` Initialize the persistence manager.
`boolean` | `isActive()`
`boolean` | `isClosed()`
`boolean` | `isManaged()` Whether this persistence manager is using managed transactions.
`void` | `lock()` Synchronizes on an internal lock if the `Multithreaded` flag is set to true.
`void` | `lockPersistent(Object pc)` Ensure that the given instance is locked at the current lock level, as set in the `FetchConfiguration` for the persistence manager.
`void` | `lockPersistent(Object pc, int level, int timeout)` Ensure that the given instance is locked at the given lock level.
`void` | `lockPersistentAll(Collection pcs)` Ensure that the given instances are locked at the current lock level, as set in the `FetchConfiguration` for the persistence manager.
`void` | `lockPersistentAll(Collection pcs, int level, int timeout)` Ensure that the given instances are locked at the given lock level.
`void` | `lockPersistentAll(Object[] pcs)` Ensure that the given instances are locked at the current lock level, as set in the `FetchConfiguration` for the persistence manager.
`void` | `lockPersistentAll(Object[] pcs, int level, int timeout)` Ensure that the given instances are locked at the given lock level.
`void` | `makeClassDirty(Class cls)` Mark the given class as dirty within the current transaction.
`KodoStateManager` | `makeEmbedded(Object pc, KodoStateManager owner, int ownerField)` Make the given instance embedded.
`void` | `makeNontransactional(Object pc)`
`void` | `makeNontransactionalAll(Collection pcs)`
`void` | `makeNontransactionalAll(Object[] pcs)`
`void` | `makePersistent(Object pc)`
`void` | `makePersistentAll(Collection pcs)`
`void` | `makePersistentAll(Object[] pcs)`
`protected KodoStateManager` | `makePersistentInternal(Object pc)`
`void` | `makeTransactional(Object pc)`
`void` | `makeTransactionalAll(Collection pcs)`
`void` | `makeTransactionalAll(Object[] pcs)`
`void` | `makeTransient(Object pc)`
`void` | `makeTransientAll(Collection pcs)`
`void` | `makeTransientAll(Object[] pcs)`
`protected Map` | `newManagedObjectCache()` Create a `Map` to be used for the managed object cache.
`Query` | `newNamedQuery(Class cls, String name)` JDO 2.0 Preview.
`Object` | `newObjectIdInstance(Class cls, String str)`
`Query` | `newQuery()`
`Query` | `newQuery(Class cls)`
`Query` | `newQuery(Class cls, Collection cln)`
`Query` | `newQuery(Class cls, Collection cln, String filter)`
`Query` | `newQuery(Class cls, String filter)`
`Query` | `newQuery(Extent ext)`
`Query` | `newQuery(Extent ext, String filter)`
`Query` | `newQuery(Object compiled)`
`Query` | `newQuery(String language, Object compiled)`
`KodoStateManager` | `newStateManager(Object oid, boolean copyOids)` Create a new state manager with the given oid and corresponding metadata.
`Object` | `putUserObject(Object key, Object val)` JDO 2.0 Preview.
`void` | `refresh(Object pc)`
`void` | `refreshAll()`
`void` | `refreshAll(Collection pcs)`
`void` | `refreshAll(Object[] pcs)`
`void` | `registerListener(TransactionListener tl)` Register a listener for transaction-related events.
`boolean` | `removeListener(TransactionListener tl)` Remove a listener for transaction-related events.
`Object` | `removeUserObject(Object key)` JDO 2.0 Preview.
`void` | `retrieve(Object pc)`
`void` | `retrieve(Object pc, boolean dfgOnly)` Immediately load the given object's persistent fields.
`void` | `retrieveAll(Collection pcs)`
`void` | `retrieveAll(Collection pcs, boolean dfgOnly)`
`void` | `retrieveAll(Object[] pcs)`
`void` | `retrieveAll(Object[] pcs, boolean dfgOnly)`
`void` | `rollback()`
`void` | `rollbackAndResume()` Issue a rollback and then start a new transaction.
`void` | `setCloseOnManagedCommit(boolean close)` Whether to really close in a managed environment if the close method has been called and the transaction subsequently ends.
`void` | `setDetachFields(int mode)` Detach mode constant to determine which fields are part of the detached graph.
`void` | `setDetachFields(String mode)` For string-based auto-configuration of detach fields mode.
`void` | `setDetachOnClose(boolean detach)` Whether to detach all persistent managed objects when the persistence manager closes.
`void` | `setEvictFromDataCache(boolean evict)` Whether to also evict an object from the data cache when it is evicted through the persistence manager.
`void` | `setIgnoreCache(boolean val)`
`void` | `setMultithreaded(boolean multithreaded)`
`void` | `setNontransactionalRead(boolean val)`
`void` | `setNontransactionalWrite(boolean val)`
`void` | `setObjectLookupMode(int mode)` Whether to return hollow objects from `PersistenceManager.getObjectById(java.lang.Object, boolean)` when the validate parameter is false.
`void` | `setOptimistic(boolean val)`
`void` | `setRestoreValues(boolean val)`
`void` | `setRetainValues(boolean val)`
`void` | `setRetainValuesInOptimistic(boolean val)` Per-persistence manager configuration of whether to retain values when entering an optimistic transaction.
`void` | `setRollbackOnly()` JDO 2.0 Preview.
`void` | `setSynchronization(Synchronization synch)`
`void` | `setUserObject(Object o)`
`void` | `unlock()` Releases the internal lock.

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

Field Detail

### FLUSH_INC

    protected static final int FLUSH_INC

  Incremental flush.

### FLUSH_COMMIT

    protected static final int FLUSH_COMMIT

  Flush in preparation of commit.

### FLUSH_ROLLBACK

    protected static final int FLUSH_ROLLBACK

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

Constructor Detail

### PersistenceManagerImpl

    public PersistenceManagerImpl()

Method Detail

### initialize

    public void initialize(PersistenceManagerFactoryImpl factory,
                           StoreManager sm,
                           String user,
                           String pass,
                           boolean managed,
                           int connMode)

  Initialize the persistence manager. This method is called automatically by the factory before use.
  Parameters:
    `factory` - the PersistenceManagerFactory used to create this PersistenceManager
    `sm` - a concrete StoreManager implementation to handle interaction with the data store
    `user` - the username this PersistenceManager represents; used when pooling managers to make sure that a request to the PersistenceManagerFactory for a connection with an explicit user is delegated to a suitable PersistenceManager
    `pass` - the password for the above user
    `managed` - the transaction mode
    `connMode` - the connection retain mode

### finalize

    protected void finalize()
                     throws Throwable

  Close on finalize.
  Overrides:
    `finalize` in class `Object`

### newManagedObjectCache

    protected Map newManagedObjectCache()

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

### getCloseOnManagedCommit

    public boolean getCloseOnManagedCommit()

  Whether to really close in a managed environment if the close method has been called and the transaction subsequently ends. Defaults to true.

### setCloseOnManagedCommit

    public void setCloseOnManagedCommit(boolean close)

  Whether to really close in a managed environment if the close method has been called and the transaction subsequently ends. Defaults to true.

### getEvictFromDataCache

    public boolean getEvictFromDataCache()

  Whether to also evict an object from the data cache when it is evicted through the persistence manager.

### setEvictFromDataCache

    public void setEvictFromDataCache(boolean evict)

  Whether to also evict an object from the data cache when it is evicted through the persistence manager.

### getMetaData

    public ConnectionMetaData getMetaData()

  Specified by:
    `getMetaData` in interface `Connection`

### createInteraction

    public Interaction createInteraction()
                                  throws NotSupportedException

  Specified by:
    `createInteraction` in interface `Connection`

### getLocalTransaction

    public LocalTransaction getLocalTransaction()
                                         throws NotSupportedException

  Specified by:
    `getLocalTransaction` in interface `Connection`

### getResultSetInfo

    public ResultSetInfo getResultSetInfo()
                                   throws NotSupportedException

  Specified by:
    `getResultSetInfo` in interface `Connection`

### getPersistenceManager

    public PersistenceManager getPersistenceManager()

  Specified by:
    `getPersistenceManager` in interface `Transaction`

### getNontransactionalRead

    public boolean getNontransactionalRead()

  Specified by:
    `getNontransactionalRead` in interface `Transaction`

### setNontransactionalRead

    public void setNontransactionalRead(boolean val)

  Specified by:
    `setNontransactionalRead` in interface `Transaction`

### getNontransactionalWrite

    public boolean getNontransactionalWrite()

  Specified by:
    `getNontransactionalWrite` in interface `Transaction`

### setNontransactionalWrite

    public void setNontransactionalWrite(boolean val)

  Specified by:
    `setNontransactionalWrite` in interface `Transaction`

### getOptimistic

    public boolean getOptimistic()

  Specified by:
    `getOptimistic` in interface `Transaction`

### setOptimistic

    public void setOptimistic(boolean val)

  Specified by:
    `setOptimistic` in interface `Transaction`

### getRetainValues

    public boolean getRetainValues()

  Specified by:
    `getRetainValues` in interface `Transaction`

### setRetainValues

    public void setRetainValues(boolean val)

  Specified by:
    `setRetainValues` in interface `Transaction`

### getRetainValuesInOptimistic

    public boolean getRetainValuesInOptimistic()

  Description copied from interface: `KodoPersistenceManager`
  Per-persistence manager configuration of whether to retain values when entering an optimistic transaction.
  Specified by:
    `getRetainValuesInOptimistic` in interface `KodoPersistenceManager`

### setRetainValuesInOptimistic

    public void setRetainValuesInOptimistic(boolean val)

  Description copied from interface: `KodoPersistenceManager`
  Per-persistence manager configuration of whether to retain values when entering an optimistic transaction.
  Specified by:
    `setRetainValuesInOptimistic` in interface `KodoPersistenceManager`

### getObjectLookupMode

    public int getObjectLookupMode()

  Description copied from interface: `KodoPersistenceManager`
  Whether to return hollow objects from `PersistenceManager.getObjectById(java.lang.Object, boolean)` when the validate parameter is false.
  Specified by:
    `getObjectLookupMode` in interface `KodoPersistenceManager`

### setObjectLookupMode

    public void setObjectLookupMode(int mode)

  Description copied from interface: `KodoPersistenceManager`
  Whether to return hollow objects from `PersistenceManager.getObjectById(java.lang.Object, boolean)` when the validate parameter is false.
  Specified by:
    `setObjectLookupMode` in interface `KodoPersistenceManager`

### getRestoreValues

    public boolean getRestoreValues()

  Specified by:
    `getRestoreValues` in interface `Transaction`

### setRestoreValues

    public void setRestoreValues(boolean val)

  Specified by:
    `setRestoreValues` in interface `Transaction`

### getIgnoreCache

    public boolean getIgnoreCache()

  Specified by:
    `getIgnoreCache` in interface `PersistenceManager`

### setIgnoreCache

    public void setIgnoreCache(boolean val)

  Specified by:
    `setIgnoreCache` in interface `PersistenceManager`

### begin

    public void begin()

  Specified by:
    `begin` in interface `Transaction`

### commit

    public void commit()

  Specified by:
    `commit` in interface `Transaction`

### rollback

    public void rollback()

  Specified by:
    `rollback` in interface `Transaction`

### getRollbackOnly

    public boolean getRollbackOnly()

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Return whether the current transaction has been marked for rollback. In the JDO 2 specification, this is part of `Transaction`.
  Specified by:
    `getRollbackOnly` in interface `KodoPersistenceManager`

### setRollbackOnly

    public void setRollbackOnly()

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Mark the current transaction for rollback. In the JDO 2 specification, this is part of `Transaction`.
  Specified by:
    `setRollbackOnly` in interface `KodoPersistenceManager`

### flush

    public void flush()

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. 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. In this case it will throw a `JDOFatalException`.
  Specified by:
    `flush` in interface `KodoPersistenceManager`

### checkConsistency

    public void checkConsistency()

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Check the consistency of the persistence manager cache, reporting any optimistic violations, constraint violations, etc. In a datastore transaction or a flushed optimistic transaction, this method will act just like `KodoPersistenceManager.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:
    `checkConsistency` in interface `KodoPersistenceManager`

### commitAndResume

    public void commitAndResume()

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

      	pm.currentTransaction ().commit ();
      	pm.currentTransaction ().begin ();

  except that the PersistenceManager's internal atomic lock is utilized, so this method can be safely executed from multiple threads.
  Specified by:
    `commitAndResume` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  See Also:
    `Transaction.commit()`, `Transaction.begin()`

### rollbackAndResume

    public void rollbackAndResume()

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

      	pm.currentTransaction ().rollback ();
      	pm.currentTransaction ().begin ();

  except that the PersistenceManager's internal atomic lock is utilized, so this method can be safely executed from multiple threads.
  Specified by:
    `rollbackAndResume` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  See Also:
    `Transaction.rollback()`, `Transaction.begin()`

### getSynchronization

    public Synchronization getSynchronization()

  Specified by:
    `getSynchronization` in interface `Transaction`

### setSynchronization

    public void setSynchronization(Synchronization synch)

  Specified by:
    `setSynchronization` in interface `Transaction`

### isActive

    public boolean isActive()

  Specified by:
    `isActive` in interface `Transaction`

### beforeCompletion

    public void beforeCompletion()

  Specified by:
    `beforeCompletion` in interface `Synchronization`

### afterCompletion

    public void afterCompletion(int status)

  Specified by:
    `afterCompletion` in interface `Synchronization`

### flushInternal

    protected void flushInternal(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`, or `FLUSH_ROLLBACK`
  Since:
    2.5

### endTransaction

    protected void endTransaction(int status)

  End the current transaction, making appropriate state transitions.

### getConfiguration

    public JDOConfiguration getConfiguration()

  Description copied from interface: `KodoPersistenceManager`
  Return the configuration associated with this persistence manager.
  Specified by:
    `getConfiguration` in interface `KodoPersistenceManager`

### getLog

    public Log getLog()

### getFetchConfiguration

    public FetchConfiguration getFetchConfiguration()

  Description copied from interface: `KodoPersistenceManager`
  Return the (mutable) fetch configuration for loading objects from this persistence manager.
  Specified by:
    `getFetchConfiguration` in interface `KodoPersistenceManager`

### getConnectionRetainMode

    public int getConnectionRetainMode()

  Description copied from interface: `KodoPersistenceManager`
  Return the connection retain mode for this persistence manager.
  Specified by:
    `getConnectionRetainMode` in interface `KodoPersistenceManager`

### getConnection

    public Object getConnection()

  Description copied from interface: `KodoPersistenceManager`
  Return the connection in use by the persistence manager, or a new connection if none.
  Specified by:
    `getConnection` in interface `KodoPersistenceManager`

### isManaged

    public boolean isManaged()

  Description copied from interface: `KodoPersistenceManager`
  Whether this persistence manager is using managed transactions.
  Specified by:
    `isManaged` in interface `KodoPersistenceManager`

### getManagedRuntime

    public ManagedRuntime getManagedRuntime()

  Description copied from interface: `KodoPersistenceManager`
  Return the managed runtime in use.
  Specified by:
    `getManagedRuntime` in interface `KodoPersistenceManager`

### getClassLoader

    public ClassLoader getClassLoader()

  Description copied from interface: `KodoPersistenceManager`
  Return the current thread's class loader at the time this persistence manager was obtained from the persistence manager factory.
  Specified by:
    `getClassLoader` in interface `KodoPersistenceManager`

### getConnectionUserName

    public String getConnectionUserName()

  Description copied from interface: `KodoPersistenceManager`
  Return the connection user name.
  Specified by:
    `getConnectionUserName` in interface `KodoPersistenceManager`

### getConnectionPassword

    public String getConnectionPassword()

  Description copied from interface: `KodoPersistenceManager`
  Return the connection password.
  Specified by:
    `getConnectionPassword` in interface `KodoPersistenceManager`

### getProfilingAgent

    public com.solarmetric.profile.ProfilingAgent getProfilingAgent()

  Specified by:
    `getProfilingAgent` in interface `com.solarmetric.profile.ProfilingAgentProvider`

### makeClassDirty

    public void makeClassDirty(Class cls)

  Description copied from interface: `KodoPersistenceManager`
  Mark the given class as dirty within the current transaction.
  Specified by:
    `makeClassDirty` in interface `KodoPersistenceManager`

### getDirtyClasses

    public Collection getDirtyClasses()

  Description copied from interface: `KodoPersistenceManager`
  Return the set of classes that have been made dirty in the current transaction. Classes are made dirty automatically when an instance becomes dirty, or through explicit calls to `KodoPersistenceManager.makeClassDirty(java.lang.Class)`.
  Specified by:
    `getDirtyClasses` in interface `KodoPersistenceManager`

### putUserObject

    public Object putUserObject(Object key,
                                Object val)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Put the specified key-value pair into the map of user objects.
  Specified by:
    `putUserObject` in interface `KodoPersistenceManager`

### getUserObject

    public Object getUserObject(Object key)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Get the value for the specified key from the map of user objects.
  Specified by:
    `getUserObject` in interface `KodoPersistenceManager`

### removeUserObject

    public Object removeUserObject(Object key)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Remove the specified key and its value from the map of user objects.
  Specified by:
    `removeUserObject` in interface `KodoPersistenceManager`

### getUserObject

    public Object getUserObject()

  Specified by:
    `getUserObject` in interface `PersistenceManager`

### setUserObject

    public void setUserObject(Object o)

  Specified by:
    `setUserObject` in interface `PersistenceManager`

### getPersistenceManagerFactory

    public PersistenceManagerFactory getPersistenceManagerFactory()

  Specified by:
    `getPersistenceManagerFactory` in interface `PersistenceManager`

### getMultithreaded

    public boolean getMultithreaded()

  Specified by:
    `getMultithreaded` in interface `PersistenceManager`

### setMultithreaded

    public void setMultithreaded(boolean multithreaded)

  Specified by:
    `setMultithreaded` in interface `PersistenceManager`

### registerListener

    public void registerListener(TransactionListener tl)

  Description copied from interface: `KodoPersistenceManager`
  Register a listener for transaction-related events.
  Specified by:
    `registerListener` in interface `KodoPersistenceManager`

### removeListener

    public boolean removeListener(TransactionListener tl)

  Description copied from interface: `KodoPersistenceManager`
  Remove a listener for transaction-related events.
  Specified by:
    `removeListener` in interface `KodoPersistenceManager`

### currentTransaction

    public Transaction currentTransaction()

  Specified by:
    `currentTransaction` in interface `PersistenceManager`

### cancelAll

    public boolean cancelAll()

  Description copied from interface: `KodoPersistenceManager`
  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 `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Returns:
    true if any statements were cancelled, false otherwise

### isClosed

    public boolean isClosed()

  Specified by:
    `isClosed` in interface `PersistenceManager`

### close

    public void close()

  Specified by:
    `close` in interface `PersistenceManager`

### free

    protected void free()

  Free the resources used by this persistence manager.

### getObjectId

    public Object getObjectId(Object pc)

  Specified by:
    `getObjectId` in interface `PersistenceManager`

### getTransactionalObjectId

    public Object getTransactionalObjectId(Object pc)

  Specified by:
    `getTransactionalObjectId` in interface `PersistenceManager`

### getObjectIdClass

    public Class getObjectIdClass(Class cls)

  Specified by:
    `getObjectIdClass` in interface `PersistenceManager`

### newObjectIdInstance

    public Object newObjectIdInstance(Class cls,
                                      String str)

  Specified by:
    `newObjectIdInstance` in interface `PersistenceManager`

### getObjectById

    public Object getObjectById(Object oid,
                                boolean validate)

  Specified by:
    `getObjectById` in interface `PersistenceManager`

### getObjectById

    public Object getObjectById(Object oid,
                                FetchConfiguration fetch,
                                BitSet exclude,
                                Object context)

  Description copied from interface: `KodoPersistenceManagerSPI`
  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 context information, and the system will load the object according to the given fetch configuratiion (or the persistence manager's configuration, if the given one is null). Fields can optionally be excluded from required loading using the `exclude` mask.
  Specified by:
    `getObjectById` in interface `KodoPersistenceManagerSPI`

### getObjectById

    public Object getObjectById(Object oid,
                                FetchConfiguration fetch,
                                BitSet exclude,
                                Object context,
                                boolean validate,
                                boolean copyOid,
                                boolean allowNew)

  Description copied from interface: `KodoPersistenceManagerSPI`
  Return the object with the given oid.
  Specified by:
    `getObjectById` in interface `KodoPersistenceManagerSPI`
  Following copied from interface: `kodo.runtime.KodoPersistenceManagerSPI`
  See Also:
    `KodoPersistenceManagerSPI.getObjectById(Object,FetchConfiguration,BitSet,Object)`

### newStateManager

    public KodoStateManager newStateManager(Object oid,
                                            boolean copyOids)

  Create a new state manager with the given oid and corresponding metadata.
  Specified by:
    `newStateManager` in interface `KodoPersistenceManagerSPI`

### getObjectsById

    public Object[] getObjectsById(Object[] oids,
                                   boolean validate)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Return the objects with the given oids.
  Specified by:
    `getObjectsById` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `oids` - the oids of the objects to return
    `validate` - if true, the existance of the objects in the datastore will be validated.
  Returns:
    the objects that were looked up, in the same order as the oids parameter.
  See Also:
    `PersistenceManager.getObjectById(Object,boolean)`

### getObjectsById

    public Object[] getObjectsById(Object[] oids,
                                   FetchConfiguration fetch,
                                   BitSet exclude,
                                   Object context)

  Description copied from interface: `KodoPersistenceManagerSPI`
  Return the objects with the given oids. 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 context information, and the system will load the object according to the given fetch configuratiion (or the persistence manager's configuration, if the given one is null). This method is provided as an optimization opportunity to concrete jdo implementations built on this common runtime. It is not for use by client code.
  Specified by:
    `getObjectsById` in interface `KodoPersistenceManagerSPI`

### getObjectsById

    protected Object[] getObjectsById(Object[] oids,
                                      FetchConfiguration fetch,
                                      BitSet exclude,
                                      Object context,
                                      boolean validate,
                                      boolean copyOids,
                                      boolean allowNew)

### getCachedObjectById

    public Object getCachedObjectById(Object oid)

  Description copied from interface: `KodoPersistenceManager`
  Return the cached instance for the given oid/object, or null if not cached.
  Specified by:
    `getCachedObjectById` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `oid` - the object's id
  Returns:
    the cached object, or null if not cached

### makePersistentAll

    public void makePersistentAll(Collection pcs)

  Specified by:
    `makePersistentAll` in interface `PersistenceManager`

### makePersistentAll

    public void makePersistentAll(Object[] pcs)

  Specified by:
    `makePersistentAll` in interface `PersistenceManager`

### makePersistent

    public void makePersistent(Object pc)

  Specified by:
    `makePersistent` in interface `PersistenceManager`

### makePersistentInternal

    protected KodoStateManager makePersistentInternal(Object pc)

### deletePersistentAll

    public void deletePersistentAll(Collection pcs)

  Specified by:
    `deletePersistentAll` in interface `PersistenceManager`

### deletePersistentAll

    public void deletePersistentAll(Object[] pcs)

  Specified by:
    `deletePersistentAll` in interface `PersistenceManager`

### deletePersistent

    public void deletePersistent(Object pc)

  Specified by:
    `deletePersistent` in interface `PersistenceManager`

### makeNontransactionalAll

    public void makeNontransactionalAll(Collection pcs)

  Specified by:
    `makeNontransactionalAll` in interface `PersistenceManager`

### makeNontransactionalAll

    public void makeNontransactionalAll(Object[] pcs)

  Specified by:
    `makeNontransactionalAll` in interface `PersistenceManager`

### makeNontransactional

    public void makeNontransactional(Object pc)

  Specified by:
    `makeNontransactional` in interface `PersistenceManager`

### makeTransactionalAll

    public void makeTransactionalAll(Collection pcs)

  Specified by:
    `makeTransactionalAll` in interface `PersistenceManager`

### makeTransactionalAll

    public void makeTransactionalAll(Object[] pcs)

  Specified by:
    `makeTransactionalAll` in interface `PersistenceManager`

### makeTransactional

    public void makeTransactional(Object pc)

  Specified by:
    `makeTransactional` in interface `PersistenceManager`

### makeTransientAll

    public void makeTransientAll(Collection pcs)

  Specified by:
    `makeTransientAll` in interface `PersistenceManager`

### makeTransientAll

    public void makeTransientAll(Object[] pcs)

  Specified by:
    `makeTransientAll` in interface `PersistenceManager`

### makeTransient

    public void makeTransient(Object pc)

  Specified by:
    `makeTransient` in interface `PersistenceManager`

### makeEmbedded

    public KodoStateManager makeEmbedded(Object pc,
                                         KodoStateManager owner,
                                         int ownerField)

  Description copied from interface: `KodoPersistenceManagerSPI`
  Make the given instance embedded.
  Specified by:
    `makeEmbedded` in interface `KodoPersistenceManagerSPI`
  Following copied from interface: `kodo.runtime.KodoPersistenceManagerSPI`
  Parameters:
    `pc` - the instance to embed, or null to embed a newly-created instance that will be loaded with datastore data
    `owner` - the owning state manager
    `ownerField` - the field number of the owning object
  Returns:
    the state manager for the embedded instance

### refreshAll

    public void refreshAll()

  Specified by:
    `refreshAll` in interface `PersistenceManager`

### refreshAll

    public void refreshAll(Collection pcs)

  Specified by:
    `refreshAll` in interface `PersistenceManager`

### refreshAll

    public void refreshAll(Object[] pcs)

  Specified by:
    `refreshAll` in interface `PersistenceManager`

### refresh

    public void refresh(Object pc)

  Specified by:
    `refresh` in interface `PersistenceManager`

### retrieveAll

    public void retrieveAll(Collection pcs)

  Specified by:
    `retrieveAll` in interface `PersistenceManager`

### retrieveAll

    public void retrieveAll(Collection pcs,
                            boolean dfgOnly)

  Specified by:
    `retrieveAll` in interface `PersistenceManager`

### retrieveAll

    public void retrieveAll(Object[] pcs)

  Specified by:
    `retrieveAll` in interface `PersistenceManager`

### retrieveAll

    public void retrieveAll(Object[] pcs,
                            boolean dfgOnly)

  Specified by:
    `retrieveAll` in interface `PersistenceManager`

### retrieve

    public void retrieve(Object pc)

  Specified by:
    `retrieve` in interface `PersistenceManager`

### retrieve

    public void retrieve(Object pc,
                         boolean dfgOnly)

  Description copied from interface: `KodoPersistenceManager`
  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.
  Specified by:
    `retrieve` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pc` - the instance whose fields should be retrieved
    `dfgOnly` - indicator as to whether to retrieve only fields in the current fetch groups, or all fields
  See Also:
    `PersistenceManager.retrieveAll(Collection,boolean)`

### evictAll

    public void evictAll()

  Specified by:
    `evictAll` in interface `PersistenceManager`

### evictAll

    public void evictAll(Collection pcs)

  Specified by:
    `evictAll` in interface `PersistenceManager`

### evictAll

    public void evictAll(Object[] pcs)

  Specified by:
    `evictAll` in interface `PersistenceManager`

### evictAll

    public void evictAll(Class cls)

  Description copied from interface: `KodoPersistenceManager`
  Evict all persistent-clean and persistent-nontransactional instances in the extent of the given class (including subclasses).
  Specified by:
    `evictAll` in interface `KodoPersistenceManager`

### evictAll

    public void evictAll(Extent extent)

  Description copied from interface: `KodoPersistenceManager`
  Evict all persistent-clean and persistent-nontransactional instances in the given `Extent`.
  Specified by:
    `evictAll` in interface `KodoPersistenceManager`

### evict

    public void evict(Object pc)

  Specified by:
    `evict` in interface `PersistenceManager`

### lockPersistent

    public void lockPersistent(Object pc)

  Description copied from interface: `KodoPersistenceManager`
  Ensure that the given instance is locked at the current lock level, as set in the `FetchConfiguration` for the persistence manager.
  Specified by:
    `lockPersistent` in interface `KodoPersistenceManager`

### lockPersistent

    public void lockPersistent(Object pc,
                               int level,
                               int timeout)

  Description copied from interface: `KodoPersistenceManager`
  Ensure that the given instance is locked at the given lock level.
  Specified by:
    `lockPersistent` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pc` - 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

### lockPersistentAll

    public void lockPersistentAll(Collection pcs)

  Description copied from interface: `KodoPersistenceManager`
  Ensure that the given instances are locked at the current lock level, as set in the `FetchConfiguration` for the persistence manager.
  Specified by:
    `lockPersistentAll` in interface `KodoPersistenceManager`

### lockPersistentAll

    public void lockPersistentAll(Collection pcs,
                                  int level,
                                  int timeout)

  Description copied from interface: `KodoPersistenceManager`
  Ensure that the given instances are locked at the given lock level.
  Specified by:
    `lockPersistentAll` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pcs` - 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

### lockPersistentAll

    public void lockPersistentAll(Object[] pcs)

  Description copied from interface: `KodoPersistenceManager`
  Ensure that the given instances are locked at the current lock level, as set in the `FetchConfiguration` for the persistence manager.
  Specified by:
    `lockPersistentAll` in interface `KodoPersistenceManager`

### lockPersistentAll

    public void lockPersistentAll(Object[] pcs,
                                  int level,
                                  int timeout)

  Description copied from interface: `KodoPersistenceManager`
  Ensure that the given instances are locked at the given lock level.
  Specified by:
    `lockPersistentAll` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pcs` - 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

### getExtent

    public Extent getExtent(Class type,
                            boolean subclasses)

  Specified by:
    `getExtent` in interface `PersistenceManager`

### newQuery

    public Query newQuery()

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(Class cls)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(Class cls,
                          Collection cln)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(Extent ext)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(Class cls,
                          Collection cln,
                          String filter)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(Extent ext,
                          String filter)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(Class cls,
                          String filter)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(Object compiled)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newQuery

    public Query newQuery(String language,
                          Object compiled)

  Specified by:
    `newQuery` in interface `PersistenceManager`

### newNamedQuery

    public Query newNamedQuery(Class cls,
                               String name)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Return the named query defined in the metadata.
  Specified by:
    `newNamedQuery` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `cls` - if not null, the candidate class to query
    `name` - the name of the query to lookup
  Returns:
    a `Query` instance based on the information defined in the metadata

### lock

    public void lock()

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

### unlock

    public void unlock()

  Description copied from interface: `KodoPersistenceManagerSPI`
  Releases the internal lock.
  Specified by:
    `unlock` in interface `KodoPersistenceManagerSPI`

### getStoreManager

    public StoreManager getStoreManager(boolean unwrap)

  Description copied from interface: `KodoPersistenceManagerSPI`
  Return the store manager in use.
  Specified by:
    `getStoreManager` in interface `KodoPersistenceManagerSPI`
  Following copied from interface: `kodo.runtime.KodoPersistenceManagerSPI`
  Parameters:
    `unwrap` - if true, the native store manager will be returned; otherwise, the store manager used by this persistence manager, which may be a decorator around the native store manager, will be returned

### getLockManager

    public LockManager getLockManager()

  Description copied from interface: `KodoPersistenceManagerSPI`
  Return the lock manager in use.
  Specified by:
    `getLockManager` in interface `KodoPersistenceManagerSPI`

### getInverseManager

    public InverseManager getInverseManager()

  Description copied from interface: `KodoPersistenceManagerSPI`
  Return the inverse manager in use.
  Specified by:
    `getInverseManager` in interface `KodoPersistenceManagerSPI`

### getState

    public KodoStateManager getState(Object oid)

  Description copied from interface: `KodoPersistenceManager`
  Return the state manager for the instance with the given oid. Includes objects made persistent in the current transaction.
  Specified by:
    `getState` in interface `KodoPersistenceManager`

### getStateManager

    public KodoStateManager getStateManager(Object pc)

  Description copied from interface: `KodoPersistenceManagerSPI`
  Return the state manager for the given instance. Includes objects made persistent in the current transaction.
  Specified by:
    `getStateManager` in interface `KodoPersistenceManagerSPI`

### getStateManager

    protected kodo.runtime.StateManagerImpl getStateManager(Object pc,
                                                            Object oid,
                                                            boolean allowNew)

  Return the StateManager for the instance with the given id.
  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 undetermined which will be returned

### getManagedObjects

    public Collection getManagedObjects()

  Description copied from interface: `KodoPersistenceManager`
  Return a list of all managed instances.
  Specified by:
    `getManagedObjects` in interface `KodoPersistenceManager`

### getTransactionalObjects

    public Collection getTransactionalObjects()

  Description copied from interface: `KodoPersistenceManager`
  Return a list of current transaction instances.
  Specified by:
    `getTransactionalObjects` in interface `KodoPersistenceManager`

### getManagedStates

    protected Collection getManagedStates()

### getTransactionalStates

    protected Collection getTransactionalStates()

  Return a copy of all transactional state managers.

### getDetachOnClose

    public boolean getDetachOnClose()

  Description copied from interface: `KodoPersistenceManager`
  Whether to detach all persistent managed objects when the persistence manager closes.
  Specified by:
    `getDetachOnClose` in interface `KodoPersistenceManager`

### setDetachOnClose

    public void setDetachOnClose(boolean detach)

  Description copied from interface: `KodoPersistenceManager`
  Whether to detach all persistent managed objects when the persistence manager closes.
  Specified by:
    `setDetachOnClose` in interface `KodoPersistenceManager`

### setDetachFields

    public void setDetachFields(String mode)

  For string-based auto-configuration of detach fields mode.

### getDetachFields

    public int getDetachFields()

  Description copied from interface: `KodoPersistenceManager`
  Detach mode constant to determine which fields are part of the detached graph. Defaults to `KodoPersistenceManager.DETACH_FGS`.
  Specified by:
    `getDetachFields` in interface `KodoPersistenceManager`

### setDetachFields

    public void setDetachFields(int mode)

  Description copied from interface: `KodoPersistenceManager`
  Detach mode constant to determine which fields are part of the detached graph. Defaults to `KodoPersistenceManager.DETACH_FGS`.
  Specified by:
    `setDetachFields` in interface `KodoPersistenceManager`

### detach

    public Object detach(Object pc)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Detach the specified object from the PersistenceManager.
  Specified by:
    `detach` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pc` - the instance to detach
  Returns:
    the detached instance
  See Also:
    `KodoPersistenceManager.detachAll(Object[])`

### detachAll

    public Object[] detachAll(Object[] pcs)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Detach the specified objects from the PersistenceManager. The objects returned can be manipulated and re-attached with `KodoPersistenceManager.attachAll(Object[])`. The detached instances will be unmanaged copies of the specified parameters, and are suitable for serialization and manipulation outside of a Kodo 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 `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pcs` - the instances to detach
  Returns:
    the detached instances
  Throws:
    `JDOUserException` - if any of the instances do not have the `detachable` metadata extension.
  See Also:
    `KodoPersistenceManager.attachAll(Object[])`, `KodoHelper.getDetachedObjectId(java.lang.Object)`, `KodoHelper.getDetachedState(java.lang.Object)`, `KodoPersistenceManager.getFetchConfiguration()`

### detachAll

    public Collection detachAll(Collection pcs)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Detach the specified objects from the PersistenceManager.
  Specified by:
    `detachAll` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pcs` - the instances to detach
  Returns:
    the detached instances
  See Also:
    `KodoPersistenceManager.detachAll(Object[])`

### attach

    public Object attach(Object pc)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Import the specified object into the PersistenceManager.
  Specified by:
    `attach` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pc` - instance to import
  Returns:
    the re-attached instance
  See Also:
    `KodoPersistenceManager.attachAll(Object[])`

### attachAll

    public Object[] attachAll(Object[] pcs)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Import the specified objects into the PersistenceManager. Instances that were previously detached from this or another PersistenceManager will have their changed merged into the persistent instances. Instances that are new will be persisted as new instances.
  Specified by:
    `attachAll` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pcs` - array of instances to import
  Returns:
    the re-attached instances
  Throws:
    `JDOUserException` - if any of the instances are not detachable, or if there is not a current active transaction.
    `JDOOptimisticVerificationException` - when attempting to attaching instance that has been deleted in the data store, or when attaching an instance into a PersistenceManager that currently has cached an earlier version of that instance.
  See Also:
    `KodoPersistenceManager.detachAll(Object[])`

### attachAll

    public Collection attachAll(Collection pcs)

  Description copied from interface: `KodoPersistenceManager`
  JDO 2.0 Preview. Import the specified objects into the PersistenceManager.
  Specified by:
    `attachAll` in interface `KodoPersistenceManager`
  Following copied from interface: `kodo.runtime.KodoPersistenceManager`
  Parameters:
    `pcs` - Collection of instances to import
  Returns:
    the re-attached instances
  See Also:
    `KodoPersistenceManager.attachAll(Object[])`

### assertOpen

    public void assertOpen()

  Description copied from interface: `KodoPersistenceManagerSPI`
  Throw an exception if this persistence manager has been closed.
  Specified by:
    `assertOpen` in interface `KodoPersistenceManagerSPI`

### assertActiveTransaction

    public void assertActiveTransaction()

  Description copied from interface: `KodoPersistenceManagerSPI`
  Throw an exception if there is no active transaction.
  Specified by:
    `assertActiveTransaction` in interface `KodoPersistenceManagerSPI`

### assertNontransactionalRead

    public void assertNontransactionalRead()

  Description copied from interface: `KodoPersistenceManagerSPI`
  Throw an exception if there is no transaction active and nontransactional reading is not enabled.
  Specified by:
    `assertNontransactionalRead` in interface `KodoPersistenceManagerSPI`

### assertManaged

    protected kodo.runtime.StateManagerImpl assertManaged(Object pc)

  Throw an exception if the given object is not managed; otherwise return its state manager.

Overview | Package | Class | Tree | Deprecated | Index | Help
| SolarMetric Kodo JDO 3.2.4 generated on January 7 2005
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright 2001,2002 SolarMetric, Inc. All Rights Reserved.