public ClassPool getPoolForLoader(ClassLoader cl) { return classPoolRepository.registerClassLoader(cl); } }
private CtClass obtainCtClassInfo(ScopedClassPool pool, String className, byte[] classfileBuffer) throws NotFoundException { try { return pool.getLocally(className); } catch (NotFoundException e) { // todo Bill Burke: this scares the shit out of me, but it must be done // I think it will screw up hotdeployment at some time. Then again, maybe not ;) ByteArrayClassPath cp = new ByteArrayClassPath(className, classfileBuffer); pool.insertClassPath(cp); return pool.getLocally(className); } catch(Error e) { return null; } }
public String toString() { ClassLoader cl = null; try { cl = getClassLoader(); } catch(IllegalStateException ignore) { } return this.getClass().getName() + "@" + System.identityHashCode(this) + " " + super.toString() + " - dcl:" + cl; }
private void registerBootstrapLoaders(Module skip, ScopedClassPoolRepository repository) { Collection<Module> unregistered = registerModuleCallback.getUnregisteredModules(); if (unregistered.size() > 0) { for (Module module : unregistered) { if (module == skip) { continue; } ClassLoader loader = getClassLoaderForModule(module); if (loader == null || this.currentClassLoaders.contains(loader)) { continue; } ClassPool classPool = repository.registerClassLoader(loader); if (classPool == null) { repository.unregisterClassLoader(loader); } } } }
try clazz = pool.getLocally(className); pool.insertClassPath(cp); clazz = pool.getLocally(className); pool.flushClass(className); return null; pool.flushClass(className); return null; pool.flushClass(className); return null; if (transformed) pool.lockInCache(clazz); if (AspectManager.debugClasses) pool.soften(clazz);
!generatedClasses.containsKey(classname)) Map<ClassLoader, ScopedClassPool> registeredCLs = repository.getRegisteredCLs(); synchronized (registeredCLs) repository.unregisterClassLoader(pool.getClassLoader()); continue;
private ClassPool createTempPool() { //Rememeber that the stuff in jboss5/lib goes in a child classloader of the default classloader. We need //to make this the parent of the temp classloader ClassLoader loader = this.getClass().getClassLoader();// AspectManager.class.getClassLoader(); TODO validate this ClassPool pool = ClassPoolRepository.getInstance().registerClassLoader(loader); return ClassPoolRepository.getInstance().getClassPoolFactory().create(pool, ClassPoolRepository.getInstance()); }
public void close() { super.close(); unregisterWithParent(); for (Iterator<AbstractClassPool> childIterator = children.keySet().iterator(); childIterator.hasNext();) { AbstractClassPool child = childIterator.next(); childIterator.remove(); if (child.getClassLoader() != null) { child.close(); } } }
if (woven != null) pool.lockInCache(woven); if (AspectManager.debugClasses) pool.soften(clazz);
/** * Defines the ClassPoolFactory that will be used by this repository. * @param factory the ClassPoolFactory that is responsible for creating ClassPools for this repository. * if this factory implements {@link ClassLoaderRegistryHandlerFactory} interface, * it will also be responsible for creating a ClassLoaderRegistryHandler for this * repository */ @Override public void setClassPoolFactory(ScopedClassPoolFactory factory) { if (factory instanceof ClassLoaderRegistryHandlerFactory) { ClassLoaderRegistryHandlerFactory registryHandlerFactory = (ClassLoaderRegistryHandlerFactory) factory; registryHandler = registryHandlerFactory.create(new DefaultClassLoaderRegistryHandler()); } super.setClassPoolFactory(factory); }
@Override public void cacheCtClass(String classname, CtClass c, boolean dynamic) { boolean trace = logger.isTraceEnabled(); if (trace) logger.trace(this + " caching " + classname); // TODO remove this true when ready super.cacheCtClass(classname, c, true); if (dynamic) { if (trace) logger.trace(this + " registering dynamic class " + classname); doneGeneratingClass(classname); String resourcename = getResourceName(classname); localResources.put(resourcename, Boolean.TRUE); } }
pool.flushClass(clazz.getName()); return null;
/** * Creates the entire parent class pool chain of the ClassPool corresponding to * {@code cl}. * * @param cl the ClassLoader whose corresponding ClassPool is being created. * Should not be null * @param src * @param repository * @return the parent ClassPool of the ClassPool corresponding to {@code cl} * @throws NullPointerException if {@code cl} is null */ protected ClassPool getCreateParentClassPools(final ClassLoader cl, ClassPool src, ScopedClassPoolRepository repository) { ClassLoader parent = SecurityActions.getParent(cl); if (parent != null) { return repository.registerClassLoader(parent); } else { return systemClassPool; } }
@SuppressWarnings("unchecked") private Collection<CtClass> getAllReferences(CtClass clazz) { ClassPool pool = ClassPoolRepository.getInstance().getClassPoolFactory(). create(clazz.getClassPool(), ClassPoolRepository.getInstance()); Collection<String> refClassNames = new HashSet<String>(); refClassNames.addAll((Collection<String>) clazz.getRefClasses()); Map<String, CtClass> refClasses = new HashMap<String, CtClass>(); for (String refClassName: refClassNames) { addRefClass(refClassName, null, pool, clazz, refClasses); } return refClasses.values(); }
public void unregisterClassLoader(ClassLoader classLoader, Module module) { ScopedClassPool classPool = registeredModules.remove(module); if (classLoader == null) { if (classPool == null) { //throw new IllegalStateException("Module " + module + " is not registered"); //TODO JBREFLECT-116 if (log.isDebugEnabled()) log.warn("Module " + module + " is not registered"); return; } classPool.close(); } else { unregisterClassLoader(classLoader); } }
/** * Constructor. */ protected ClassPoolRepository() { super(AbstractClassPoolFactory.getSystemClassPool()); registryHandler = new DefaultClassLoaderRegistryHandler(); super.setClassPoolFactory(new AbstractClassPoolFactory()); }
ClassPool parentUnitPool = parentUnitLoader == null? null: repository.registerClassLoader(parentUnitLoader); if (parentUnitPool == null)