PersistenceCapable instances without declaring them to be
* PersistenceCapable.
* It is also used to acquire a PersistenceManagerFactory via
* various methods.
*
This helper class defines static methods that allow a JDO-aware
* application to examine the runtime state of instances. For example,
* an application can discover whether the instance is persistent,
* transactional, dirty, new, deleted, or detached; and to get its associated
* PersistenceManager if it has one.
*
* @version 2.0
*/
public class JDOHelper extends Object {
/** The Internationalization message helper.
*/
private final static I18NHelper msg =
I18NHelper.getInstance ("javax.jdo.Bundle"); //NOI18N
/** The JDOImplHelper instance used for handling non-binary-compatible
* implementations.
*/
private static JDOImplHelper implHelper = (JDOImplHelper)
AccessController.doPrivileged(
new PrivilegedAction () {
public Object run () {
return JDOImplHelper.getInstance();
}
}
);
/** The stateless instance used for handling non-binary-compatible
* implementations of getPersistenceManager.
*/
static StateInterrogationObjectReturn getPersistenceManager =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getPersistenceManager(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of getObjectId.
*/
static StateInterrogationObjectReturn getObjectId =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getObjectId(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of getTransactionalObjectId.
*/
static StateInterrogationObjectReturn getTransactionalObjectId =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getTransactionalObjectId(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of getVersion.
*/
static StateInterrogationObjectReturn getVersion =
new StateInterrogationObjectReturn() {
public Object get(Object pc, StateInterrogation si) {
return si.getVersion(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isPersistent.
*/
static StateInterrogationBooleanReturn isPersistent =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isPersistent(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isTransactional.
*/
static StateInterrogationBooleanReturn isTransactional =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isTransactional(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isDirty.
*/
static StateInterrogationBooleanReturn isDirty =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isDirty(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isNew.
*/
static StateInterrogationBooleanReturn isNew =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isNew(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isDeleted.
*/
static StateInterrogationBooleanReturn isDeleted =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isDeleted(pc);
}
};
/** The stateless instance used for handling non-binary-compatible
* implementations of isDetached.
*/
static StateInterrogationBooleanReturn isDetached =
new StateInterrogationBooleanReturn() {
public Boolean is(Object pc, StateInterrogation si) {
return si.isDetached(pc);
}
};
/** Return the associated PersistenceManager if there is one.
* Transactional and persistent instances return the associated
* PersistenceManager.
*
*
Transient non-transactional instances and instances of classes
* that do not implement PersistenceCapable return
* null.
* @see PersistenceCapable#jdoGetPersistenceManager()
* @param pc the PersistenceCapable instance.
* @return the PersistenceManager associated with the parameter
* instance.
*/
public static PersistenceManager getPersistenceManager(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetPersistenceManager();
} else {
return (PersistenceManager)
implHelper.nonBinaryCompatibleGet(pc, getPersistenceManager);
}
}
/** Explicitly mark the parameter instance and field dirty.
* Normally, PersistenceCapable classes are able to detect
* changes made to their fields. However, if a reference to an array is
* given to a method outside the class, and the array is modified, then the
* persistent instance is not aware of the change. This API allows the
* application to notify the instance that a change was made to a field.
*
*
Transient instances and instances of classes
* that do not implement PersistenceCapable ignore this method.
* @see PersistenceCapable#jdoMakeDirty(String fieldName)
* @param pc the PersistenceCapable instance.
* @param fieldName the name of the field to be marked dirty.
*/
public static void makeDirty(Object pc, String fieldName) {
if (pc instanceof PersistenceCapable) {
((PersistenceCapable)pc).jdoMakeDirty(fieldName);
} else {
implHelper.nonBinaryCompatibleMakeDirty(pc, fieldName);
}
}
/** Return a copy of the JDO identity associated with the parameter
* instance.
*
*
Persistent instances of PersistenceCapable classes have a
* JDO identity managed by the PersistenceManager. This method
* returns a copy of the ObjectId that represents the JDO identity.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return null.
*
*
The ObjectId may be serialized
* and later restored, and used with a PersistenceManager from
* the same JDO implementation to locate a persistent instance with the same
* data store identity.
*
*
If the JDO identity is managed by the application, then the ObjectId
* may be used with a PersistenceManager from any JDO
* implementation that supports the PersistenceCapable class.
*
*
If the JDO identity is not managed by the application or the data * store, then the ObjectId returned is only valid within the current * transaction. *
* @see PersistenceManager#getObjectId(Object pc)
* @see PersistenceCapable#jdoGetObjectId()
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @param pc the PersistenceCapable instance.
* @return a copy of the ObjectId of the parameter instance as of the
* beginning of the transaction.
*/
public static Object getObjectId(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetObjectId();
} else {
return implHelper.nonBinaryCompatibleGet(pc, getObjectId);
}
}
/** Get object ids for a collection of instances. For each instance
* in the parameter, the getObjectId method is called. This method
* returns one identity instance for each element
* in the parameter. The order of iteration of the returned
* Collection exactly matches the order of iteration of the
* parameter Collection.
* @param pcs the persistence-capable instances
* @return the object ids of the parameters
* @see #getObjectId(Object pc)
* @see #getObjectIds(Object[] pcs)
* @since 2.0
*/
public static Collection getObjectIds(Collection pcs) {
ArrayList result = new ArrayList();
for (Iterator it = pcs.iterator(); it.hasNext();) {
result.add(getObjectId(it.next()));
}
return result;
}
/** Get object ids for an array of instances. For each instance
* in the parameter, the getObjectId method is called. This method
* returns one identity instance for each element
* in the parameter. The order of instances of the returned
* array exactly matches the order of instances of the
* parameter array.
* @param pcs the persistence-capable instances
* @return the object ids of the parameters
* @see #getObjectId(Object pc)
* @see #getObjectIds(Collection pcs)
* @since 2.0
*/
public static Object[] getObjectIds(Object[] pcs) {
Object[] result = new Object[pcs.length];
for (int i = 0; i < pcs.length; ++i) {
result[i] = getObjectId(pcs[i]);
}
return result;
}
/** Return a copy of the JDO identity associated with the parameter
* instance.
*
* @see PersistenceCapable#jdoGetTransactionalObjectId()
* @see PersistenceManager#getObjectById(Object oid, boolean validate)
* @param pc the PersistenceCapable instance.
* @return a copy of the ObjectId of the parameter instance as modified in
* this transaction.
*/
public static Object getTransactionalObjectId(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetTransactionalObjectId();
} else {
return implHelper.nonBinaryCompatibleGet(
pc, getTransactionalObjectId);
}
}
/**
* Return the version of the instance.
* @since 2.0
* @param pc the instance
* @return the version of the instance
*/
public static Object getVersion (Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoGetVersion();
} else {
return implHelper.nonBinaryCompatibleGet(pc, getVersion);
}
}
/** Tests whether the parameter instance is dirty.
*
* Instances that have been modified, deleted, or newly
* made persistent in the current transaction return true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see javax.jdo.spi.StateManager#makeDirty(PersistenceCapable pc,
* String fieldName)
* @see PersistenceCapable#jdoIsDirty()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance has been modified in
* the current transaction.
*/
public static boolean isDirty(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsDirty();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isDirty);
}
}
/** Tests whether the parameter instance is transactional.
*
* Instances whose state is associated with the current transaction
* return true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
* @see PersistenceCapable#jdoIsTransactional()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance is transactional.
*/
public static boolean isTransactional(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsTransactional();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isTransactional);
}
}
/** Tests whether the parameter instance is persistent.
*
* Instances that represent persistent objects in the data store
* return true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see PersistenceManager#makePersistent(Object pc)
* @see PersistenceCapable#jdoIsPersistent()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance is persistent.
*/
public static boolean isPersistent(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsPersistent();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isPersistent);
}
}
/** Tests whether the parameter instance has been newly made persistent.
*
* Instances that have been made persistent in the current transaction
* return true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see PersistenceManager#makePersistent(Object pc)
* @see PersistenceCapable#jdoIsNew()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance was made persistent
* in the current transaction.
*/
public static boolean isNew(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsNew();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isNew);
}
}
/** Tests whether the parameter instance has been deleted.
*
* Instances that have been deleted in the current transaction return
* true.
*
*
Transient instances and instances of classes that do not implement
* PersistenceCapable return false.
*
* @see PersistenceManager#deletePersistent(Object pc)
* @see PersistenceCapable#jdoIsDeleted()
* @param pc the PersistenceCapable instance.
* @return true if the parameter instance was deleted
* in the current transaction.
*/
public static boolean isDeleted(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsDeleted();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isDeleted);
}
}
/**
* Tests whether the parameter instance has been detached.
*
* Instances that have been detached return true.
*
*
Transient instances return false. *
* @see PersistenceCapable#jdoIsDetached()
* @return true if this instance is detached.
* @since 2.0
* @param pc the instance
*/
public static boolean isDetached(Object pc) {
if (pc instanceof PersistenceCapable) {
return ((PersistenceCapable)pc).jdoIsDetached();
} else {
return implHelper.nonBinaryCompatibleIs(pc, isDetached);
}
}
/** Get a PersistenceManagerFactory based on a Properties
* instance, using the current thread's context class loader to locate the
* PersistenceManagerFactory class.
* @return the PersistenceManagerFactory.
* @param props a Properties instance with properties of the
* PersistenceManagerFactory.
* @see #getPersistenceManagerFactory(Map,ClassLoader)
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(Map props) {
ClassLoader cl = getContextClassLoader();
return getPersistenceManagerFactory (props, cl);
}
/**
* Get a PersistenceManagerFactory based on a
* Properties instance and a class loader.
* The following are standard key values:
* "javax.jdo.PersistenceManagerFactoryClass"
*
"javax.jdo.option.Optimistic",
*
"javax.jdo.option.RetainValues",
*
"javax.jdo.option.RestoreValues",
*
"javax.jdo.option.IgnoreCache",
*
"javax.jdo.option.NontransactionalRead",
*
"javax.jdo.option.NontransactionalWrite",
*
"javax.jdo.option.Multithreaded",
*
"javax.jdo.option.ConnectionUserName",
*
"javax.jdo.option.ConnectionPassword",
*
"javax.jdo.option.ConnectionURL",
*
"javax.jdo.option.ConnectionFactoryName",
*
"javax.jdo.option.ConnectionFactory2Name",
*
"javax.jdo.option.Mapping",
*
"javax.jdo.mapping.Catalog",
*
"javax.jdo.mapping.Schema".
*
JDO implementations
* are permitted to define key values of their own. Any key values not
* recognized by the implementation must be ignored. Key values that are
* recognized but not supported by an implementation must result in a
* JDOFatalUserException thrown by the method.
*
The returned PersistenceManagerFactory is not
* configurable (the setXXX methods will throw an
* exception).
*
JDO implementations might manage a map of instantiated
* PersistenceManagerFactory instances based on specified
* property key values, and return a previously instantiated
* PersistenceManagerFactory instance. In this case, the
* properties of the returned instance must exactly match the requested
* properties.
* @return the PersistenceManagerFactory.
* @param props a Properties instance with properties of the
* PersistenceManagerFactory.
* @param cl the class loader to use to load the
* PersistenceManagerFactory class
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(Map props, ClassLoader cl) {
String pmfClassName = (String) props.get (
"javax.jdo.PersistenceManagerFactoryClass"); //NOI18N
if (pmfClassName == null) {
throw new JDOFatalUserException (msg.msg(
"EXC_GetPMFNoClassNameProperty")); // NOI18N
}
try {
Class pmfClass = cl.loadClass (pmfClassName);
Method pmfMethod = pmfClass.getMethod(
"getPersistenceManagerFactory", //NOI18N
new Class[] {Map.class});
return (PersistenceManagerFactory) pmfMethod.invoke (
null, new Object[] {props});
} catch (ClassNotFoundException cnfe) {
throw new JDOFatalUserException (msg.msg(
"EXC_GetPMFClassNotFound", pmfClassName), cnfe); //NOI18N
} catch (IllegalAccessException iae) {
throw new JDOFatalUserException (msg.msg(
"EXC_GetPMFIllegalAccess", pmfClassName), iae); //NOI18N
} catch (NoSuchMethodException nsme) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFNoSuchMethod"), nsme); //NOI18N
} catch (InvocationTargetException ite) {
Throwable nested = ite.getTargetException();
if (nested instanceof JDOException) {
throw (JDOException)nested;
} else throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFUnexpectedException"), ite); //NOI18N
} catch (NullPointerException e) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFNullPointerException", pmfClassName), e); //NOI18N
} catch (ClassCastException e) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFClassCastException", pmfClassName), e); //NOI18N
} catch (Exception e) {
throw new JDOFatalInternalException (msg.msg(
"EXC_GetPMFUnexpectedException"), e); //NOI18N
}
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the properties stored in the resource at
* propsResource. This method is equivalent to
* invoking {@link
* #getPersistenceManagerFactory(String,ClassLoader)} with
* Thread.currentThread().getContextClassLoader() as
* the loader argument.
* @since 2.0
* @param propsResource the resource containing the Properties
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String propsResource) {
return getPersistenceManagerFactory (propsResource,
getContextClassLoader());
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the properties stored in the resource at
* propsResource. Loads the resource via
* loader, and creates a {@link
* PersistenceManagerFactory} with loader. Any
* IOExceptions thrown during resource loading will
* be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param propsResource the resource containing the Properties
* @param loader the class loader to use to load both the propsResource and
* the PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String propsResource, ClassLoader loader) {
return getPersistenceManagerFactory(propsResource, loader, loader);
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the properties stored in the resource at
* propsResource. Loads the Properties via
* propsLoader, and creates a {@link
* PersistenceManagerFactory} with pmfLoader. Any
* IOExceptions thrown during resource loading will
* be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param propsResource the resource containing the Properties
* @param propsLoader the class loader to use to load the propsResource
* @param pmfLoader the class loader to use to load the
* PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String propsResource, ClassLoader propsLoader, ClassLoader pmfLoader) {
if (propsResource == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullResource")); //NOI18N
if (propsLoader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullPropsLoader")); //NOI18N
if (pmfLoader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullPMFLoader")); //NOI18N
Properties props = new Properties ();
InputStream in = null;
try {
in = propsLoader.getResourceAsStream (propsResource);
if (in == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNoResource", propsResource, propsLoader)); //NOI18N
props.load (in);
} catch (IOException ioe) {
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFIOExceptionRsrc", propsResource), ioe); //NOI18N
}
finally {
if (in != null)
try {
in.close ();
} catch (IOException ioe) { }
}
return getPersistenceManagerFactory (props, pmfLoader);
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the properties stored in the file at
* propsFile. This method is equivalent to
* invoking {@link
* #getPersistenceManagerFactory(File,ClassLoader)} with
* Thread.currentThread().getContextClassLoader() as
* the loader argument.
* @since 2.0
* @param propsFile the file containing the Properties
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(File propsFile) {
return getPersistenceManagerFactory (propsFile,
getContextClassLoader());
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the properties stored in the file at
* propsFile. Creates a {@link
* PersistenceManagerFactory} with loader. Any
* IOExceptions or
* FileNotFoundExceptions thrown during resource
* loading will be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param propsFile the file containing the Properties
* @param loader the class loader to use to load the
* PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(File propsFile, ClassLoader loader) {
if (propsFile == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullFile")); //NOI18N
if (loader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullLoader")); //NOI18N
Properties props = new Properties ();
InputStream in = null;
try {
in = new FileInputStream (propsFile);
props.load (in);
} catch (FileNotFoundException fnfe) {
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNoFile", propsFile, loader), fnfe); //NOI18N
} catch (IOException ioe) {
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFIOExceptionFile", propsFile), ioe); //NOI18N
} finally {
if (in != null)
try {
in.close ();
} catch (IOException ioe) { }
}
return getPersistenceManagerFactory (props, loader);
}
/**
* Returns a {@link PersistenceManagerFactory} at the JNDI
* location specified by jndiLocation in the context
* context. If context is
* null, new InitialContext() will be
* used. This method is equivalent to invoking {@link
* #getPersistenceManagerFactory(String,Context,ClassLoader)}
* with Thread.currentThread().getContextClassLoader() as
* the loader argument.
* @since 2.0
* @param jndiLocation the JNDI location containing the
* PersistenceManagerFactory
* @param context the context in which to find the named
* PersistenceManagerFactory
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String jndiLocation, Context context) {
return getPersistenceManagerFactory (jndiLocation, context,
getContextClassLoader());
}
/**
* Returns a {@link PersistenceManagerFactory} at the JNDI
* location specified by jndiLocation in the context
* context. If context is
* null, new InitialContext() will be
* used. Creates a {@link PersistenceManagerFactory} with
* loader. Any NamingExceptions thrown
* will be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param jndiLocation the JNDI location containing the
* PersistenceManagerFactory
* @param context the context in which to find the named
* PersistenceManagerFactory
* @param loader the class loader to use to load the
* PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(String jndiLocation, Context context, ClassLoader loader) {
if (jndiLocation == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullJndiLoc")); //NOI18N
if (loader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullLoader")); //NOI18N
try {
if (context == null)
context = new InitialContext ();
Object o = context.lookup (jndiLocation);
return (PersistenceManagerFactory) PortableRemoteObject.narrow
(o, PersistenceManagerFactory.class);
} catch (NamingException ne) {
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNamingException", jndiLocation, loader), ne); //NOI18N
}
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the Properties stored in the input stream at
* stream. This method is equivalent to
* invoking {@link
* #getPersistenceManagerFactory(InputStream,ClassLoader)} with
* Thread.currentThread().getContextClassLoader() as
* the loader argument.
* @since 2.0
* @param stream the stream containing the Properties
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(InputStream stream) {
return getPersistenceManagerFactory (stream,
getContextClassLoader());
}
/**
* Returns a {@link PersistenceManagerFactory} configured based
* on the Properties stored in the input stream at
* stream. Creates a {@link
* PersistenceManagerFactory} with loader. Any
* IOExceptions thrown during resource
* loading will be wrapped in a {@link JDOFatalUserException}.
* @since 2.0
* @param stream the stream containing the Properties
* @param loader the class loader to use to load the
* PersistenceManagerFactory class
* @return the PersistenceManagerFactory
*/
public static PersistenceManagerFactory getPersistenceManagerFactory
(InputStream stream, ClassLoader loader) {
if (stream == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullStream")); //NOI18N
if (loader == null)
throw new JDOFatalUserException (msg.msg (
"EXC_GetPMFNullLoader")); //NOI18N
Properties props = new Properties ();
try {
props.load (stream);
} catch (IOException ioe) {
throw new JDOFatalUserException
(msg.msg ("EXC_GetPMFIOExceptionStream"), ioe); //NOI18N
}
return getPersistenceManagerFactory (props, loader);
}
/** Get the context class loader associated with the current thread.
* This is done in a doPrivileged block because it is a secure method.
* @return the current thread's context class loader.
* @since 2.0
*/
private static ClassLoader getContextClassLoader() {
return (ClassLoader)AccessController.doPrivileged(
new PrivilegedAction () {
public Object run () {
return Thread.currentThread().getContextClassLoader();
}
}
);
}
}