PersistenceManagerImpl

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.jdo.impl.pm
Class PersistenceManagerImpl

java.lang.Object
  org.apache.jdo.impl.pm.PersistenceManagerImpl

All Implemented Interfaces:: javax.jdo.PersistenceManager, PersistenceManagerInternal

public abstract class PersistenceManagerImpl
extends java.lang.Object
implements PersistenceManagerInternal

This is the StoreManager independent implemetation of the org.apache.jdo.pm.PersistenceManagerInternal interface. Delegates most of the method execution to the corresponding instance of the CacheManagerImpl.

Author:: Marina Vatkina

Nested Class Summary
`(package private) class`	`PersistenceManagerImpl.EmptyExtent`

Field Summary
`private boolean`	`_activeTransaction` Flag for active transaction
`private boolean`	`_detachAllOnCommit` Flag for detaching all objects upon PM commit.
`private boolean`	`_flushing` Flag for flushing process
`private boolean`	`_ignoreCache` Flag for Query.
`private boolean`	`_isClosed` True if this PersistenceManager is closed
`private java.lang.Object`	`_jta` Reference to the associated JTA Transaction if any
`private StoreManager`	`_storeManager` Reference to the StoreManager
`private TransactionImpl`	`_transaction` Associated Transaction
`private CacheManagerImpl`	`_txCache` Reference to the CacheManager
`private java.lang.Object`	`_userObject` User Object
`private PersistenceManagerWrapper`	`current` Current PersistenceManagerWrapper as PersistenceManagerInternal
`private static java.lang.Integer`	`int10`
`private static java.lang.Integer`	`int11` Default initialCapacity values.
`private static RuntimeJavaModelFactory`	`javaModelFactory` RuntimeJavaModelFactory.
`private static org.apache.commons.logging.Log`	`logger` Logger support
`private StateManagerInternal`	`lookingFor` Helper objects to identify StateManager associated with the given PersistenceCapable instance
`protected static org.apache.jdo.util.I18NHelper`	`msg` I18N message handler
`private boolean`	`multithreaded` Flag for multithreaded support.
`private java.lang.ClassLoader`	`myClassLoader` This is the ClassLoader that was the Thread.currentThread().getContextClassLoader() at the time this PersistenceManagerImpl was created.
`private boolean`	`optimistic` Flag for optimistic transaction
`private javax.jdo.spi.PersistenceCapable`	`pc`
`private PersistenceManagerFactoryImpl`	`pmf` PersistenceManagerFactory that created (and could be pooling) this PersistenceManager
`private static java.lang.Class[]`	`sigSCO_Collection` The signature for SCO Collections.
`private static java.lang.Class[]`	`sigSCO_HashMap` The signature for SCO HashMap.
`private static java.lang.Class[]`	`sigSCO_HashSet` The signature for SCO HashSet.
`private static java.lang.Class[]`	`sigSCO_Map` The signature for SCO Maps.
`private static java.lang.Class[]`	`sigSCO_Short` Constructor signatures
`private static java.lang.Class[]`	`sigSCO_TreeMap` The signature for SCO TreeMap.
`private static java.lang.Class[]`	`sigSCO_TreeSet` The signature for SCO TreeSet.

Constructor Summary
`PersistenceManagerImpl(PersistenceManagerFactoryInternal pmf, java.lang.String username, java.lang.String password)` Constructs new instance of PersistenceManagerImpl for this PersistenceManagerFactoryInternal and particular combination of username and password.

Method Summary
`void`	`addInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener, java.lang.Class[] classes)` Adds the listener instance to the list of lifecycle event listeners.
`protected void`	`afterCompletion(int status)` Called by Transaction commit() or rollback() cleans up transactional cache
`private void`	`assertActiveTransaction(boolean insideQuery)` assert that the associated Transaction is active
`void`	`assertIsOpen()` assert this PM instance is open
`private void`	`assertPersistenceCapable(java.lang.Object pc, java.lang.String caller)` assert Object is PersistenceCapable
`private void`	`assertPersistenceManager(javax.jdo.spi.PersistenceCapable pc)` assert PersistenceCapable is associated with this instance of PersistenceManager
`void`	`assertReadAllowed()` Assert the NontransactionalRead flag is true or a transaction is active.
`java.lang.Object`	`attachCopy(java.lang.Object pc, boolean makeTransactional)` Import the specified object into the `PersistenceManager`.
`java.util.Collection`	`attachCopyAll(java.util.Collection pcs, boolean makeTransactional)` Import the specified objects into the `PersistenceManager`.
`java.lang.Object[]`	`attachCopyAll(java.lang.Object[] pcs, boolean makeTransactional)` Import the specified objects into the `PersistenceManager`.
`void`	`checkConsistency()` Validates the `PersistenceManager` cache with the datastore.
`void`	`close()` Close this persistence manager
`javax.jdo.Transaction`	`currentTransaction()` Returns transaction associated with this persistence manager
`private void`	`debug(java.lang.String msg)` Tracing method
`private boolean`	`debugging()` Verifies if debugging is enabled.
`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.
`private void`	`deletePersistentAllInternal(java.lang.Object[] pcs)` Internal method to process deletePersistentAll call.
`private void`	`deletePersistentInternal(java.lang.Object pc)` Internal method to process deletePersistent call.
`void`	`deregister(java.lang.Object oid)` Removes the object from the cache.
`protected void`	`deregisterJTA()` Disassociate this PersistenceManager with the current JTA transaction.
`void`	`deregisterTransient(StateManagerInternal sm)` Removes transient object from the transient cache.
`java.lang.Object`	`detachCopy(java.lang.Object pc)` Detach the specified object from the `PersistenceManager`.
`java.util.Collection`	`detachCopyAll(java.util.Collection pcs)` Detach the specified objects from the `PersistenceManager`.
`java.lang.Object[]`	`detachCopyAll(java.lang.Object[] pcs)` Detach the specified objects from the `PersistenceManager`.
`boolean`	`equals(java.lang.Object obj)` Indicates whether some other object is "equal to" this one.
`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.
`private void`	`evictAllInternal(java.lang.Object[] pcs)` Internal method to process evictAll call.
`private void`	`evictInternal(java.lang.Object pc)` Internal method to process evict call.
`StateManagerInternal`	`findStateManager(javax.jdo.spi.PersistenceCapable pc)` A helper method to find the StateManager associated with this PC instance
`void`	`flush()` Flushes all dirty, new, and deleted instances to the data store.
`protected void`	`flushInstances()` Called by Transaction commit() Loops through transactional cache and calls PersistentStore.updatePersistent() on each instance
`protected void`	`forceClose()` Close this persistence manager even if there are open wrappers or an uncomplete transaction.
`java.lang.ClassLoader`	`getContextClassLoaderPrivileged()` Calls getContextClassLoader for the current Thread in a doPrivileged block.
`javax.jdo.PersistenceManager`	`getCurrentWrapper()` Returns current wrapper
`javax.jdo.datastore.JDOConnection`	`getDataStoreConnection()` If this method is called while a datastore transaction is active, the object returned will be enlisted in the current transaction.
`boolean`	`getDetachAllOnCommit()` Get the value of the detachAllOnCommit flag.
`javax.jdo.Extent`	`getExtent(java.lang.Class persistenceCapableClass)` Equivalent to `getExtent (persistenceCapableClass, true)`.
`javax.jdo.Extent`	`getExtent(java.lang.Class persistenceCapableClass, boolean subclasses)` The PersistenceManager may manage a collection of instances in the data store based on the class of the instances.
`private java.lang.Object`	`getExternalObjectId(java.lang.Object pc, boolean transactional)` Returns external representation of the current or transactional objectId depending on the parameter
`javax.jdo.FetchPlan`	`getFetchPlan()` Returns the `FetchPlan` used by this `PersistenceManager`.
`boolean`	`getIgnoreCache()` Get the value of the ignoreCache flag.
`private java.lang.Integer`	`getInitialSize(java.lang.Class type)` Helper method to calculate initialSize of the Collection or Map if null is specifield for the new tracked instance.
`java.util.Collection`	`getInsertedInstances()` Returns a Collection of instances that has been made persistent or become persistent through persistence-by-reachability algorithm in this transaction.
`java.lang.Object`	`getInternalObjectId(java.lang.Object pc)` Gets the internal object id for this instance.
`boolean`	`getMultithreaded()` Get the current Multithreaded flag for this PersistenceManager.
`java.lang.Object`	`getObjectById(java.lang.Class cls, java.lang.Object key)` Looks up the instance of the given type with the given key.
`java.lang.Object`	`getObjectById(java.lang.Object oid)` Looks up the instance corresponding to the specified oid.
`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.
`java.util.Collection`	`getObjectsById(java.util.Collection oids)` Return the objects with the given oids.
`java.util.Collection`	`getObjectsById(java.util.Collection oids, boolean validate)` Return the objects with the given oids.
`java.lang.Object[]`	`getObjectsById(java.lang.Object[] oids)` Return the objects with the given oids.
`java.lang.Object[]`	`getObjectsById(java.lang.Object[] oids, boolean validate)` Return the objects with the given oids.
`javax.jdo.PersistenceManagerFactory`	`getPersistenceManagerFactory()` This method returns the PersistenceManagerFactory used to create this PersistenceManager.
`java.util.Properties`	`getProperties()` The JDO vendor might store certain non-operational properties and make those properties available to applications (for troubleshooting).
`javax.jdo.datastore.Sequence`	`getSequence(java.lang.String name)` Returns the sequence identified by `name`.
`StateManagerInternal`	`getStateManager(java.lang.Object oid, java.lang.Class pcClass)` Provides a StateManagerInternal for the given Object Id.
`StoreManager`	`getStoreManager()` Provides a StoreManager that is ready to accept operations on it.
`java.lang.Object`	`getTransactionalObjectId(java.lang.Object pc)`
`java.lang.Object`	`getUserObject()` The application can manage the PersistenceManager instances more easily by having an application object associated with each PersistenceManager instance.
`java.lang.Object`	`getUserObject(java.lang.Object key)` Get the value for the specified key from the map of user objects.
`int`	`hashCode()` Returns a hash code value for this PersistenceManager.
`void`	`hereIsStateManager(StateManagerInternal sm, javax.jdo.spi.PersistenceCapable pc)` A helper method called from the StateManager inside getPersistenceManager() to identify StateManager associated with this PC instance
`boolean`	`insideCommit()` Returns true if the call initiated as a result of the commit process, versus flush for query in a datastore transaction.
`boolean`	`isClosed()` Return whether this PersistenceManager is closed.
`boolean`	`isSupportedSCOType(java.lang.Class type)` Called by StateManager to verify field type.
`java.lang.Class`	`loadClass(java.lang.String name, java.lang.ClassLoader given)` Provides a Class of the given name.
`java.lang.Class`	`loadPCClassForObjectIdClass(java.lang.Class objectIdClass)` Provides the Class object of the persistence-capable class that defines the specified class as its ObjectId class.
`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.
`private void`	`makeNontransactionalAllInternal(java.lang.Object[] pcs)` Internal method to process makeNontransactionalAll call.
`private void`	`makeNontransactionalInternal(java.lang.Object pc)` Internal method to process makeNontransactional call.
`java.lang.Object`	`makePersistent(java.lang.Object pc)` Make the transient instance persistent in this PersistenceManager.
`java.util.Collection`	`makePersistentAll(java.util.Collection pcs)` Make an collection of instances persistent.
`java.lang.Object[]`	`makePersistentAll(java.lang.Object[] pcs)` Make an array of instances persistent.
`private java.lang.Object[]`	`makePersistentAllInternal(java.lang.Object[] pcs)` Internal method for processing makePersistentAll request.
`private java.lang.Object`	`makePersistentInternal(java.lang.Object pc)` Internal method for processing makePersistent request.
`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.
`private void`	`makeTransactionalAllInternal(java.lang.Object[] pcs)` Internal method to process makeTransactionalAll call.
`private void`	`makeTransactionalInternal(java.lang.Object pc)` Internal method to process makeTransactional call.
`void`	`makeTransient(java.lang.Object pc)` Make an instance transient, removing it from management by this PersistenceManager.
`void`	`makeTransient(java.lang.Object pc, boolean useFetchPlan)` 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.util.Collection pcs, boolean useFetchPlan)` Make 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.
`void`	`makeTransientAll(java.lang.Object[] pcs, boolean useFetchPlan)` Make instances transient, removing them from management by this `PersistenceManager`.
`private void`	`makeTransientAllInternal(java.lang.Object[] pcs)` Internal method to process makeTransientAll call.
`private void`	`makeTransientInternal(java.lang.Object pc)` Internal method to process makeTransient call.
`void`	`markAsFlushed(StateManagerInternal sm)` Called by StateManagerInternal#markAsFlushed() to adjust transactional cache(s) if necessary after successful flush to the data store.
`java.util.Collection`	`newCollectionInstanceInternal(java.lang.Class type, java.lang.Class elementType, boolean allowNulls, java.lang.Integer initialSize, java.lang.Float loadFactor, java.util.Collection initialContents, java.util.Comparator comparator)` Called by internally by the runtime to create a new tracked instance.
`java.lang.Object`	`newInstance(java.lang.Class pcClass)` Creates an instance of a persistence-capable interface or abstract class.
`java.util.Map`	`newMapInstanceInternal(java.lang.Class type, java.lang.Class keyType, java.lang.Class valueType, boolean allowNulls, java.lang.Integer initialSize, java.lang.Float loadFactor, java.util.Map initialContents, java.util.Comparator comparator)` Called by internally by the runtime to create a new tracked instance.
`abstract javax.jdo.Query`	`newNamedQuery(java.lang.Class cls, java.lang.String queryName)` Create a new `Query` with the given candidate class from a named query.
`java.lang.Object`	`newObjectIdInstance(java.lang.Class pcClass, java.lang.Object key)` This method returns an object id instance corresponding to the pcClass and key arguments.
`abstract javax.jdo.Query`	`newQuery()` Create a new Query with no elements.
`abstract javax.jdo.Query`	`newQuery(java.lang.Class cls)` Create a new Query specifying the Class of the results.
`abstract javax.jdo.Query`	`newQuery(java.lang.Class cls, java.util.Collection cln)` Create a new Query with the Class of the results and candidate Collection.
`abstract javax.jdo.Query`	`newQuery(java.lang.Class cls, java.util.Collection cln, java.lang.String filter)` Create a new Query with the Class of the results, candidate Collection, and Filter.
`abstract javax.jdo.Query`	`newQuery(java.lang.Class cls, java.lang.String filter)` Create a new Query with the Class of the results and Filter.
`abstract javax.jdo.Query`	`newQuery(javax.jdo.Extent cln)` Create a new Query with the candidate Extent; the class is taken from the Extent.
`abstract javax.jdo.Query`	`newQuery(javax.jdo.Extent cln, java.lang.String filter)` Create a new Query with the candidate Extent and Filter.
`abstract javax.jdo.Query`	`newQuery(java.lang.Object compiled)` Create a new Query using elements from another Query.
`abstract javax.jdo.Query`	`newQuery(java.lang.String query)` Create a Construct a new query instance using the specified String as the single-string representation of the query.
`abstract javax.jdo.Query`	`newQuery(java.lang.String language, java.lang.Object query)` Create a new Query using the specified language.
`java.lang.Object`	`newSCOInstanceInternal(java.lang.Class type)` Called by internally by the runtime to create a new tracked instance.
`protected void`	`notifyOptimistic(boolean optimistic)` For Transaction to notify PersistenceManager that optimistic flag is changed
`protected void`	`notifyStatusChange(boolean isActive)` For Transaction to notify PersistenceManager that status is changed
`protected void`	`popCurrentWrapper(PersistenceManagerWrapper prev)` Replace current wrapper with the previous
`protected void`	`pushCurrentWrapper(PersistenceManagerWrapper pmw)` Remember the current wrapper
`java.lang.Object`	`putUserObject(java.lang.Object key, java.lang.Object val)` Put the specified key-value pair into the map of user objects.
`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(javax.jdo.JDOException jdoe)` Refreshes all instances in the exception that failed verification.
`void`	`refreshAll(java.lang.Object[] pcs)` Refresh the state of an array of instances from the data store.
`private void`	`refreshAllInternal(java.lang.Object[] pcs)` Internal method to process refreshAll call.
`private void`	`refreshInternal(java.lang.Object pc)` Internal method to process refresh call.
`void`	`register(StateManagerInternal sm, java.lang.Object oid, boolean transactional, boolean throwDuplicateException)` Adds persistent object to the cache.
`void`	`registerTransient(StateManagerInternal sm)` Adds transient object to the transient cache.
`void`	`removeInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener)` Removes the listener instance from the list of lifecycle event listeners.
`java.lang.Object`	`removeUserObject(java.lang.Object key)` Remove the specified key and its value from the map of user objects.
`void`	`replaceObjectId(java.lang.Object oldId, java.lang.Object newId)` Replaces the objectId key value in the cache.
`void`	`retrieve(java.lang.Object pc)` Retrieve field values of an instance from the store.
`void`	`retrieve(java.lang.Object pc, boolean FGOnly)` Retrieve field values of an instance from the store.
`void`	`retrieveAll(java.util.Collection pcs)` Retrieve field values of instances from the store.
`void`	`retrieveAll(java.util.Collection pcs, boolean FGOnly)` Retrieve field values of instances from the store.
`void`	`retrieveAll(java.lang.Object[] pcs)` Retrieve field values of instances from the store.
`void`	`retrieveAll(java.lang.Object[] pcs, boolean FGOnly)` Retrieve field values of instances from the store.
`private void`	`retrieveAllInternal(java.lang.Object[] pcs, boolean DFGOnly)` Internal method to process retrieveAll call.
`private void`	`retrieveInternal(java.lang.Object pc, boolean DFGOnly)` Internal method to process retrieve call.
`void`	`setDetachAllOnCommit(boolean flag)`
`void`	`setIgnoreCache(boolean flag)`
`protected void`	`setJTATransaction(java.lang.Object t)` with the current thread in the managed environment
`void`	`setMultithreaded(boolean flag)` Set the Multithreaded flag for this PersistenceManager.
`void`	`setStoreManager(StoreManager storeManager)` Sets a StoreManager that is ready to accept operations on it such as insert, etc.
`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.
`private void`	`validateResult(int l, java.lang.Throwable[] err)` Helper method to validate errors on processing arrays of objects.
`protected boolean`	`verify(java.lang.String username, java.lang.String password)` Verify that cached instance of a PersistenceManager was initialy requested with the same values for username and password

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Field Detail

_isClosed

private boolean _isClosed

True if this PersistenceManager is closed

_transaction

private TransactionImpl _transaction

Associated Transaction

_jta

private java.lang.Object _jta

Reference to the associated JTA Transaction if any

current

private PersistenceManagerWrapper current

Current PersistenceManagerWrapper as PersistenceManagerInternal

pmf

private PersistenceManagerFactoryImpl pmf

PersistenceManagerFactory that created (and could be pooling) this PersistenceManager

_txCache

private CacheManagerImpl _txCache

Reference to the CacheManager

_storeManager

private StoreManager _storeManager

Reference to the StoreManager

_ignoreCache

private boolean _ignoreCache

Flag for Query. Constructor defaults it to the PMF setting.

_detachAllOnCommit

private boolean _detachAllOnCommit

Flag for detaching all objects upon PM commit. Constructor defaults it to the PMF setting.

_activeTransaction

private boolean _activeTransaction

Flag for active transaction

optimistic

private boolean optimistic

Flag for optimistic transaction

multithreaded

private boolean multithreaded

Flag for multithreaded support.

_userObject

private java.lang.Object _userObject

User Object

_flushing

private boolean _flushing

Flag for flushing process

myClassLoader

private final java.lang.ClassLoader myClassLoader

This is the ClassLoader that was the Thread.currentThread().getContextClassLoader() at the time this PersistenceManagerImpl was created.

sigSCO_Short

private static final java.lang.Class[] sigSCO_Short

Constructor signatures

sigSCO_Collection

private static final java.lang.Class[] sigSCO_Collection

The signature for SCO Collections.

sigSCO_Map

private static final java.lang.Class[] sigSCO_Map

The signature for SCO Maps.

sigSCO_HashSet

private static final java.lang.Class[] sigSCO_HashSet

The signature for SCO HashSet.

sigSCO_TreeSet

private static final java.lang.Class[] sigSCO_TreeSet

The signature for SCO TreeSet.

sigSCO_HashMap

private static final java.lang.Class[] sigSCO_HashMap

The signature for SCO HashMap.

sigSCO_TreeMap

private static final java.lang.Class[] sigSCO_TreeMap

The signature for SCO TreeMap.

int11

private static final java.lang.Integer int11

Default initialCapacity values.

int10

private static final java.lang.Integer int10

javaModelFactory

private static final RuntimeJavaModelFactory javaModelFactory

RuntimeJavaModelFactory.

logger

private static final org.apache.commons.logging.Log logger

Logger support

msg

protected static final org.apache.jdo.util.I18NHelper msg

I18N message handler

lookingFor

private StateManagerInternal lookingFor

Helper objects to identify StateManager associated with the given PersistenceCapable instance

pc

private javax.jdo.spi.PersistenceCapable pc

Constructor Detail

PersistenceManagerImpl

public PersistenceManagerImpl(PersistenceManagerFactoryInternal pmf,
                              java.lang.String username,
                              java.lang.String password)

Constructs new instance of PersistenceManagerImpl for this PersistenceManagerFactoryInternal and particular combination of username and password.
Parameters:: pmf - calling PersistenceManagerFactory as PersistenceManagerFactoryInternal; username - user name used for accessing Connector or null if none is provided.; password - user password used for accessing Connector or null if none is provided.

Method Detail

setIgnoreCache

public void setIgnoreCache(boolean flag)

Specified by:: setIgnoreCache in interface javax.jdo.PersistenceManager

Parameters:: flag - the ignoreCache value
See Also:: PersistenceManager.setIgnoreCache(boolean flag)

getIgnoreCache

public boolean getIgnoreCache()

Get the value of the ignoreCache flag.

Specified by:: getIgnoreCache in interface javax.jdo.PersistenceManager

Returns:: the IgnoreCache flag
See Also:: PersistenceManager.getIgnoreCache()

setDetachAllOnCommit

public void setDetachAllOnCommit(boolean flag)

Specified by:: setDetachAllOnCommit in interface javax.jdo.PersistenceManager

Parameters:: flag - the detachAllOnCommit value
See Also:: PersistenceManager.setDetachAllOnCommit(boolean flag)

getDetachAllOnCommit

public boolean getDetachAllOnCommit()

Get the value of the detachAllOnCommit flag.

Specified by:: getDetachAllOnCommit in interface javax.jdo.PersistenceManager

Returns:: the DetachAllOnCommit flag
See Also:: PersistenceManager.getDetachAllOnCommit()

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.

Specified by:: setMultithreaded in interface javax.jdo.PersistenceManager

Parameters:: flag - the Multithreaded setting.

getMultithreaded

public boolean getMultithreaded()

Get the current Multithreaded flag for this PersistenceManager.

Specified by:: getMultithreaded in interface javax.jdo.PersistenceManager

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

isClosed

public boolean isClosed()

Return whether this PersistenceManager is closed.

Specified by:: isClosed in interface javax.jdo.PersistenceManager

See Also:: PersistenceManager.isClosed()

close

public void close()

Close this persistence manager

Specified by:: close in interface javax.jdo.PersistenceManager

See Also:: PersistenceManager.close()

currentTransaction

public javax.jdo.Transaction currentTransaction()

Returns transaction associated with this persistence manager

Specified by:: currentTransaction in interface javax.jdo.PersistenceManager

Returns:: transaction current transaction

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.

If the validate flag is true: This method verifies that there is an instance in the data store with the same oid, constructs an instance, and returns it. If there is no transaction active, then a hollow instance or persistent non-transactional instance is returned. If there is a transaction active, then a persistent clean instance is returned.

If the validate flag is false: If there is not already an instance in the cache with the same oid, then an instance is constructed and returned. If the instance does not exist in the data store, then this method will not fail. However, a request to access fields of the instance will throw an exception.

Specified by:: getObjectById in interface javax.jdo.PersistenceManager

Parameters:: oid - an ObjectId; validate - if the existence of the instance is to be validated
Returns:: the PersistenceCapable instance with the specified ObjectId

getObjectById

public java.lang.Object getObjectById(java.lang.Class cls,
                                      java.lang.Object key)

Looks up the instance of the given type with the given key.

Specified by:: getObjectById in interface javax.jdo.PersistenceManager

Parameters:: cls - The type of object to load; key - either the string representation of the object id, or an object representation of a single field identity key
Returns:: the corresponding persistent instance
Since:: 2.0

getObjectById

public java.lang.Object getObjectById(java.lang.Object oid)

Looks up the instance corresponding to the specified oid. This is equivalent to

getObjectById(oid, true);

Specified by:: getObjectById in interface javax.jdo.PersistenceManager



Parameters:
oid - The object id of the object to load
Returns:
the corresponding persistent instance
Since:
  2.0





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.
 Delegates actual execution to the internal method.


Specified by:
getObjectId in interface javax.jdo.PersistenceManager


Parameters:
pc - the PersistenceCapable instance
Returns:
the corresponding ObjectId of the instance. Returns null
 if pc is null, not persistence-capable, or not persistent.





loadClass
public java.lang.Class loadClass(java.lang.String name,
                                 java.lang.ClassLoader given)
                          throws java.lang.ClassNotFoundException

Description copied from interface: PersistenceManagerInternal
Provides a Class of the given name.  This method will use one of as
 many as three ClassLoaders in attempting to load the named class. The
 ClassLoaders are:
 
   The given Class Loader
   The current Thread's context Class Loader
   The class loader that was the context Class Loader of the thread
     which created this PersistenceManagerInternal 
 
 For each such non-null Class Loader, it is used as a parameter of
 Class.forName. If the result is not null, then the given Comparator's
 compare method is invoked with that Class and the given Object o. If
 that returns zero, that Class is returned. If either the Class.forName
 returns null or the comparator returns non-zero, the next non-null
 ClassLoader in the above list is tried in the same manner.
 
 If after the above has been tried on all the ClassLoaders, an
 appropriate Class has not been found, throws JDOUserException.


Specified by:
loadClass in interface PersistenceManagerInternal


Parameters:
name - Fully qualified name of the Class to load.
given - ClassLoader which is the first to be tried
 in loading the named Class.
Throws:
java.lang.ClassNotFoundException - - if an appropriate Class can not
 be loaded.
See Also:
PersistenceManagerInternal.loadClass(java.lang.String, java.lang.ClassLoader)





loadPCClassForObjectIdClass
public java.lang.Class loadPCClassForObjectIdClass(java.lang.Class objectIdClass)
                                            throws java.lang.ClassNotFoundException

Description copied from interface: PersistenceManagerInternal
Provides the Class object of the persistence-capable class that defines 
 the specified class as its ObjectId class. This method will use one of as
 many as three ClassLoaders in attempting to find the persistence-capable 
 class. The ClassLoaders are the same as in PersistenceManagerInternal.loadClass(java.lang.String, java.lang.ClassLoader):
 
 The given Class Loader, here the given class loader is the class 
 loader of the ObjectId class
 The current Thread's context Class Loader
 The class loader that was the context Class Loader of the thread
     which created this PersistenceManagerInternal 
 
 The method returns the top most persistence-capable class in the case of 
 an inheritance hierachy.


Specified by:
loadPCClassForObjectIdClass in interface PersistenceManagerInternal



Throws:
java.lang.ClassNotFoundException
See Also:
PersistenceManagerInternal.loadPCClassForObjectIdClass(java.lang.Class)





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

Gets the internal object id for this instance. Returns null
 if it is not a PersistenceCapable instance.


Specified by:
getInternalObjectId in interface PersistenceManagerInternal


Parameters:
pc - 
Returns:
the internal object id





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


Specified by:
getTransactionalObjectId in interface javax.jdo.PersistenceManager


See Also:
PersistenceManager.getTransactionalObjectId(java.lang.Object)





newObjectIdInstance
public java.lang.Object newObjectIdInstance(java.lang.Class pcClass,
                                            java.lang.Object key)

This method returns an object id instance corresponding to the pcClass
 and key arguments.


Specified by:
newObjectIdInstance in interface javax.jdo.PersistenceManager


Parameters:
pcClass - the Class of the persistence-capable instance
key - the value of the key field for single-field identity.
Returns:
an instance of the object identity class





getObjectsById
public java.util.Collection getObjectsById(java.util.Collection oids,
                                           boolean validate)

Return the objects with the given oids.


Specified by:
getObjectsById in interface javax.jdo.PersistenceManager


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.
Since:
  2.0
See Also:
getObjectById(Object,boolean)





getObjectsById
public java.util.Collection getObjectsById(java.util.Collection oids)

Return the objects with the given oids. This method is equivalent 
 to calling getObjectsById(Collection, boolean)
 with the validate flag true.


Specified by:
getObjectsById in interface javax.jdo.PersistenceManager


Parameters:
oids - the oids of the objects to return
Returns:
the objects that were looked up, in the
     same order as the oids parameter.
Since:
  2.0
See Also:
getObjectsById(Collection,boolean)





getObjectsById
public java.lang.Object[] getObjectsById(java.lang.Object[] oids,
                                         boolean validate)

Return the objects with the given oids.


Specified by:
getObjectsById in interface javax.jdo.PersistenceManager


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.
Since:
  2.0
See Also:
getObjectById(Object,boolean)





getObjectsById
public java.lang.Object[] getObjectsById(java.lang.Object[] oids)

Return the objects with the given oids. This method is equivalent
 to calling getObjectsById(Object[],boolean) 
 with the validate flag true.


Specified by:
getObjectsById in interface javax.jdo.PersistenceManager


Parameters:
oids - the oids of the objects to return
Returns:
the objects that were looked up, in the
     same order as the oids parameter.
Since:
  2.0
See Also:
getObjectsById(Object[],boolean)





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.


Specified by:
getObjectIdClass in interface javax.jdo.PersistenceManager


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





newQuery
public abstract javax.jdo.Query newQuery()

Create a new Query with no elements.


Specified by:
newQuery in interface javax.jdo.PersistenceManager



Returns:
a new Query instance with no elements.





newQuery
public abstract javax.jdo.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.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


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





newQuery
public abstract javax.jdo.Query newQuery(java.lang.String query)

Create a Construct a new query instance using the specified String 
 as the single-string representation of the query.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


Parameters:
query - the single-string query
Returns:
the new Query
Since:
  2.0






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

Create a new Query using the specified language.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


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 abstract javax.jdo.Query newQuery(java.lang.Class cls)

Create a new Query specifying the Class of the results.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


Parameters:
cls - the Class of the results
Returns:
the new Query





newQuery
public abstract javax.jdo.Query newQuery(javax.jdo.Extent cln)

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


Specified by:
newQuery in interface javax.jdo.PersistenceManager


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





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

Create a new Query with the Class of the results and candidate Collection.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


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





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

Create a new Query with the Class of the results and Filter.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


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





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

Create a new Query with the Class of the results, candidate Collection,
 and Filter.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


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





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

Create a new Query with the candidate Extent and Filter.
 The class is taken from the Extent.


Specified by:
newQuery in interface javax.jdo.PersistenceManager


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





newNamedQuery
public abstract javax.jdo.Query newNamedQuery(java.lang.Class cls,
                                              java.lang.String queryName)

Create a new Query with the given candidate class
 from a named query. The query name given must be the name of a
 query defined in metadata.


Specified by:
newNamedQuery in interface javax.jdo.PersistenceManager


Parameters:
cls - the Class of candidate instances
queryName - the name of the query to look up in metadata
Returns:
the new Query
Since:
  2.0






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

The PersistenceManager may manage 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 as the Extent of candidate instances.


Specified by:
getExtent in interface javax.jdo.PersistenceManager


Parameters:
persistenceCapableClass - Class of instances
subclasses - whether to include instances of subclasses
Returns:
an Extent of instances.
See Also:
StoreManager.getExtent(java.lang.Class, boolean, org.apache.jdo.pm.PersistenceManagerInternal), 
Query





getExtent
public javax.jdo.Extent getExtent(java.lang.Class persistenceCapableClass)

Equivalent to getExtent (persistenceCapableClass,
 true).


Specified by:
getExtent in interface javax.jdo.PersistenceManager


Since:
  2.0
See Also:
getExtent(Class,boolean)





makePersistent
public java.lang.Object 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.


Specified by:
makePersistent in interface javax.jdo.PersistenceManager


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





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

Make an array of instances persistent.


Specified by:
makePersistentAll in interface javax.jdo.PersistenceManager


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





makePersistentAll
public java.util.Collection makePersistentAll(java.util.Collection pcs)

Make an collection of instances persistent.


Specified by:
makePersistentAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - an 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 an exception if the instance is transient or is managed by another
 PersistenceManager.


Specified by:
deletePersistent in interface javax.jdo.PersistenceManager


Parameters:
pc - a persistent instance





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

Delete an array of instances from the data store.


Specified by:
deletePersistentAll in interface javax.jdo.PersistenceManager


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.


Specified by:
deletePersistentAll in interface javax.jdo.PersistenceManager


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.


Specified by:
makeTransient in interface javax.jdo.PersistenceManager


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.


Specified by:
makeTransientAll in interface javax.jdo.PersistenceManager


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.


Specified by:
makeTransientAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the instances to make transient.





makeTransient
public void makeTransient(java.lang.Object pc,
                          boolean useFetchPlan)

Make an instance transient, removing it from management by this 
 PersistenceManager. Because FOStore doesn't
 support the notion of a fetch plan, this method behaves exactly as
 makeTransient(Object pc).


Specified by:
makeTransient in interface javax.jdo.PersistenceManager


See Also:
javax.jdo.PersistenceManager#makeTransient(Object, boolean);





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

Make instances transient, removing them from management
 by this PersistenceManager. Because FOStore doesn't
 support the notion of a fetch plan, this method behaves exactly as
 makeTransientAll(Object[] pcs).


Specified by:
makeTransientAll in interface javax.jdo.PersistenceManager


See Also:
javax.jdo.PersistenceManager#makeTransientAll(Object[], boolean);





makeTransientAll
public void makeTransientAll(java.util.Collection pcs,
                             boolean useFetchPlan)

Make instances transient, removing them from management
 by this PersistenceManager. Because FOStore doesn't
 support the notion of a fetch plan, this method behaves exactly as
 makeTransientAll(Collection pcs).


Specified by:
makeTransientAll in interface javax.jdo.PersistenceManager


See Also:
javax.jdo.PersistenceManager#makeTransientAll(Collection, boolean);





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
 cache is compared to the state of the instance in the data store.  If they
 are not the same, then an exception is thrown.


Specified by:
makeTransactional in interface javax.jdo.PersistenceManager


Parameters:
pc - the instance to make transactional.





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

Make an array of instances subject to transactional boundaries.


Specified by:
makeTransactionalAll in interface javax.jdo.PersistenceManager


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.


Specified by:
makeTransactionalAll in interface javax.jdo.PersistenceManager


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.


Specified by:
makeNontransactional in interface javax.jdo.PersistenceManager


Parameters:
pc - the instance to make nontransactional.





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

Make an array of instances non-transactional after commit.


Specified by:
makeNontransactionalAll in interface javax.jdo.PersistenceManager


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.


Specified by:
makeNontransactionalAll in interface javax.jdo.PersistenceManager


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





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.


Specified by:
evict in interface javax.jdo.PersistenceManager


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.


Specified by:
evictAll in interface javax.jdo.PersistenceManager


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.


Specified by:
evictAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the Collection of instance to evict from the cache.





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.


Specified by:
evictAll in interface javax.jdo.PersistenceManager


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.


Specified by:
refresh in interface javax.jdo.PersistenceManager


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.


Specified by:
refreshAll in interface javax.jdo.PersistenceManager


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.


Specified by:
refreshAll in interface javax.jdo.PersistenceManager


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.


Specified by:
refreshAll in interface javax.jdo.PersistenceManager


See Also:
refresh(Object pc)





refreshAll
public void refreshAll(javax.jdo.JDOException jdoe)

Refreshes all instances in the exception that failed verification.


Specified by:
refreshAll in interface javax.jdo.PersistenceManager


Since:
  2.0






retrieve
public void retrieve(java.lang.Object pc)

Retrieve field values of an instance from the store.  This tells
 the PersistenceManager that the application intends to use the
 instance, and its field values must be retrieved.
 The PersistenceManager might use policy information about the
 class to retrieve associated instances.


Specified by:
retrieve in interface javax.jdo.PersistenceManager


Parameters:
pc - the instance





retrieve
public void retrieve(java.lang.Object pc,
                     boolean FGOnly)

Retrieve field values of an instance from the store.  
 The PersistenceManager might use policy information 
 about the class to retrieve associated instances.


Specified by:
retrieve in interface javax.jdo.PersistenceManager


Parameters:
pc - the instance
FGOnly - whether to retrieve only the fields in the fetch plan





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

Retrieve field values of instances from the store.  This tells
 the PersistenceManager that the application intends to use the
 instances, and all field values must be retrieved.
 The PersistenceManager might use policy information about the
 class to retrieve associated instances.


Specified by:
retrieveAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the instances





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

Retrieve field values of instances from the store.  This tells
 the PersistenceManager that the application intends to use the
 instances, and their field values should be retrieved.  The fields
 in the default fetch group must be retrieved, and the implementation
 might retrieve more fields than the default fetch group.
 The PersistenceManager might use policy information about the
 class to retrieve associated instances.


Specified by:
retrieveAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the instances
FGOnly - whether to retrieve only the fields in the fetch plan
Since:
  1.0.1






retrieveAll
public void retrieveAll(java.util.Collection pcs)

Retrieve field values of instances from the store.  This tells
 the PersistenceManager that the application intends to use the
 instances, and all field values must be retrieved.
 The PersistenceManager might use policy information about the
 class to retrieve associated instances.


Specified by:
retrieveAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the instances





retrieveAll
public void retrieveAll(java.util.Collection pcs,
                        boolean FGOnly)

Retrieve field values of instances from the store.  This tells
 the PersistenceManager that the application intends to use the
 instances, and their field values should be retrieved.  The fields
 in the default fetch group must be retrieved, and the implementation
 might retrieve more fields than the default fetch group.
 The PersistenceManager might use policy information about the
 class to retrieve associated instances.


Specified by:
retrieveAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the instances
FGOnly - whether to retrieve only the fields in the fetch plan
Since:
  1.0.1






getPersistenceManagerFactory
public javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory()

This method returns the PersistenceManagerFactory used to create
 this PersistenceManager.  It returns null if this instance was
 created via a constructor.


Specified by:
getPersistenceManagerFactory in interface javax.jdo.PersistenceManager



Returns:
the PersistenceManagerFactory that created
 this PersistenceManager





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.


Specified by:
setUserObject in interface javax.jdo.PersistenceManager


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.


Specified by:
getUserObject in interface javax.jdo.PersistenceManager



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





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

Detach the specified object from the PersistenceManager.


Specified by:
detachCopy in interface javax.jdo.PersistenceManager


Parameters:
pc - the instance to detach
Returns:
the detached instance
Since:
  2.0
See Also:
detachCopyAll(Object[])





detachCopyAll
public java.util.Collection detachCopyAll(java.util.Collection pcs)

Detach the specified objects from the PersistenceManager.


Specified by:
detachCopyAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the instances to detach
Returns:
the detached instances
Since:
  2.0
See Also:
detachCopyAll(Object[])





detachCopyAll
public java.lang.Object[] detachCopyAll(java.lang.Object[] pcs)

Detach the specified objects from the
 PersistenceManager. The objects returned can be
 manipulated and re-attached with 
 attachCopyAll(Object[], boolean). 
 The detached instances will be
 unmanaged copies of the specified parameters, and are suitable
 for serialization and manipulation outside of a JDO
 environment. When detaching instances, only fields in the
 current FetchPlan 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 FetchPlan.


Specified by:
detachCopyAll in interface javax.jdo.PersistenceManager


Parameters:
pcs - the instances to detach
Returns:
the detached instances
Throws:
javax.jdo.JDOUserException - if any of the instances do not
Since:
  2.0
See Also:
attachCopyAll(Object[], boolean), 
getFetchPlan()





attachCopy
public java.lang.Object attachCopy(java.lang.Object pc,
                                   boolean makeTransactional)

Import the specified object into the
 PersistenceManager.





Parameters:
pc - instance to import
makeTransactional - if true, this method will
     mark transactional the persistent instances corresponding
     to all instances in the closure of the detached graph.
Returns:
the re-attached instance
Since:
  2.0
See Also:
attachCopyAll(Object[],boolean)





attachCopyAll
public java.util.Collection attachCopyAll(java.util.Collection pcs,
                                          boolean makeTransactional)

Import the specified objects into the
 PersistenceManager.





Parameters:
pcs - Collection of instances to import
makeTransactional - if true, this method will
     mark transactional the persistent instances corresponding
     to all instances in the closure of the detached graph.
Returns:
the re-attached instances
Since:
  2.0
See Also:
attachCopyAll(Object[],boolean)





attachCopyAll
public java.lang.Object[] attachCopyAll(java.lang.Object[] pcs,
                                        boolean makeTransactional)

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.





Parameters:
pcs - array of instances to import
makeTransactional - if true, this method will
     mark transactional the persistent instances corresponding
     to all instances in the closure of the detached graph.
Returns:
the re-attached instances
Since:
  2.0
See Also:
detachCopyAll(Object[])





putUserObject
public java.lang.Object putUserObject(java.lang.Object key,
                                      java.lang.Object val)

Put the specified key-value pair into the map of user objects.


Specified by:
putUserObject in interface javax.jdo.PersistenceManager


Since:
  2.0






getUserObject
public java.lang.Object getUserObject(java.lang.Object key)

Get the value for the specified key from the map of user objects.


Specified by:
getUserObject in interface javax.jdo.PersistenceManager


Parameters:
key - the key of the object to be returned
Returns:
the object
Since:
  2.0






removeUserObject
public java.lang.Object removeUserObject(java.lang.Object key)

Remove the specified key and its value from the map of user objects.


Specified by:
removeUserObject in interface javax.jdo.PersistenceManager


Parameters:
key - the key of the object to be removed
Since:
  2.0






flush
public void flush()

Flushes all dirty, new, and deleted instances to the data
 store. It has no effect if a transaction is not active.
 If a datastore transaction is active, this method
 synchronizes the cache with the datastore and reports any
 exceptions.
 If an optimistic transaction is active, this method obtains
 a datastore connection, synchronizes the cache with the
 datastore using this connection and reports any
 exceptions. The connection obtained by this method is held
 until the end of the transaction.
 If exceptions occur during flush, the implementation will
 set the current transaction's RollbackOnly flag
 (see Transaction.setRollbackOnly()).


Specified by:
flush in interface PersistenceManagerInternal


Since:
  2.0






checkConsistency
public void checkConsistency()

Validates the PersistenceManager cache with the
 datastore. This method has no effect if a transaction is not
 active.
 If a datastore transaction is active, this method verifies
 the consistency of instances in the cache against the
 datastore. An implementation might flush instances as if
 flush() were called, but it is not required to do
 so.
 If an optimistic transaction is active, this method obtains
 a datastore connection and verifies the consistency of the
 instances in the cache against the datastore. If any
 inconsistencies are detected, a JDOOptimisticVerificationException is thrown. This exception
 contains a nested JDOOptimisticVerificationException
 for each object that failed the consistency check. No
 datastore resources acquired during the execution of this
 method are held beyond the scope of this method.


Specified by:
checkConsistency in interface javax.jdo.PersistenceManager


Since:
  2.0






getFetchPlan
public javax.jdo.FetchPlan getFetchPlan()

Returns the FetchPlan used by this
 PersistenceManager.


Specified by:
getFetchPlan in interface javax.jdo.PersistenceManager



Returns:
the FetchPlan
Since:
  2.0






newInstance
public java.lang.Object newInstance(java.lang.Class pcClass)

Creates an instance of a persistence-capable interface or
 abstract class. The returned instance is transient.


Specified by:
newInstance in interface javax.jdo.PersistenceManager


Parameters:
pcClass - Must be an abstract class or interface 
     that is declared in the metadata.
Returns:
the created instance
Since:
  2.0






getSequence
public javax.jdo.datastore.Sequence getSequence(java.lang.String name)

Returns the sequence identified by name.


Specified by:
getSequence in interface javax.jdo.PersistenceManager


Parameters:
name - the name of the Sequence
Returns:
the Sequence
Since:
  2.0






getDataStoreConnection
public javax.jdo.datastore.JDOConnection getDataStoreConnection()

If this method is called while a datastore transaction is
 active, the object returned will be enlisted in the current
 transaction. If called in an optimistic transaction or outside
 an active transaction, the object returned will not be
 enlisted in any transaction.


Specified by:
getDataStoreConnection in interface javax.jdo.PersistenceManager



Returns:
the JDOConnection instance
Since:
  2.0






addInstanceLifecycleListener
public void addInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener,
                                         java.lang.Class[] classes)

Adds the listener instance to the list of lifecycle event
 listeners. The classes parameter identifies all
 of the classes of interest. If the classes
 parameter is specified as null, events for all
 persistent classes and interfaces will be sent to
 listenerInstance.
 The listenerInstance will be called for each event for which it
 implements the corresponding listenerInstance interface.


Specified by:
addInstanceLifecycleListener in interface javax.jdo.PersistenceManager


Parameters:
listener - the lifecycle listener
classes - the classes of interest to the listener
Since:
  2.0






removeInstanceLifecycleListener
public void removeInstanceLifecycleListener(javax.jdo.listener.InstanceLifecycleListener listener)

Removes the listener instance from the list of lifecycle event listeners.


Specified by:
removeInstanceLifecycleListener in interface javax.jdo.PersistenceManager


Parameters:
listener - the listener instance to be removed
Since:
  2.0






getProperties
public java.util.Properties getProperties()

The JDO vendor might store certain non-operational properties and
 make those properties available to applications (for troubleshooting).
   
 Standard properties include:
 
VendorName
 VersionNumber






Returns:
the Properties of this PersistenceManager





assertIsOpen
public void assertIsOpen()

assert this PM instance is open


Specified by:
assertIsOpen in interface PersistenceManagerInternal








getStoreManager
public StoreManager getStoreManager()

Description copied from interface: PersistenceManagerInternal
Provides a StoreManager that is ready to accept operations on it.


Specified by:
getStoreManager in interface PersistenceManagerInternal



Returns:
A StoreManager.
See Also:
PersistenceManagerInternal.getStoreManager()





setStoreManager
public void setStoreManager(StoreManager storeManager)

Description copied from interface: PersistenceManagerInternal
Sets a StoreManager that is ready to accept operations on it such
 as insert, etc.


Specified by:
setStoreManager in interface PersistenceManagerInternal


Parameters:
storeManager - the StoreManager to be used by this
 PersistenceManager
See Also:
PersistenceManagerInternal.setStoreManager(StoreManager)





newSCOInstanceInternal
public java.lang.Object newSCOInstanceInternal(java.lang.Class type)

Called by internally by the runtime to create a new tracked instance.
 Will not result in marking field as dirty


Specified by:
newSCOInstanceInternal in interface PersistenceManagerInternal


Parameters:
type - Class of the new SCO instance
Returns:
the object of the class type
See Also:
(Class type)





newCollectionInstanceInternal
public java.util.Collection newCollectionInstanceInternal(java.lang.Class type,
                                                          java.lang.Class elementType,
                                                          boolean allowNulls,
                                                          java.lang.Integer initialSize,
                                                          java.lang.Float loadFactor,
                                                          java.util.Collection initialContents,
                                                          java.util.Comparator comparator)

Called by internally by the runtime to create a new tracked instance.
 Will not result in marking field as dirty


Specified by:
newCollectionInstanceInternal in interface PersistenceManagerInternal


See Also:
PersistenceManagerInternal.newCollectionInstanceInternal(Class type,
        Class elementType, boolean allowNulls, Integer initialSize,
        Float loadFactor, Collection initialContents, Comparator comparator)





newMapInstanceInternal
public java.util.Map newMapInstanceInternal(java.lang.Class type,
                                            java.lang.Class keyType,
                                            java.lang.Class valueType,
                                            boolean allowNulls,
                                            java.lang.Integer initialSize,
                                            java.lang.Float loadFactor,
                                            java.util.Map initialContents,
                                            java.util.Comparator comparator)

Called by internally by the runtime to create a new tracked instance.
 Will not result in marking field as dirty.


Specified by:
newMapInstanceInternal in interface PersistenceManagerInternal


See Also:
PersistenceManagerInternal.newMapInstanceInternal(Class type,
        Class keyType, Class valueType, boolean allowNulls, Integer initialSize,
        Float loadFactor, Map initialContents, Comparator comparator)





isSupportedSCOType
public boolean isSupportedSCOType(java.lang.Class type)

Description copied from interface: PersistenceManagerInternal
Called by StateManager to verify field type.


Specified by:
isSupportedSCOType in interface PersistenceManagerInternal


Parameters:
type - Class type of the field.
Returns:
true if this type is a supported SCO type.
See Also:
(Class type)





register
public void register(StateManagerInternal sm,
                     java.lang.Object oid,
                     boolean transactional,
                     boolean throwDuplicateException)

Description copied from interface: PersistenceManagerInternal
Adds persistent object to the cache.


Specified by:
register in interface PersistenceManagerInternal


Parameters:
sm - instance of StateManagerInternal to be added
oid - ObjectId of the corresponding persistence-capable instance
transactional - true if the corresponding lifecycle state is transactional
throwDuplicateException - true if the exception should be thrown in case the same ObjectId
 has been already registered.
See Also:
PersistenceManagerInternal.register(StateManagerInternal sm, Object oid, 
 boolean transactional, boolean throwDuplicateException)





registerTransient
public void registerTransient(StateManagerInternal sm)

Description copied from interface: PersistenceManagerInternal
Adds transient object to the transient cache.


Specified by:
registerTransient in interface PersistenceManagerInternal


Parameters:
sm - instance of StateManagerInternal to be added
See Also:
PersistenceManagerInternal.registerTransient(StateManagerInternal sm)





deregister
public void deregister(java.lang.Object oid)

Description copied from interface: PersistenceManagerInternal
Removes the object from the cache.


Specified by:
deregister in interface PersistenceManagerInternal


Parameters:
oid - ObjectId of the instance to be removed.
See Also:
PersistenceManagerInternal.deregister(Object oid)





deregisterTransient
public void deregisterTransient(StateManagerInternal sm)

Description copied from interface: PersistenceManagerInternal
Removes transient object from the transient cache.


Specified by:
deregisterTransient in interface PersistenceManagerInternal


Parameters:
sm - instance of StateManagerInternal to be removed
See Also:
PersistenceManagerInternal.deregisterTransient(StateManagerInternal sm)





replaceObjectId
public void replaceObjectId(java.lang.Object oldId,
                            java.lang.Object newId)

Description copied from interface: PersistenceManagerInternal
Replaces the objectId key value in the cache.


Specified by:
replaceObjectId in interface PersistenceManagerInternal


Parameters:
oldId - previous value of ObjectId.
newId - new value of ObjectId.
See Also:
PersistenceManagerInternal.replaceObjectId(Object oldId, Object newId)





markAsFlushed
public void markAsFlushed(StateManagerInternal sm)

Description copied from interface: PersistenceManagerInternal
Called by StateManagerInternal#markAsFlushed() to adjust transactional cache(s)
 if necessary after successful flush to the data store.


Specified by:
markAsFlushed in interface PersistenceManagerInternal


Parameters:
sm - StateManagerInternal instance that has been flushed
See Also:
PersistenceManagerInternal.markAsFlushed(StateManagerInternal sm)





insideCommit
public boolean insideCommit()

Description copied from interface: PersistenceManagerInternal
Returns true if the call initiated as a result of the commit process,
 versus flush for query in a datastore transaction.


Specified by:
insideCommit in interface PersistenceManagerInternal



Returns:
true if commit has started
See Also:
PersistenceManagerInternal.insideCommit()





hereIsStateManager
public void hereIsStateManager(StateManagerInternal sm,
                               javax.jdo.spi.PersistenceCapable pc)

A helper method called from the StateManager inside getPersistenceManager()
 to identify StateManager associated with this PC instance


Specified by:
hereIsStateManager in interface PersistenceManagerInternal


Parameters:
pc - PC instance
sm - StateManager to save





getStateManager
public StateManagerInternal getStateManager(java.lang.Object oid,
                                            java.lang.Class pcClass)

Description copied from interface: PersistenceManagerInternal
Provides a StateManagerInternal for the given Object Id.


Specified by:
getStateManager in interface PersistenceManagerInternal


Parameters:
oid - the given Object Id.
pcClass - Class of a PersistenceCapable instance to be created
 if this Object Id was not registered with this PersistenceManager.
Returns:
A StateManagerInternal.
See Also:
PersistenceManagerInternal.getStateManager(java.lang.Object, java.lang.Class)





findStateManager
public StateManagerInternal findStateManager(javax.jdo.spi.PersistenceCapable pc)

A helper method to find the StateManager associated with this PC instance


Specified by:
findStateManager in interface PersistenceManagerInternal


Parameters:
pc - PC instance
Returns:
StateManager as StateManagerInternal





getCurrentWrapper
public javax.jdo.PersistenceManager getCurrentWrapper()

Returns current wrapper


Specified by:
getCurrentWrapper in interface PersistenceManagerInternal








getInsertedInstances
public java.util.Collection getInsertedInstances()

Returns a Collection of instances that has been made persistent
 or become persistent through persistence-by-reachability
 algorithm in this transaction. Called by the Extent.iterator.


Specified by:
getInsertedInstances in interface PersistenceManagerInternal



Returns:
Collection of Persistent-New instances.
See Also:
PersistenceManagerInternal.getInsertedInstances()





hashCode
public int hashCode()

Returns a hash code value for this PersistenceManager.






Returns:
a hash code value for this PersistenceManager.





equals
public boolean equals(java.lang.Object obj)

Indicates whether some other object is "equal to" this one.





Parameters:
obj - the reference object with which to compare.
Returns:
true if this object is the same as the obj
          argument; false otherwise.





pushCurrentWrapper
protected void pushCurrentWrapper(PersistenceManagerWrapper pmw)

Remember the current wrapper











popCurrentWrapper
protected void popCurrentWrapper(PersistenceManagerWrapper prev)

Replace current wrapper with the previous











setJTATransaction
protected void setJTATransaction(java.lang.Object t)

with the current thread in the managed environment











deregisterJTA
protected void deregisterJTA()

Disassociate this PersistenceManager with the current JTA
 transaction.











forceClose
protected void forceClose()

Close this persistence manager even if there are open wrappers
 or an uncomplete transaction.
 Called by transaction completion in case of an inconsistent state
 or as a part of a normal close process.











verify
protected boolean verify(java.lang.String username,
                         java.lang.String password)

Verify that cached instance of a PersistenceManager was initialy
 requested with the same values for username and password











flushInstances
protected void flushInstances()

Called by Transaction commit()
 Loops through transactional cache and calls PersistentStore.updatePersistent()
 on each instance











afterCompletion
protected void afterCompletion(int status)

Called by Transaction commit() or rollback()
 cleans up transactional cache





Parameters:
status - javax.transaction.Status





notifyStatusChange
protected void notifyStatusChange(boolean isActive)

For Transaction to notify PersistenceManager that
 status is changed











notifyOptimistic
protected void notifyOptimistic(boolean optimistic)

For Transaction to notify PersistenceManager that
 optimistic flag is changed











getExternalObjectId
private java.lang.Object getExternalObjectId(java.lang.Object pc,
                                             boolean transactional)

Returns external representation of the current or transactional
 objectId depending on the parameter





Parameters:
pc - the PersistenceCapable instance
transactional - true if the transactional Id is requested
Returns:
the corresponding ObjectId of the instance. Returns null
 if pc is null, not persistence-capable, or not persistent.





assertActiveTransaction
private void assertActiveTransaction(boolean insideQuery)

assert that the associated Transaction is active











assertPersistenceCapable
private void assertPersistenceCapable(java.lang.Object pc,
                                      java.lang.String caller)

assert Object is PersistenceCapable











assertPersistenceManager
private void assertPersistenceManager(javax.jdo.spi.PersistenceCapable pc)

assert PersistenceCapable is associated with this instance of PersistenceManager











validateResult
private void validateResult(int l,
                            java.lang.Throwable[] err)

Helper method to validate errors on processing arrays of objects.





Parameters:
l - actual size of the array
err - array of Throwable to validate
Throws:
javax.jdo.JDOUserException - if l is greater than 0.





getInitialSize
private java.lang.Integer getInitialSize(java.lang.Class type)

Helper method to calculate initialSize of the Collection or Map if
 null is specifield for the new tracked instance.





Parameters:
type - Class type for which the request is processed.
Returns:
default initialSize as Integer.





makePersistentInternal
private java.lang.Object makePersistentInternal(java.lang.Object pc)

Internal method for processing makePersistent request.





See Also:
makePersistent(Object pc)





makePersistentAllInternal
private java.lang.Object[] makePersistentAllInternal(java.lang.Object[] pcs)

Internal method for processing makePersistentAll request.





See Also:
makePersistentAll(Object[] pcs)





deletePersistentInternal
private void deletePersistentInternal(java.lang.Object pc)

Internal method to process deletePersistent call.





See Also:
deletePersistent(Object pc)





deletePersistentAllInternal
private void deletePersistentAllInternal(java.lang.Object[] pcs)

Internal method to process deletePersistentAll call.





See Also:
deletePersistentAll(Object[] pcs)





makeTransientInternal
private void makeTransientInternal(java.lang.Object pc)

Internal method to process makeTransient call.





See Also:
makeTransient(Object pc)





makeTransientAllInternal
private void makeTransientAllInternal(java.lang.Object[] pcs)

Internal method to process makeTransientAll call.





See Also:
makeTransientAll(Object[] pcs)





makeTransactionalInternal
private void makeTransactionalInternal(java.lang.Object pc)

Internal method to process makeTransactional call.





See Also:
makeTransactional(Object pc)





makeTransactionalAllInternal
private void makeTransactionalAllInternal(java.lang.Object[] pcs)

Internal method to process makeTransactionalAll call.





See Also:
makeTransactionalAll(Object[] pcs)





makeNontransactionalInternal
private void makeNontransactionalInternal(java.lang.Object pc)

Internal method to process makeNontransactional  call.





See Also:
makeNontransactional(Object pc)





makeNontransactionalAllInternal
private void makeNontransactionalAllInternal(java.lang.Object[] pcs)

Internal method to process makeNontransactionalAll  call.





See Also:
makeNontransactionalAll(Object[] pcs)





evictInternal
private void evictInternal(java.lang.Object pc)

Internal method to process evict call.





See Also:
evict(Object pc)





evictAllInternal
private void evictAllInternal(java.lang.Object[] pcs)

Internal method to process evictAll call.





See Also:
evictAll(Object[] pcs)





refreshInternal
private void refreshInternal(java.lang.Object pc)

Internal method to process refresh call.





See Also:
refresh(Object pc)





refreshAllInternal
private void refreshAllInternal(java.lang.Object[] pcs)

Internal method to process refreshAll call.





See Also:
refreshAll(Object[] pcs)





retrieveInternal
private void retrieveInternal(java.lang.Object pc,
                              boolean DFGOnly)

Internal method to process retrieve call.





See Also:
retrieve(Object pc)





retrieveAllInternal
private void retrieveAllInternal(java.lang.Object[] pcs,
                                 boolean DFGOnly)

Internal method to process retrieveAll call.





See Also:
retrieveAll(Object[] pcs)





debug
private void debug(java.lang.String msg)

Tracing method





Parameters:
msg - String to display





debugging
private boolean debugging()

Verifies if debugging is enabled.






Returns:
true if debugging is enabled.





getContextClassLoaderPrivileged
public java.lang.ClassLoader getContextClassLoaderPrivileged()
                                                      throws java.lang.SecurityException

Calls getContextClassLoader for the current Thread in a
 doPrivileged block.






Returns:
the context class loader of the current Thread
Throws:
java.lang.SecurityException - thrown by getContextClassLoader.





assertReadAllowed
public void assertReadAllowed()

Assert the NontransactionalRead flag is true or a transaction is active.


Specified by:
assertReadAllowed in interface PersistenceManagerInternal

















  
      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.jdo.impl.pm Class PersistenceManagerImpl

_isClosed

_transaction

_jta

current

pmf

_txCache

_storeManager

_ignoreCache

_detachAllOnCommit

_activeTransaction

optimistic

multithreaded

_userObject

_flushing

myClassLoader

sigSCO_Short

sigSCO_Collection

sigSCO_Map

sigSCO_HashSet

sigSCO_TreeSet

sigSCO_HashMap

sigSCO_TreeMap

int11

int10

javaModelFactory

logger

msg

lookingFor

pc

PersistenceManagerImpl

setIgnoreCache

getIgnoreCache

setDetachAllOnCommit

getDetachAllOnCommit

setMultithreaded

getMultithreaded

isClosed

close

currentTransaction

getObjectById

getObjectById

getObjectById

getObjectId

loadClass

loadPCClassForObjectIdClass

getInternalObjectId

getTransactionalObjectId

newObjectIdInstance

getObjectsById

getObjectsById

getObjectsById

getObjectsById

getObjectIdClass

newQuery

newQuery

newQuery

newQuery

newQuery

newQuery

newQuery

newQuery

newQuery

newQuery

newNamedQuery

getExtent

getExtent

makePersistent

makePersistentAll

makePersistentAll

deletePersistent

deletePersistentAll

deletePersistentAll

makeTransient

makeTransientAll

makeTransientAll

makeTransient

makeTransientAll

makeTransientAll

makeTransactional

org.apache.jdo.impl.pm
Class PersistenceManagerImpl