FileDocCategorySizeDatePackage
PersistenceManagerWrapper.javaAPI DocGlassfish v2 API25322Fri May 04 22:35:06 BST 2007com.sun.jdo.spi.persistence.support.sqlstore.impl

PersistenceManagerWrapper

public class PersistenceManagerWrapper extends Object implements PersistenceManager
PersistenceManagerWrapper is ....

Fields Summary
private PersistenceManagerWrapper
prev
private PersistenceManagerImpl
pm
private boolean
isValid
private static final ResourceBundle
messages
I18N message handler
Constructors Summary
PersistenceManagerWrapper(PersistenceManagerImpl pm)


    // Constructed by  com.sun.jdo.spi.persistence.support.sqlstore.SQLPersistenceManagerFactory
      
        this.pm = pm;
        prev = pm.getCurrentWrapper();
        pm.pushCurrentWrapper(this);
        isValid = true;
Methods Summary
public voidclose()
A PersistenceManager instance can be used until it is closed.

This method closes the PersistenceManager, which if pooled, releases it to the pool of available PersistenceManagers.

        if (isValid) {
            isValid = false;
            pm.popCurrentWrapper(prev);
            pm = null;
            prev = null;
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public TransactioncurrentTransaction()
There is exactly one Transaction associated with a PersistenceManager.

return
the Transaction associated with this PersistenceManager.

        if (isValid) {
            return pm.currentTransaction();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public voiddeletePersistent(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.

param
pc a persistent instance

        if (isValid) {
            pm.deletePersistent(pc);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public voiddeletePersistent(java.lang.Object[] pcs)
Delete an array of instances from the data store.

param
pcs a Collection of persistent instances
see
#deletePersistent(Object pc)

        if (isValid) {
            pm.deletePersistent(pcs);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public voiddeletePersistent(java.util.Collection pcs)
Delete a Collection of instances from the data store.

param
pcs a Collection of persistent instances
see
#deletePersistent(Object pc)

        if (isValid) {
            pm.deletePersistent(pcs);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public java.util.CollectiongetExtent(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 a Collection of instances in the data store that might be iterated or given to a Query as the Collection of candidate instances.

param
persistenceCapableClass Class of instances
param
subclasses whether to include instances of subclasses
return
a Collection of instances
see
Query

        if (isValid) {
            return pm.getExtent(persistenceCapableClass, subclasses);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public java.lang.ObjectgetObjectById(java.lang.Object oid)
This method locates a persistent instance in the cache of instances managed by this PersistenceManager. If an instance with the same ObjectId is found it is returned. Otherwise, a new instance is created and associated with the ObjectId.

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.

param
oid an ObjectId
return
the PersistenceCapable instance with the specified ObjectId

        if (isValid) {
            return pm.getObjectById(oid);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public java.lang.ObjectgetObjectById(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 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.

see
#getObjectId(Object pc)
return
the PersistenceCapable instance with the specified ObjectId
param
oid an ObjectId
param
validate if the existence of the instance is to be validated

        if (isValid) {
            return pm.getObjectById(oid, validate);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public java.lang.ObjectgetObjectId(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.

param
pc the PersistenceCapable instance
return
the ObjectId of the instance

        if (isValid) {
            return pm.getObjectId(pc);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public java.lang.ClassgetObjectIdClass(java.lang.Class cls)
In order for the application to construct instance of the ObjectId class it needs to know the class being used by the JDO implementation.

param
cls the PersistenceCapable Class
return
the Class of the ObjectId of the parameter

        if (isValid) {
            return pm.getObjectIdClass(cls);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public PersistenceManagergetPersistenceManager()

        return (PersistenceManager) pm;
public PersistenceManagerFactorygetPersistenceManagerFactory()
This method returns the PersistenceManagerFactory used to create this PersistenceManager. It returns null if this instance was created via a constructor.

return
the PersistenceManagerFactory that created this PersistenceManager

        if (isValid) {
            return pm.getPersistenceManagerFactory();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
public java.util.PropertiesgetProperties()
The JDO vendor might store certain non-operational properties and make those properties available to applications (for troubleshooting).

Standard properties include:

  • VendorName
  • VersionNumber

    • return
    the Properties of this PersistenceManager

            if (isValid) {
            return pm.getProperties();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public booleangetRequireCopyObjectId()
    Returns the boolean value of the requireCopyObjectId flag for this PersistenceManager. If set to false, the PersistenceManager does not create a copy of an ObjectId for PersistenceManager.getObjectId(Object pc) and PersistenceManager.getObjectById(Object oid) requests.

    see
    PersistenceManager#getObjectId(Object pc)
    see
    PersistenceManager#getObjectById(Object oid)
    return
    boolean requireCopyObjectId flag

            if (isValid) {
            return pm.getRequireCopyObjectId();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public booleangetRequireTrackedSCO()
    Returns the boolean value of the requireTrackedSCO flag for this PersistenceManager. If set to false, the PersistenceManager will not create tracked SCO instances for new persistent instances at commit with retainValues set to true and while retrieving data from a datastore.

    return
    boolean requireTrackedSCO flag

            if (isValid) {
            return pm.getRequireTrackedSCO();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public booleangetSupersedeDeletedInstance()
    Returns the boolean value of the supersedeDeletedInstance flag for this PersistenceManager. If set to true, deleted instances are allowed to be replaced with persistent-new instances with the equal Object Id.

    return
    boolean supersedeDeletedInstance flag

            if (isValid) {
            return pm.getSupersedeDeletedInstance();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public java.lang.ObjectgetTransactionalInstance(java.lang.Object pc)
    This method is used to get a PersistenceCapable instance representing the same data store object as the parameter, that is valid for this PersistenceManager.

    param
    pc a PersistenceCapable instance
    return
    the PersistenceCapable instance representing the same data store object

            if (isValid) {
            return pm.getTransactionalInstance(pc);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public java.lang.ObjectgetUserObject()
    The application can manage the PersistenceManager instances more easily by having an application object associated with each PersistenceManager instance.

    return
    the user object associated with this PersistenceManager
    see
    #setUserObject

            if (isValid) {
            return pm.getUserObject();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public booleanisClosed()
    A PersistenceManager instance can be used until it is closed.

    return
    if this PersistenceManager has been closed
    see
    #close()

            if (isValid) {
            return pm.isClosed();
        } else {
            return true;
        }
    public voidmakePersistent(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.

    param
    pc a transient instance of a Class that implements PersistenceCapable

            if (isValid) {
            pm.makePersistent(pc);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public voidmakePersistent(java.lang.Object[] pcs)
    Make an array of instances persistent.

    param
    pcs an array of transient instances
    see
    #makePersistent(Object pc)

            if (isValid) {
            pm.makePersistent(pcs);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public voidmakePersistent(java.util.Collection pcs)
    Make a Collection of instances persistent.

    param
    pcs a Collection of transient instances
    see
    #makePersistent(Object pc)

            if (isValid) {
            pm.makePersistent(pcs);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public java.lang.ObjectnewCollectionInstance(java.lang.Class type, java.lang.Object owner, java.lang.String fieldName, java.lang.Class elementType, boolean allowNulls, int initialSize)
    Returns a new Collection instance of the type specified, with the owner and field name to notify upon changes to the value of any of its fields. The collection class restricts the element types allowed to the elementType or instances assignable to the elementType, and allows nulls to be added as elements based on the setting of allowNulls. The Collection has an initial size as specified by the initialSize parameter.

    param
    type Class of the new SCO instance
    param
    owner the owner to notify upon changes
    param
    fieldName the field to notify upon changes
    param
    elementType the element types allowed
    param
    allowNulls true if allowed
    param
    initialSize initial size of the Collection
    return
    the object of the class type

            if (isValid) {
            return pm.newCollectionInstance(type, owner, fieldName, elementType, allowNulls, initialSize);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public QuerynewQuery(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.

    param
    cls the Class of results
    param
    cln the Collection of candidate instances
    param
    filter the Filter for candidate instances
    return
    the new Query

            if (isValid) {
            return pm.newQuery(cls, cln, filter);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public QuerynewQuery()
    Create a new Query with no elements.

    return
    a new Query instance with no elements.

            if (isValid) {
            return pm.newQuery();
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public QuerynewQuery(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.

    return
    the new Query
    param
    compiled another Query from the same JDO implementation

            if (isValid) {
            return pm.newQuery(compiled);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public QuerynewQuery(java.lang.Class cls)
    Create a new Query specifying the Class of the results.

    param
    cls the Class of the results
    return
    the new Query

            if (isValid) {
            return pm.newQuery(cls);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public QuerynewQuery(java.lang.Class cls, java.util.Collection cln)
    Create a new Query with the Class of the results and candidate Collection. specified.

    param
    cls the Class of results
    param
    cln the Collection of candidate instances
    return
    the new Query

            if (isValid) {
            return pm.newQuery(cls, cln);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public QuerynewQuery(java.lang.Class cls, java.lang.String filter)
    Create a new Query with the Class of the results and Filter. specified.

    param
    cls the Class of results
    param
    filter the Filter for candidate instances
    return
    the new Query

            if (isValid) {
            return pm.newQuery(cls, filter);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public java.lang.ObjectnewSCOInstance(java.lang.Class type, java.lang.Object owner, java.lang.String fieldName)
    Returns a new Second Class Object instance of the type specified, with the owner and field name to notify upon changes to the value of any of its fields. If a collection class is created, then the class does not restrict the element types, and allows nulls to be added as elements.

    param
    type Class of the new SCO instance
    param
    owner the owner to notify upon changes
    param
    fieldName the field to notify upon changes
    return
    the object of the class type

            if (isValid) {
            return pm.newSCOInstance(type, owner, fieldName);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public voidsetRequireCopyObjectId(boolean flag)
    Sets the requireCopyObjectId flag for this PersistenceManager. If set to false, the PersistenceManager will not create a copy of an ObjectId for PersistenceManager.getObjectId(Object pc) and PersistenceManager.getObjectById(Object oid) requests.

    see
    PersistenceManager#getObjectId(Object pc)
    see
    PersistenceManager#getObjectById(Object oid)
    param
    flag boolean requireCopyObjectId flag

            if (isValid) {
            pm.setRequireCopyObjectId(flag);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public voidsetRequireTrackedSCO(boolean flag)
    Sets the requireTrackedSCO flag for this PersistenceManager. If set to false, the PersistenceManager will not create tracked SCO instances for new persistent instances at commit with retainValues set to true and while retrieving data from a datastore.

    param
    flag boolean requireTrackedSCO flag

            if (isValid) {
            pm.setRequireTrackedSCO(flag);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public voidsetSupersedeDeletedInstance(boolean flag)
    Sets the supersedeDeletedInstance flag for this PersistenceManager.

    param
    flag boolean supersedeDeletedInstance flag

            if (isValid) {
            pm.setSupersedeDeletedInstance(flag);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }
    public voidsetUserObject(java.lang.Object o)
    The application can manage the PersistenceManager instances more easily by having an application object associated with each PersistenceManager instance.

    param
    o the user instance to be remembered by the PersistenceManager
    see
    #getUserObject

            if (isValid) {
            pm.setUserObject(o);
        } else {
            throw new JDOUserException(I18NHelper.getMessage(messages,
                    "jdo.persistencemanagerwrapper.invalidpm"));// NOI18N
        }