public void initialize(DataCacheManager manager) { if (evictPolicy == EvictPolicy.TIMESTAMP) { entityTimestampMap = new ConcurrentHashMap<String,Long>(); // Get all persistence types to pre-load the entityTimestamp Map Collection perTypes = conf.getMetaDataRepositoryInstance().getPersistentTypeNames( false, AccessController.doPrivileged(J2DoPrivHelper .getContextClassLoaderAction())); if(perTypes == null) return; // Pre-load all the entity types into the HashMap to handle // synchronization on the map efficiently for (Object o : perTypes) entityTimestampMap.put((String)o, Long.valueOf(0)); } }
public void initialize(DataCacheManager manager) { if (evictPolicy == EvictPolicy.TIMESTAMP) { entityTimestampMap = new ConcurrentHashMap<String,Long>(); // Get all persistence types to pre-load the entityTimestamp Map Collection perTypes = conf.getMetaDataRepositoryInstance().getPersistentTypeNames( false, AccessController.doPrivileged(J2DoPrivHelper .getContextClassLoaderAction())); if(perTypes == null) return; // Pre-load all the entity types into the HashMap to handle // synchronization on the map efficiently for (Object o : perTypes) entityTimestampMap.put((String)o, Long.valueOf(0)); } }
public void initialize(DataCacheManager manager) { if (evictPolicy == EvictPolicy.TIMESTAMP) { entityTimestampMap = new ConcurrentHashMap<String,Long>(); // Get all persistence types to pre-load the entityTimestamp Map Collection perTypes = conf.getMetaDataRepositoryInstance().getPersistentTypeNames( false, AccessController.doPrivileged(J2DoPrivHelper .getContextClassLoaderAction())); if(perTypes == null) return; // Pre-load all the entity types into the HashMap to handle // synchronization on the map efficiently for (Object o : perTypes) entityTimestampMap.put((String)o, Long.valueOf(0)); } }
public void initialize(DataCacheManager manager) { if (evictPolicy == EvictPolicy.TIMESTAMP) { entityTimestampMap = new ConcurrentHashMap<String,Long>(); // Get all persistence types to pre-load the entityTimestamp Map Collection perTypes = conf.getMetaDataRepositoryInstance().getPersistentTypeNames( false, AccessController.doPrivileged(J2DoPrivHelper .getContextClassLoaderAction())); if(perTypes == null) return; // Pre-load all the entity types into the HashMap to handle // synchronization on the map efficiently for (Object o : perTypes) entityTimestampMap.put((String)o, Long.valueOf(0)); } }
/** * Constructor. * * @param repos metadata repository to use internally * @param flags enhancer configuration * @param tmpLoader temporary class loader for loading intermediate classes * @param devscan whether to scan the dev classpath for persistent types * if none are configured */ public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) { _repos = repos; _tmpLoader = tmpLoader; _log = repos.getConfiguration(). getLog(OpenJPAConfiguration.LOG_ENHANCE); _flags = flags; _names = repos.getPersistentTypeNames(devscan, tmpLoader); if (_names == null && _log.isInfoEnabled()) _log.info(_loc.get("runtime-enhance-pcclasses")); }
/** * Constructor. * * @param repos metadata repository to use internally * @param flags enhancer configuration * @param loader temporary class loader for loading intermediate classes * @param devscan whether to scan the dev classpath for persistent types * if none are configured */ public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) { _repos = repos; _tmpLoader = tmpLoader; _log = repos.getConfiguration(). getLog(OpenJPAConfiguration.LOG_ENHANCE); _flags = flags; _names = repos.getPersistentTypeNames(devscan, tmpLoader); if (_names == null && _log.isInfoEnabled()) _log.info(_loc.get("runtime-enhance-pcclasses")); }
/** * Constructor. * * @param repos metadata repository to use internally * @param flags enhancer configuration * @param tmpLoader temporary class loader for loading intermediate classes * @param devscan whether to scan the dev classpath for persistent types * if none are configured */ public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) { _repos = repos; _tmpLoader = tmpLoader; _log = repos.getConfiguration(). getLog(OpenJPAConfiguration.LOG_ENHANCE); _flags = flags; _names = repos.getPersistentTypeNames(devscan, tmpLoader); if (_names == null && _log.isInfoEnabled()) _log.info(_loc.get("runtime-enhance-pcclasses")); }
/** * Constructor. * * @param repos metadata repository to use internally * @param flags enhancer configuration * @param loader temporary class loader for loading intermediate classes * @param devscan whether to scan the dev classpath for persistent types * if none are configured */ public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) { _repos = repos; _tmpLoader = tmpLoader; _log = repos.getConfiguration(). getLog(OpenJPAConfiguration.LOG_ENHANCE); _flags = flags; _names = repos.getPersistentTypeNames(devscan, tmpLoader); if (_names == null && _log.isInfoEnabled()) _log.info(_loc.get("runtime-enhance-pcclasses")); }
/** * Constructor. * * @param repos metadata repository to use internally * @param flags enhancer configuration * @param tmpLoader temporary class loader for loading intermediate classes * @param devscan whether to scan the dev classpath for persistent types * if none are configured */ public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) { _repos = repos; _tmpLoader = tmpLoader; _log = repos.getConfiguration(). getLog(OpenJPAConfiguration.LOG_ENHANCE); _flags = flags; _names = repos.getPersistentTypeNames(devscan, tmpLoader); if (_names == null && _log.isInfoEnabled()) _log.info(_loc.get("runtime-enhance-pcclasses")); }
/** * Constructor. * * @param repos metadata repository to use internally * @param flags enhancer configuration * @param loader temporary class loader for loading intermediate classes * @param devscan whether to scan the dev classpath for persistent types * if none are configured */ public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) { _repos = repos; _tmpLoader = tmpLoader; _log = repos.getConfiguration(). getLog(OpenJPAConfiguration.LOG_ENHANCE); _flags = flags; _names = repos.getPersistentTypeNames(devscan, tmpLoader); if (_names == null && _log.isInfoEnabled()) _log.info(_loc.get("runtime-enhance-pcclasses")); }
/** * Constructor. * * @param repos metadata repository to use internally * @param flags enhancer configuration * @param tmpLoader temporary class loader for loading intermediate classes * @param devscan whether to scan the dev classpath for persistent types * if none are configured */ public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) { _repos = repos; _tmpLoader = tmpLoader; _log = repos.getConfiguration(). getLog(OpenJPAConfiguration.LOG_ENHANCE); _flags = flags; _names = repos.getPersistentTypeNames(devscan, tmpLoader); if (_names == null && _log.isInfoEnabled()) _log.info(_loc.get("runtime-enhance-pcclasses")); }
private ClassMetaData getMetaDataInternal(Class<?> cls, ClassLoader envLoader, boolean mustExist) { ClassMetaData meta = getMetaDataInternal(cls, envLoader); if (meta == null) { if (cls != null && DynamicPersistenceCapable.class.isAssignableFrom(cls)) cls = cls.getSuperclass(); // if cls is a generated interface, use the user interface // to locate metadata if (cls != null && _implGen != null && _implGen.isImplType(cls)) cls = _implGen.toManagedInterface(cls); meta = getMetaDataInternal(cls, envLoader); } if (meta == null && mustExist) { if (cls != null && !ImplHelper.isManagedType(_conf, cls)) throw new MetaDataException(_loc.get("no-meta-notpc", cls)).setFatal(false); Set<String> pcNames = getPersistentTypeNames(false, envLoader); if (pcNames != null && pcNames.size() > 0) throw new MetaDataException(_loc.get("no-meta-types", cls, pcNames)); throw new MetaDataException(_loc.get("no-meta", cls)); } resolve(meta); return meta; }
private QueryMetaData getQueryMetaDataInternal(Class<?> cls, String name, ClassLoader envLoader, boolean mustExist) { QueryMetaData meta = getQueryMetaDataInternal(cls, name, envLoader); if (meta == null) { // load all the metadatas for all the known classes so that // query names are seen and registered resolveAll(envLoader); meta = getQueryMetaDataInternal(cls, name, envLoader); } if (meta == null && mustExist) { if (cls == null) { throw new MetaDataException(_loc.get("no-named-query-null-class", getPersistentTypeNames(false, envLoader), name)); } else { throw new MetaDataException(_loc.get("no-named-query", cls, name)); } } return meta; }
private QueryMetaData getQueryMetaDataInternal(Class<?> cls, String name, ClassLoader envLoader, boolean mustExist) { QueryMetaData meta = getQueryMetaDataInternal(cls, name, envLoader); if (meta == null) { // load all the metadatas for all the known classes so that // query names are seen and registered resolveAll(envLoader); meta = getQueryMetaDataInternal(cls, name, envLoader); } if (meta == null && mustExist) { if (cls == null) { throw new MetaDataException(_loc.get("no-named-query-null-class", getPersistentTypeNames(false, envLoader), name)); } else { throw new MetaDataException(_loc.get("no-named-query", cls, name)); } } return meta; }
private QueryMetaData getQueryMetaDataInternal(Class<?> cls, String name, ClassLoader envLoader, boolean mustExist) { QueryMetaData meta = getQueryMetaDataInternal(cls, name, envLoader); if (meta == null) { // load all the metadatas for all the known classes so that // query names are seen and registered resolveAll(envLoader); meta = getQueryMetaDataInternal(cls, name, envLoader); } if (meta == null && mustExist) { if (cls == null) { throw new MetaDataException(_loc.get("no-named-query-null-class", getPersistentTypeNames(false, envLoader), name)); } else { throw new MetaDataException(_loc.get("no-named-query", cls, name)); } } return meta; }
private QueryMetaData getQueryMetaDataInternal(Class<?> cls, String name, ClassLoader envLoader, boolean mustExist) { QueryMetaData meta = getQueryMetaDataInternal(cls, name, envLoader); if (meta == null) { // load all the metadatas for all the known classes so that // query names are seen and registered resolveAll(envLoader); meta = getQueryMetaDataInternal(cls, name, envLoader); } if (meta == null && mustExist) { if (cls == null) { throw new MetaDataException(_loc.get("no-named-query-null-class", getPersistentTypeNames(false, envLoader), name)); } else { throw new MetaDataException(_loc.get("no-named-query", cls, name)); } } return meta; }
/** * Makes sure all subclasses of the given type are loaded in the JVM. * This is usually done automatically. */ public void loadSubclasses(ClassMapping mapping) { Discriminator dsc = mapping.getDiscriminator(); if (dsc.getSubclassesLoaded()) return; // if the subclass list is set, no need to load subs if (mapping.getRepository().getPersistentTypeNames(false, _ctx.getClassLoader()) != null) { dsc.setSubclassesLoaded(true); return; } try { dsc.loadSubclasses(this); } catch (ClassNotFoundException cnfe) { throw new StoreException(cnfe); } catch (SQLException se) { throw SQLExceptions.getStore(se, _dict); } }
/** * Makes sure all subclasses of the given type are loaded in the JVM. * This is usually done automatically. */ public void loadSubclasses(ClassMapping mapping) { Discriminator dsc = mapping.getDiscriminator(); if (dsc.getSubclassesLoaded()) return; // if the subclass list is set, no need to load subs if (mapping.getRepository().getPersistentTypeNames(false, _ctx.getClassLoader()) != null) { dsc.setSubclassesLoaded(true); return; } try { dsc.loadSubclasses(this); } catch (ClassNotFoundException cnfe) { throw new StoreException(cnfe); } catch (SQLException se) { throw SQLExceptions.getStore(se, _dict); } }
/** * Makes sure all subclasses of the given type are loaded in the JVM. * This is usually done automatically. */ public void loadSubclasses(ClassMapping mapping) { Discriminator dsc = mapping.getDiscriminator(); if (dsc.getSubclassesLoaded()) return; // if the subclass list is set, no need to load subs if (mapping.getRepository().getPersistentTypeNames(false, _ctx.getClassLoader()) != null) { dsc.setSubclassesLoaded(true); return; } try { dsc.loadSubclasses(this); } catch (ClassNotFoundException cnfe) { throw new StoreException(cnfe); } catch (SQLException se) { throw SQLExceptions.getStore(se, _dict); } }
/** * Makes sure all subclasses of the given type are loaded in the JVM. * This is usually done automatically. */ public void loadSubclasses(ClassMapping mapping) { Discriminator dsc = mapping.getDiscriminator(); if (dsc.getSubclassesLoaded()) return; // if the subclass list is set, no need to load subs if (mapping.getRepository().getPersistentTypeNames(false, _ctx.getClassLoader()) != null) { dsc.setSubclassesLoaded(true); return; } try { dsc.loadSubclasses(this); } catch (ClassNotFoundException cnfe) { throw new StoreException(cnfe); } catch (SQLException se) { throw SQLExceptions.getStore(se, _dict); } }