/** * Resolve all known metadata classes. */ private void resolveAll(ClassLoader envLoader) { Collection<Class<?>> types = loadPersistentTypes(false, envLoader); for (Class<?> c : types) { getMetaData(c, envLoader, false); } }
/** * Read the optimizedIdCopy value from the config (if available) */ private void configureOptimizeIdCopy() { if (_repos != null && _repos.getConfiguration() != null) { _optimizeIdCopy = _repos.getConfiguration().getOptimizeIdCopy(); } }
public void stopCaching(String cls) { MetaDataRepository mdr = _conf.getMetaDataRepositoryInstance(); ClassMetaData cmd = mdr.getCachedMetaData(cls); _cacheable.put(cmd, Boolean.FALSE); }
private void closeInternal() { SequenceMetaData[] smds = getSequenceMetaDatas(); for (int i = 0; i < smds.length; i++) smds[i].close(); clear(); }
/** * Add all components in the given repository to the set to be serialized. */ public void addAll(MetaDataRepository repos) { if (repos == null) return; for (ClassMetaData meta : repos.getMetaDatas()) addMetaData(meta); for (SequenceMetaData seq : repos.getSequenceMetaDatas()) addSequenceMetaData(seq); for (QueryMetaData query : repos.getQueryMetaDatas()) addQueryMetaData(query); }
/** * Convenience method to get metadata for the given type. */ protected ClassMetaData getMetaData(Class<?> c, boolean required, ClassLoader loader) { return resolver.getConfiguration().getMetaDataRepositoryInstance(). getMetaData(c, loader, required); }
/** * 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")); }
/** * The metadata repository for the factory that this instance was * constructed with will be serialized, along with any query * compilations etc. that have been created for the factory. */ public void store() { MetaDataRepository repos = conf.getMetaDataRepositoryInstance(); repos.setSourceMode(MetaDataRepository.MODE_ALL); Collection types = repos.loadPersistentTypes(devpath, null); for (Iterator iter = types.iterator(); iter.hasNext(); ) repos.getMetaData((Class) iter.next(), null, true); loadQueries(); log.info("The following data will be stored: "); log(repos, conf.getQueryCompilationCacheInstance()); CacheMarshallersValue.getMarshallerById(conf, getClass().getName()) .store(new Object[] { repos, conf.getQueryCompilationCacheInstance() }); }
public void setSchema(String schema) { // If the schema name is empty, check to see if a system // level default exists and if so use it. if (schema == null || "".equals(schema)){ String tmp = getRepository().getMetaDataFactory().getDefaults().getDefaultSchema(); schema = (tmp != null ? tmp : ""); } this._schema = schema; }
/** * Initialize mapping. Logs init message by default. */ protected void initializeMapping() { Log log = _repos.getLog(); if (log.isTraceEnabled()) log.trace(_loc.get("init-mapping", this + "@" + System.identityHashCode(this))); }
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; }
/** * The repository to use to hold metadata. */ public MetaDataRepository getRepository() { if (_repos == null) { _repos = newRepository(); _repos.setResolve(MODE_MAPPING, false); MetaDataFactory factory = _repos.getMetaDataFactory(); factory.getDefaults().setIgnoreNonPersistent(false); factory.setStoreMode(MetaDataFactory.STORE_VERBOSE); } return _repos; }
public ClassMetaData addEmbeddedMetaData() { MetaDataRepository repos = _owner.getRepository(); _embeddedMeta = repos.newEmbeddedClassMetaData(this); _embeddedMeta.setDescribedType(_decType); repos.getMetaDataFactory().getDefaults().populate(_embeddedMeta, ClassMetaData.ACCESS_UNKNOWN); setEmbedded(true); return _embeddedMeta; }
/** * Create a new metadata, populate it with default information, add it to the repository, and * return it. * * @param access * the access type to use in populating metadata */ public ClassMetaData addMetaData(Class<?> cls, int access) { return addMetaData(cls, access, false); }
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)); } }
/** * Load the persistent classes named in configuration. * This ensures that all subclasses and application identity classes of * each type are known in advance, without having to rely on the * application loading the classes before performing operations that * might involve them. * * @param devpath if true, search for metadata files in directories * in the classpath if the no classes are configured explicitly * @param envLoader the class loader to use, or null for default * @return the loaded classes, or empty collection if none */ public Collection<Class<?>> loadPersistentTypes(boolean devpath, ClassLoader envLoader) { return loadPersistentTypes(devpath, envLoader, false); } /**
public synchronized void clear() { super.clear(); _schema = null; _results.clear(); }
/** * Add all components in the given repository to the set to be serialized. */ public void addAll(MetaDataRepository repos) { if (repos == null) return; for (ClassMetaData meta : repos.getMetaDatas()) addMetaData(meta); for (SequenceMetaData seq : repos.getSequenceMetaDatas()) addSequenceMetaData(seq); for (QueryMetaData query : repos.getQueryMetaDatas()) addQueryMetaData(query); }
private static void setIntercepting(OpenJPAConfiguration conf, ClassLoader envLoader, Class<?> cls) { ClassMetaData meta = conf.getMetaDataRepositoryInstance() .getMetaData(cls, envLoader, true); meta.setIntercepting(true); }
/** * 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")); }