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

## javax.jdo
Interface PersistenceManager

public interface PersistenceManager

`PersistenceManager` is the primary interface for JDO-aware application components. It is the factory for `Query` and `Transaction` instances, and contains methods to manage the life cycle of `PersistenceCapable` instances.

A `PersistenceManager` is obtained from the `PersistenceManagerFactory` (recommended) or by construction.

Version:
  0.9
Author:
  Craig Russell

Method Summary
`void` | `close()` Close this `PersistenceManager` so that no further requests may be made on it.
`Transaction` | `currentTransaction()` Return the `Transaction` instance associated with a `PersistenceManager`.
`void` | `deletePersistent(java.lang.Object pc)` Delete the persistent instance from the data store.
`void` | `deletePersistentAll(java.util.Collection pcs)` Delete a `Collection` of instances from the data store.
`void` | `deletePersistentAll(java.lang.Object[] pcs)` Delete an array of instances from the data store.
`void` | `evict(java.lang.Object pc)` Mark an instance as no longer needed in the cache.
`void` | `evictAll()` Mark all persistent-nontransactional instances as no longer needed in the cache.
`void` | `evictAll(java.util.Collection pcs)` Mark a `Collection` of instances as no longer needed in the cache.
`void` | `evictAll(java.lang.Object[] pcs)` Mark an array of instances as no longer needed in the cache.
`Extent` | `getExtent(java.lang.Class persistenceCapableClass, boolean subclasses)` The `PersistenceManager` manages a collection of instances in the data store based on the class of the instances.
`boolean` | `getIgnoreCache()` Get the ignoreCache setting for queries.
`boolean` | `getMultithreaded()` Get the current Multithreaded flag for this `PersistenceManager`.
`java.lang.Object` | `getObjectById(java.lang.Object oid, boolean validate)` This method locates a persistent instance in the cache of instances managed by this `PersistenceManager`.
`java.lang.Object` | `getObjectId(java.lang.Object pc)` The ObjectId returned by this method represents the JDO identity of the instance.
`java.lang.Class` | `getObjectIdClass(java.lang.Class cls)` Return the `Class` that implements the JDO Identity for the specified `PersistenceCapable` class.
`PersistenceManagerFactory` | `getPersistenceManagerFactory()` This method returns the `PersistenceManagerFactory` used to create this `PersistenceManager`.
`java.lang.Object` | `getTransactionalObjectId(java.lang.Object pc)` The ObjectId returned by this method represents the JDO identity of the instance.
`java.lang.Object` | `getUserObject()` The application can manage the `PersistenceManager` instances more easily by having an application object associated with each `PersistenceManager` instance.
`boolean` | `isClosed()` A `PersistenceManager` instance can be used until it is closed.
`void` | `makeNontransactional(java.lang.Object pc)` Make an instance non-transactional after commit.
`void` | `makeNontransactionalAll(java.util.Collection pcs)` Make a `Collection` of instances non-transactional after commit.
`void` | `makeNontransactionalAll(java.lang.Object[] pcs)` Make an array of instances non-transactional after commit.
`void` | `makePersistent(java.lang.Object pc)` Make the transient instance persistent in this `PersistenceManager`.
`void` | `makePersistentAll(java.util.Collection pcs)` Make a `Collection` of instances persistent.
`void` | `makePersistentAll(java.lang.Object[] pcs)` Make an array of instances persistent.
`void` | `makeTransactional(java.lang.Object pc)` Make an instance subject to transactional boundaries.
`void` | `makeTransactionalAll(java.util.Collection pcs)` Make a `Collection` of instances subject to transactional boundaries.
`void` | `makeTransactionalAll(java.lang.Object[] pcs)` Make an array of instances subject to transactional boundaries.
`void` | `makeTransient(java.lang.Object pc)` Make an instance transient, removing it from management by this `PersistenceManager`.
`void` | `makeTransientAll(java.util.Collection pcs)` Make a `Collection` of instances transient, removing them from management by this `PersistenceManager`.
`void` | `makeTransientAll(java.lang.Object[] pcs)` Make an array of instances transient, removing them from management by this `PersistenceManager`.
`java.lang.Object` | `newObjectIdInstance(java.lang.Class pcClass, java.lang.String str)` This method returns an object id instance corresponding to the `Class` and `String` arguments.
`Query` | `newQuery()` Create a new `Query` with no elements.
`Query` | `newQuery(java.lang.Class cls)` Create a new `Query` specifying the `Class` of the candidate instances.
`Query` | `newQuery(java.lang.Class cls, java.util.Collection cln)` Create a new `Query` with the candidate `Class` and `Collection`.
`Query` | `newQuery(java.lang.Class cls, java.util.Collection cln, java.lang.String filter)` Create a new `Query` with the `Class` of the candidate instances, candidate `Collection`, and filter.
`Query` | `newQuery(java.lang.Class cls, java.lang.String filter)` Create a new `Query` with the `Class` of the candidate instances and filter.
`Query` | `newQuery(Extent cln)` Create a new `Query` with the `Class` of the candidate instances and candidate `Extent`.
`Query` | `newQuery(Extent cln, java.lang.String filter)` Create a new `Query` with the candidate `Extent` and filter; the class is taken from the `Extent`.
`Query` | `newQuery(java.lang.Object compiled)` Create a new `Query` using elements from another `Query`.
`Query` | `newQuery(java.lang.String language, java.lang.Object query)` Create a new `Query` using the specified language.
`void` | `refresh(java.lang.Object pc)` Refresh the state of the instance from the data store.
`void` | `refreshAll()` Refresh the state of all applicable instances from the data store.
`void` | `refreshAll(java.util.Collection pcs)` Refresh the state of a `Collection` of instances from the data store.
`void` | `refreshAll(java.lang.Object[] pcs)` Refresh the state of an array of instances from the data store.
`void` | `retrieve(java.lang.Object pc)` Retrieve an instance from the store.
`void` | `retrieveAll(java.util.Collection pcs)` Retrieve instances from the store.
`void` | `retrieveAll(java.lang.Object[] pcs)` Retrieve instances from the store.
`void` | `setIgnoreCache(boolean flag)` Set the ignoreCache parameter for queries.
`void` | `setMultithreaded(boolean flag)` Set the Multithreaded flag for this `PersistenceManager`.
`void` | `setUserObject(java.lang.Object o)` The application can manage the `PersistenceManager` instances more easily by having an application object associated with each `PersistenceManager` instance.

Method Detail

### isClosed

    public boolean isClosed()

  A `PersistenceManager` instance can be used until it is closed.

  Returns:
    `true` if this `PersistenceManager` has been closed.
  See Also:
    `close()`

### close

    public void close()

  Close this `PersistenceManager` so that no further requests may be made on it. A `PersistenceManager` instance can be used only until it is closed.

  Closing a `PersistenceManager` might release it to the pool of available `PersistenceManager`s, or might be garbage collected, at the option of the JDO implementation. Before being used again to satisfy a `getPersistenceManager()` request, the default values for options will be restored to their values as specified in the `PersistenceManagerFactory`.

  This method closes the `PersistenceManager`.

### currentTransaction

    public Transaction currentTransaction()

  Return the `Transaction` instance associated with a `PersistenceManager`. There is one `Transaction` instance associated with each `PersistenceManager` instance. The `Transaction` instance supports options as well as transaction completion requests.

  Returns:
    the `Transaction` associated with this `PersistenceManager`.

### evict

    public void evict(java.lang.Object pc)

  Mark an instance as no longer needed in the cache. Eviction is normally done automatically by the `PersistenceManager` at transaction completion. This method allows the application to explicitly provide a hint to the `PersistenceManager` that the instance is no longer needed in the cache.

  Parameters:
    `pc` - the instance to evict from the cache.

### evictAll

    public void evictAll(java.lang.Object[] pcs)

  Mark an array of instances as no longer needed in the cache.

  Parameters:
    `pcs` - the array of instances to evict from the cache.
  See Also:
    `evict(Object pc)`

### evictAll

    public void evictAll(java.util.Collection pcs)

  Mark a `Collection` of instances as no longer needed in the cache.

  Parameters:
    `pcs` - the `Collection` of instances to evict from the cache.
  See Also:
    `evict(Object pc)`

### evictAll

    public void evictAll()

  Mark all persistent-nontransactional instances as no longer needed in the cache. It transitions all persistent-nontransactional instances to hollow. Transactional instances are subject to eviction based on the RetainValues setting.

  See Also:
    `evict(Object pc)`

### refresh

    public void refresh(java.lang.Object pc)

  Refresh the state of the instance from the data store.

  In an optimistic transaction, the state of instances in the cache might not match the state in the data store. This method is used to reload the state of the instance from the data store so that a subsequent commit is more likely to succeed.

  Outside a transaction, this method will refresh nontransactional state.

  Parameters:
    `pc` - the instance to refresh.

### refreshAll

    public void refreshAll(java.lang.Object[] pcs)

  Refresh the state of an array of instances from the data store.

  Parameters:
    `pcs` - the array of instances to refresh.
  See Also:
    `refresh(Object pc)`

### refreshAll

    public void refreshAll(java.util.Collection pcs)

  Refresh the state of a `Collection` of instances from the data store.

  Parameters:
    `pcs` - the `Collection` of instances to refresh.
  See Also:
    `refresh(Object pc)`

### refreshAll

    public void refreshAll()

  Refresh the state of all applicable instances from the data store.

  If called with an active transaction, all transactional instances will be refreshed. If called outside an active transaction, all nontransactional instances will be refreshed.

  See Also:
    `refresh(Object pc)`

### newQuery

    public Query newQuery()

  Create a new `Query` with no elements.

  Returns:
    the new `Query`.

### newQuery

    public Query newQuery(java.lang.Object compiled)

  Create a new `Query` using elements from another `Query`. The other `Query` must have been created by the same JDO implementation. It might be active in a different `PersistenceManager` or might have been serialized and restored.

  All of the settings of the other `Query` are copied to this `Query`, except for the candidate `Collection` or `Extent`.

  Parameters:
    `compiled` - another `Query` from the same JDO implementation
  Returns:
    the new `Query`

### newQuery

    public Query newQuery(java.lang.String language,
                          java.lang.Object query)

  Create a new `Query` using the specified language.

  Parameters:
    `language` - the language of the query parameter
    `query` - the query, which is of a form determined by the language
  Returns:
    the new `Query`

### newQuery

    public Query newQuery(java.lang.Class cls)

  Create a new `Query` specifying the `Class` of the candidate instances.

  Parameters:
    `cls` - the `Class` of the candidate instances
  Returns:
    the new `Query`

### newQuery

    public Query newQuery(Extent cln)

  Create a new `Query` with the `Class` of the candidate instances and candidate `Extent`.

  Parameters:
    `cln` - the `Extent` of candidate instances
  Returns:
    the new `Query`

### newQuery

    public Query newQuery(java.lang.Class cls,
                          java.util.Collection cln)

  Create a new `Query` with the candidate `Class` and `Collection`.

  Parameters:
    `cls` - the `Class` of results
    `cln` - the `Collection` of candidate instances
  Returns:
    the new `Query`

### newQuery

    public Query newQuery(java.lang.Class cls,
                          java.lang.String filter)

  Create a new `Query` with the `Class` of the candidate instances and filter.

  Parameters:
    `cls` - the `Class` of results
    `filter` - the filter for candidate instances
  Returns:
    the new `Query`

### newQuery

    public Query newQuery(java.lang.Class cls,
                          java.util.Collection cln,
                          java.lang.String filter)

  Create a new `Query` with the `Class` of the candidate instances, candidate `Collection`, and filter.

  Parameters:
    `cls` - the `Class` of candidate instances
    `cln` - the `Collection` of candidate instances
    `filter` - the filter for candidate instances
  Returns:
    the new `Query`

### newQuery

    public Query newQuery(Extent cln,
                          java.lang.String filter)

  Create a new `Query` with the candidate `Extent` and filter; the class is taken from the `Extent`.

  Parameters:
    `cln` - the `Extent` of candidate instances
    `filter` - the filter for candidate instances
  Returns:
    the new `Query`

### getExtent

    public Extent getExtent(java.lang.Class persistenceCapableClass,
                            boolean subclasses)

  The `PersistenceManager` manages a collection of instances in the data store based on the class of the instances. This method returns an `Extent` of instances in the data store that might be iterated or given to a `Query`. The `Extent` itself might not reference any instances, but only hold the class name and an indicator as to whether subclasses are included in the `Extent`.

  Note that the `Extent` might be very large.

  Parameters:
    `persistenceCapableClass` - `Class` of instances
    `subclasses` - whether to include instances of subclasses
  Returns:
    an `Extent` of the specified `Class`
  See Also:
    `Query`

### getObjectById

    public java.lang.Object getObjectById(java.lang.Object oid,
                                          boolean validate)

  This method locates a persistent instance in the cache of instances managed by this `PersistenceManager`. The `getObjectById` method attempts to find an instance in the cache with the specified JDO identity. The `oid` parameter object might have been returned by an earlier call to `getObjectId` or `getTransactionalObjectId`, or might have been constructed by the application.

  If the `PersistenceManager` is unable to resolve the `oid` parameter to an ObjectId instance, then it throws a `JDOUserException`.

  If the `validate` flag is `false`, and there is already an instance in the cache with the same JDO identity as the `oid` parameter, then this method returns it. There is no change made to the state of the returned instance.

  If there is not an instance already in the cache with the same JDO identity as the `oid` parameter, then this method creates an instance with the specified JDO identity and returns it. If there is no transaction in progress, the returned instance will be hollow or persistent-nontransactional, at the choice of the implementation.

  If there is a transaction in progress, the returned instance will be hollow, persistent-nontransactional, or persistent-clean, at the choice of the implementation.

  It is an implementation decision whether to access the data store, if required to determine the exact class. This will be the case of inheritance, where multiple `PersistenceCapable` classes share the same ObjectId class.

  If the validate flag is `false`, and the instance does not exist in the data store, then this method might not fail. It is an implementation choice whether to fail immediately with a `JDODataStoreException`. But a subsequent access of the fields of the instance will throw a `JDODataStoreException` if the instance does not exist at that time. Further, if a relationship is established to this instance, then the transaction in which the association was made will fail.

  If the `validate` flag is `true`, and there is already a transactional instance in the cache with the same JDO identity as the `oid` parameter, then this method returns it. There is no change made to the state of the returned instance.

  If there is an instance already in the cache with the same JDO identity as the `oid` parameter, but the instance is not transactional, then it must be verified in the data store. If the instance does not exist in the datastore, then a `JDODataStoreException` is thrown.

  If there is not an instance already in the cache with the same JDO identity as the `oid` parameter, then this method creates an instance with the specified JDO identity, verifies that it exists in the data store, and returns it. If there is no transaction in progress, the returned instance will be hollow or persistent-nontransactional, at the choice of the implementation.

  If there is a data store transaction in progress, the returned instance will be persistent-clean. If there is an optimistic transaction in progress, the returned instance will be persistent-nontransactional.

  Parameters:
    `oid` - an ObjectId
    `validate` - if the existence of the instance is to be validated
  Returns:
    the `PersistenceCapable` instance with the specified ObjectId
  See Also:
    `getObjectId(Object pc)`, `getTransactionalObjectId(Object pc)`

### getObjectId

    public java.lang.Object getObjectId(java.lang.Object pc)

  The ObjectId returned by this method represents the JDO identity of the instance. The ObjectId is a copy (clone) of the internal state of the instance, and changing it does not affect the JDO identity of the instance.

  The `getObjectId` method returns an ObjectId instance that represents the object identity of the specified JDO instance. The identity is guaranteed to be unique only in the context of the JDO `PersistenceManager` that created the identity, and only for two types of JDO Identity: those that are managed by the application, and those that are managed by the data store.

  If the object identity is being changed in the transaction, by the application modifying one or more of the application key fields, then this method returns the identity as of the beginning of the transaction. The value returned by `getObjectId` will be different following `afterCompletion` processing for successful transactions.

  Within a transaction, the ObjectId returned will compare equal to the ObjectId returned by only one among all JDO instances associated with the `PersistenceManager` regardless of the type of ObjectId.

  The ObjectId does not necessarily contain any internal state of the instance, nor is it necessarily an instance of the class used to manage identity internally. Therefore, if the application makes a change to the ObjectId instance returned by this method, there is no effect on the instance from which the ObjectId was obtained.

  The `getObjectById` method can be used between instances of `PersistenceManager` of different JDO vendors only for instances of persistence capable classes using application-managed (primary key) JDO identity. If it is used for instances of classes using datastore identity, the method might succeed, but there are no guarantees that the parameter and return instances are related in any way.

  Parameters:
    `pc` - the `PersistenceCapable` instance
  Returns:
    the ObjectId of the instance
  See Also:
    `getTransactionalObjectId(Object pc)`, `getObjectById(Object oid, boolean validate)`

### getTransactionalObjectId

    public java.lang.Object getTransactionalObjectId(java.lang.Object pc)

  The ObjectId returned by this method represents the JDO identity of the instance. The ObjectId is a copy (clone) of the internal state of the instance, and changing it does not affect the JDO identity of the instance.

  If the object identity is being changed in the transaction, by the application modifying one or more of the application key fields, then this method returns the current identity in the transaction.

  If there is no transaction in progress, or if none of the key fields is being modified, then this method will return the same value as `getObjectId`.

  Parameters:
    `pc` - a `PersistenceCapable` instance
  Returns:
    the ObjectId of the instance
  See Also:
    `getObjectId(Object pc)`, `getObjectById(Object oid, boolean validate)`

### newObjectIdInstance

    public java.lang.Object newObjectIdInstance(java.lang.Class pcClass,
                                                java.lang.String str)

  This method returns an object id instance corresponding to the `Class` and `String` arguments. The `String` argument might have been the result of executing `toString` on an object id instance.

  Parameters:
    `pcClass` - the `Class` of the persistence-capable instance
    `str` - the `String` form of the object id
  Returns:
    an instance of the object identity class

### makePersistent

    public void makePersistent(java.lang.Object pc)

  Make the transient instance persistent in this `PersistenceManager`. This method must be called in an active transaction. The `PersistenceManager` assigns an ObjectId to the instance and transitions it to persistent-new. The instance will be managed in the `Extent` associated with its `Class`. The instance will be put into the data store at commit. The closure of instances of `PersistenceCapable` classes reachable from persistent fields will be made persistent at commit. [This is known as persistence by reachability.]

  Parameters:
    `pc` - a transient instance of a `Class` that implements `PersistenceCapable`

### makePersistentAll

    public void makePersistentAll(java.lang.Object[] pcs)

  Make an array of instances persistent.

  Parameters:
    `pcs` - an array of transient instances
  See Also:
    `makePersistent(Object pc)`

### makePersistentAll

    public void makePersistentAll(java.util.Collection pcs)

  Make a `Collection` of instances persistent.

  Parameters:
    `pcs` - a `Collection` of transient instances
  See Also:
    `makePersistent(Object pc)`

### deletePersistent

    public void deletePersistent(java.lang.Object pc)

  Delete the persistent instance from the data store. This method must be called in an active transaction. The data store object will be removed at commit. Unlike `makePersistent`, which makes the closure of the instance persistent, the closure of the instance is not deleted from the data store. This method has no effect if the instance is already deleted in the current transaction. This method throws `JDOUserException` if the instance is transient or is managed by another `PersistenceManager`.

  Parameters:
    `pc` - a persistent instance

### deletePersistentAll

    public void deletePersistentAll(java.lang.Object[] pcs)

  Delete an array of instances from the data store.

  Parameters:
    `pcs` - a `Collection` of persistent instances
  See Also:
    `deletePersistent(Object pc)`

### deletePersistentAll

    public void deletePersistentAll(java.util.Collection pcs)

  Delete a `Collection` of instances from the data store.

  Parameters:
    `pcs` - a `Collection` of persistent instances
  See Also:
    `deletePersistent(Object pc)`

### makeTransient

    public void makeTransient(java.lang.Object pc)

  Make an instance transient, removing it from management by this `PersistenceManager`.

  The instance loses its JDO identity and it is no longer associated with any `PersistenceManager`. The state of fields is preserved unchanged.

  Parameters:
    `pc` - the instance to make transient.

### makeTransientAll

    public void makeTransientAll(java.lang.Object[] pcs)

  Make an array of instances transient, removing them from management by this `PersistenceManager`.

  The instances lose their JDO identity and they are no longer associated with any `PersistenceManager`. The state of fields is preserved unchanged.

  Parameters:
    `pcs` - the instances to make transient.

### makeTransientAll

    public void makeTransientAll(java.util.Collection pcs)

  Make a `Collection` of instances transient, removing them from management by this `PersistenceManager`.

  The instances lose their JDO identity and they are no longer associated with any `PersistenceManager`. The state of fields is preserved unchanged.

  Parameters:
    `pcs` - the instances to make transient.

### makeTransactional

    public void makeTransactional(java.lang.Object pc)

  Make an instance subject to transactional boundaries.

  Transient instances normally do not observe transaction boundaries. This method makes transient instances sensitive to transaction completion. If an instance is modified in a transaction, and the transaction rolls back, the state of the instance is restored to the state before the first change in the transaction.

  For persistent instances read in optimistic transactions, this method allows the application to make the state of the instance part of the transactional state. At transaction commit, the state of the instance in the cache is compared to the state of the instance in the data store. If they are not the same, then an exception is thrown.

  Parameters:
    `pc` - the instance to make transactional.

### makeTransactionalAll

    public void makeTransactionalAll(java.lang.Object[] pcs)

  Make an array of instances subject to transactional boundaries.

  Parameters:
    `pcs` - the array of instances to make transactional.
  See Also:
    `makeTransactional(Object pc)`

### makeTransactionalAll

    public void makeTransactionalAll(java.util.Collection pcs)

  Make a `Collection` of instances subject to transactional boundaries.

  Parameters:
    `pcs` - the `Collection` of instances to make transactional.
  See Also:
    `makeTransactional(Object pc)`

### makeNontransactional

    public void makeNontransactional(java.lang.Object pc)

  Make an instance non-transactional after commit.

  Normally, at transaction completion, instances are evicted from the cache. This method allows an application to identify an instance as not being evicted from the cache at transaction completion. Instead, the instance remains in the cache with nontransactional state.

  Parameters:
    `pc` - the instance to make nontransactional.

### makeNontransactionalAll

    public void makeNontransactionalAll(java.lang.Object[] pcs)

  Make an array of instances non-transactional after commit.

  Parameters:
    `pcs` - the array of instances to make nontransactional.
  See Also:
    `makeNontransactional(Object pc)`

### makeNontransactionalAll

    public void makeNontransactionalAll(java.util.Collection pcs)

  Make a `Collection` of instances non-transactional after commit.

  Parameters:
    `pcs` - the `Collection` of instances to make nontransactional.
  See Also:
    `makeNontransactional(Object pc)`

### retrieve

    public void retrieve(java.lang.Object pc)

  Retrieve an instance from the store. This is only a hint to the `PersistenceManager` that the application intends to use the instance, and its field values should be retrieved.

  The `PersistenceManager` might use policy information about the class to retrieve associated instances.

### retrieveAll

    public void retrieveAll(java.util.Collection pcs)

  Retrieve instances from the store. This is only a hint to the `PersistenceManager` that the application intends to use the instances, and their field values should be retrieved.

  The `PersistenceManager` might use policy information about the class to retrieve associated instances.

### retrieveAll

    public void retrieveAll(java.lang.Object[] pcs)

  Retrieve instances from the store. This is only a hint to the `PersistenceManager` that the application intends to use the instances, and their field values should be retrieved.

  The `PersistenceManager` might use policy information about the class to retrieve associated instances.

### setUserObject

    public void setUserObject(java.lang.Object o)

  The application can manage the `PersistenceManager` instances more easily by having an application object associated with each `PersistenceManager` instance.

  Parameters:
    `o` - the user instance to be remembered by the `PersistenceManager`
  See Also:
    `getUserObject()`

### getUserObject

    public java.lang.Object getUserObject()

  The application can manage the `PersistenceManager` instances more easily by having an application object associated with each `PersistenceManager` instance.

  Returns:
    the user object associated with this `PersistenceManager`
  See Also:
    `setUserObject(java.lang.Object)`

### getPersistenceManagerFactory

    public PersistenceManagerFactory getPersistenceManagerFactory()

  This method returns the `PersistenceManagerFactory` used to create this `PersistenceManager`.

  Returns:
    the `PersistenceManagerFactory` that created this `PersistenceManager`

### getObjectIdClass

    public java.lang.Class getObjectIdClass(java.lang.Class cls)

  Return the `Class` that implements the JDO Identity for the specified `PersistenceCapable` class. The application can use the returned `Class` to construct a JDO Identity instance for application identity `PersistenceCapable` classes. This JDO Identity instance can then be used to get an instance of the `PersistenceCapable` class for use in the application.

  In order for the application to construct an instance of the ObjectId class it needs to know the class being used by the JDO implementation.

  Parameters:
    `cls` - the `PersistenceCapable Class`
  Returns:
    the `Class` of the ObjectId of the parameter
  See Also:
    `getObjectById(java.lang.Object, boolean)`

### setMultithreaded

    public void setMultithreaded(boolean flag)

  Set the Multithreaded flag for this `PersistenceManager`. Applications that use multiple threads to invoke methods or access fields from instances managed by this `PersistenceManager` must set this flag to `true`. Instances managed by this `PersistenceManager` include persistent or transactional instances of `PersistenceCapable` classes, as well as helper instances such as `Query`, `Transaction`, or `Extent`.

  Parameters:
    `flag` - the Multithreaded setting.

### getMultithreaded

    public boolean getMultithreaded()

  Get the current Multithreaded flag for this `PersistenceManager`.

  Returns:
    the Multithreaded setting.
  See Also:
    `setMultithreaded(boolean)`

### setIgnoreCache

    public void setIgnoreCache(boolean flag)

  Set the ignoreCache parameter for queries.

  IgnoreCache set to `true` specifies that for all `Query` instances created by this `PersistenceManager`, the default is the cache should be ignored for queries.

  Parameters:
    `flag` - the ignoreCache setting.

### getIgnoreCache

    public boolean getIgnoreCache()

  Get the ignoreCache setting for queries.

  IgnoreCache set to `true` specifies that for all `Query` instances created by this `PersistenceManager`, the default is the cache should be ignored for queries.

  Returns:
    the ignoreCache setting.

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