[jboss-cvs] javassist/src/main/javassist/scopedpool ...
Kabir Khan
kkhan at jboss.com
Thu Jul 13 05:43:16 EDT 2006
User: kkhan
Date: 06/07/13 05:43:16
Added: src/main/javassist/scopedpool ScopedClassPool.java
ScopedClassPoolRepository.java
ScopedClassPoolFactory.java
ScopedClassPoolRepositoryImpl.java
SoftValueHashMap.java
ScopedClassPoolFactoryImpl.java
Log:
Move scoped classpool repository from jboss retro into javassist to have a common place for users like aop and jboss retro
Revision Changes Path
1.1 date: 2006/07/13 09:43:16; author: kkhan; state: Exp;javassist/src/main/javassist/scopedpool/ScopedClassPool.java
Index: ScopedClassPool.java
===================================================================
/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package javassist.scopedpool;
import java.lang.ref.WeakReference;
import java.util.Iterator;
import java.util.Map;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.LoaderClassPath;
import javassist.NotFoundException;
/**
* A scoped class pool
*
* @author <a href="mailto:bill at jboss.org">Bill Burke</a>
* @author <a href="adrian at jboss.com">Adrian Brock</a>
* @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
* @version $Revision: 1.1 $
*/
public class ScopedClassPool extends ClassPool
{
protected ScopedClassPoolRepository repository;
protected WeakReference classLoader;
protected LoaderClassPath classPath;
protected SoftValueHashMap softcache = new SoftValueHashMap();
static
{
ClassPool.doPruning = false;
ClassPool.releaseUnmodifiedClassFile = false;
}
/**
* Create a new ScopedClassPool.
*
* @param cl the classloader
* @param src the original class pool
* @param repository the repository
*/
protected ScopedClassPool(ClassLoader cl, ClassPool src, ScopedClassPoolRepository repository)
{
super(src);
this.repository = repository;
this.classLoader = new WeakReference(cl);
if (cl != null)
{
classPath = new LoaderClassPath(cl);
this.insertClassPath(classPath);
}
childFirstLookup = true;
}
/**
* Get the class loader
*
* @return the class loader
*/
public ClassLoader getClassLoader()
{
return getClassLoader0();
}
private ClassLoader getClassLoader0()
{
ClassLoader cl = (ClassLoader) classLoader.get();
if (cl == null)
throw new IllegalStateException("ClassLoader has been garbage collected");
return cl;
}
/**
* Close the class pool
*/
public void close()
{
this.removeClassPath(classPath);
classPath.close();
classes.clear();
softcache.clear();
}
/**
* Flush a class
*
* @param classname the class to flush
*/
public synchronized void flushClass(String classname)
{
classes.remove(classname);
softcache.remove(classname);
}
/**
* Soften a class
*
* @param clazz the class
*/
public synchronized void soften(CtClass clazz)
{
if (repository.isPrune()) clazz.prune();
classes.remove(clazz.getName());
softcache.put(clazz.getName(), clazz);
}
/**
* Whether the classloader is loader
*
* @return false always
*/
public boolean isUnloadedClassLoader()
{
return false;
}
/**
* Get the cached class
*
* @param classname the class name
* @return the class
*/
protected CtClass getCached(String classname)
{
CtClass clazz = getCachedLocally(classname);
if (clazz == null)
{
boolean isLocal = false;
ClassLoader dcl = getClassLoader0();
if (dcl != null)
{
final int lastIndex = classname.lastIndexOf('$');
String classResourceName = null;
if (lastIndex < 0)
{
classResourceName = classname.replaceAll("[\\.]", "/") + ".class";
}
else
{
classResourceName = classname.substring(0, lastIndex).replaceAll("[\\.]", "/") + classname.substring(lastIndex) + ".class";
}
isLocal = dcl.getResource(classResourceName) != null;
}
if (!isLocal)
{
Map registeredCLs = repository.getRegisteredCLs();
synchronized (registeredCLs)
{
Iterator it = registeredCLs.values().iterator();
while (it.hasNext())
{
ScopedClassPool pool = (ScopedClassPool) it.next();
if (pool.isUnloadedClassLoader())
{
repository.unregisterClassLoader(pool.getClassLoader());
continue;
}
clazz = pool.getCachedLocally(classname);
if (clazz != null)
{
return clazz;
}
}
}
}
}
// *NOTE* NEED TO TEST WHEN SUPERCLASS IS IN ANOTHER UCL!!!!!!
return clazz;
}
/**
* Cache a class
*
* @param classname the class name
* @param c the ctClass
* @param dynamic whether the class is dynamically generated
*/
protected void cacheCtClass(String classname, CtClass c, boolean dynamic)
{
if (dynamic)
{
super.cacheCtClass(classname, c, dynamic);
}
else
{
if (repository.isPrune()) c.prune();
softcache.put(classname, c);
}
}
/**
* Lock a class into the cache
*
* @param c the class
*/
public void lockInCache(CtClass c)
{
super.cacheCtClass(c.getName(), c, false);
}
/**
* Whether the class is cached in this pooled
*
* @param classname the class name
* @return the cached class
*/
protected CtClass getCachedLocally(String classname)
{
CtClass cached = (CtClass) classes.get(classname);
if (cached != null) return cached;
synchronized (softcache)
{
return (CtClass) softcache.get(classname);
}
}
/**
* Get any local copy of the class
*
* @param classname the class name
* @return the class
* @throws NotFoundException when the class is not found
*/
public synchronized CtClass getLocally(String classname) throws NotFoundException
{
softcache.remove(classname);
CtClass clazz = (CtClass) classes.get(classname);
if (clazz == null)
{
clazz = createCtClass(classname, true);
if (clazz == null) throw new NotFoundException(classname);
super.cacheCtClass(classname, clazz, false);
}
return clazz;
}
/**
* Convert a javassist class to a java class
*
* @param ct the javassist class
* @param loader the loader
* @throws CannotCompileException for any error
*/
public Class toClass(CtClass ct, ClassLoader loader) throws CannotCompileException
{
//We need to pass up the classloader stored in this pool, as the default implementation uses the Thread context cl.
//In the case of JSP's in Tomcat, org.apache.jasper.servlet.JasperLoader will be stored here, while it's parent
//org.jboss.web.tomcat.tc5.WebCtxLoader$ENCLoader is used as the Thread context cl. The invocation class needs to
// be generated in the JasperLoader classloader since in the case of method invocations, the package name will be
//the same as for the class generated from the jsp, i.e. org.apache.jsp. For classes belonging to org.apache.jsp,
//JasperLoader does NOT delegate to its parent if it cannot find them.
lockInCache(ct);
return super.toClass(ct, getClassLoader0());
}
}
1.1 date: 2006/07/13 09:43:16; author: kkhan; state: Exp;javassist/src/main/javassist/scopedpool/ScopedClassPoolRepository.java
Index: ScopedClassPoolRepository.java
===================================================================
/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package javassist.scopedpool;
import java.util.Map;
import javassist.ClassPool;
/**
*
* @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
* @version $Revision: 1.1 $
*/
public interface ScopedClassPoolRepository
{
void setClassPoolFactory(ScopedClassPoolFactory factory);
ScopedClassPoolFactory getClassPoolFactory();
/**
* Get the prune.
*
* @return the prune.
*/
boolean isPrune();
/**
* Set the prune.
*
* @param prune the prune.
*/
void setPrune(boolean prune);
/**
* Create a scoped classpool
*
* @param cl the classloader
* @param src the original classpool
* @return the classpool
*/
ScopedClassPool createScopedClassPool(ClassLoader cl, ClassPool src);
/**
* Finds a scoped classpool registered under the passed in classloader
* @param the classloader
* @return the classpool
*/
ClassPool findClassPool(ClassLoader cl);
/**
* Register a classloader
*
* @param ucl the classloader
* @return the classpool
*/
ClassPool registerClassLoader(ClassLoader ucl);
/**
* Get the registered classloaders
*
* @return the registered classloaders
*/
Map getRegisteredCLs();
/**
* This method will check to see if a register classloader has been undeployed (as in JBoss)
*/
void clearUnregisteredClassLoaders();
/**
* Unregisters a classpool and unregisters its classloader.
* @ClassLoader the classloader the pool is stored under
*/
void unregisterClassLoader(ClassLoader cl);
}
1.1 date: 2006/07/13 09:43:16; author: kkhan; state: Exp;javassist/src/main/javassist/scopedpool/ScopedClassPoolFactory.java
Index: ScopedClassPoolFactory.java
===================================================================
/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package javassist.scopedpool;
import javassist.ClassPool;
/**
*
* @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
* @version $Revision: 1.1 $
*/
public interface ScopedClassPoolFactory
{
ScopedClassPool create(ClassLoader cl, ClassPool src, ScopedClassPoolRepository repository);
ScopedClassPool create(ClassPool src, ScopedClassPoolRepository repository);
}
1.1 date: 2006/07/13 09:43:16; author: kkhan; state: Exp;javassist/src/main/javassist/scopedpool/ScopedClassPoolRepositoryImpl.java
Index: ScopedClassPoolRepositoryImpl.java
===================================================================
/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package javassist.scopedpool;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.WeakHashMap;
import javassist.ClassPool;
import javassist.LoaderClassPath;
/**
*
* @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
* @version $Revision: 1.1 $
*/
public class ScopedClassPoolRepositoryImpl implements ScopedClassPoolRepository
{
/** The instance */
private static final ScopedClassPoolRepositoryImpl instance = new ScopedClassPoolRepositoryImpl();
/** Whether to prune */
private boolean prune = true;
/** Whether to prune when added to the classpool's cache */
boolean pruneWhenCached;
/** The registered classloaders */
protected Map registeredCLs = Collections.synchronizedMap(new WeakHashMap());
/** The default class pool */
protected ClassPool classpool;
/** The factory for creating class pools */
protected ScopedClassPoolFactory factory = new ScopedClassPoolFactoryImpl();
/**
* Get the instance
*
* @return the instance
*/
public static ScopedClassPoolRepository getInstance()
{
return instance;
}
/**
* Singleton
*/
private ScopedClassPoolRepositoryImpl()
{
classpool = ClassPool.getDefault();
// FIXME This doesn't look correct
ClassLoader cl = Thread.currentThread().getContextClassLoader();
classpool.insertClassPath(new LoaderClassPath(cl));
}
/**
* Get the prune.
*
* @return the prune.
*/
public boolean isPrune()
{
return prune;
}
/**
* Set the prune.
*
* @param prune the prune.
*/
public void setPrune(boolean prune)
{
this.prune = prune;
}
/**
* Create a scoped classpool
*
* @param cl the classloader
* @param src the original classpool
* @return the classpool
*/
public ScopedClassPool createScopedClassPool(ClassLoader cl, ClassPool src)
{
return factory.create(cl, src, this);
}
public ClassPool findClassPool(ClassLoader cl)
{
if (cl == null)
return registerClassLoader(ClassLoader.getSystemClassLoader());
return registerClassLoader(cl);
}
/**
* Register a classloader
*
* @param ucl the classloader
* @return the classpool
*/
public ClassPool registerClassLoader(ClassLoader ucl)
{
synchronized (registeredCLs)
{
// FIXME: Probably want to take this method out later
// so that AOP framework can be independent of JMX
// This is in here so that we can remove a UCL from the ClassPool as a
// ClassPool.classpath
if (registeredCLs.containsKey(ucl))
{
return (ClassPool) registeredCLs.get(ucl);
}
ScopedClassPool pool = createScopedClassPool(ucl, classpool);
registeredCLs.put(ucl, pool);
return pool;
}
}
/**
* Get the registered classloaders
*
* @return the registered classloaders
*/
public Map getRegisteredCLs()
{
clearUnregisteredClassLoaders();
return registeredCLs;
}
/**
* This method will check to see if a register classloader has been undeployed (as in JBoss)
*/
public void clearUnregisteredClassLoaders()
{
ArrayList toUnregister = null;
synchronized (registeredCLs)
{
Iterator it = registeredCLs.values().iterator();
while (it.hasNext())
{
ScopedClassPool pool = (ScopedClassPool) it.next();
if (pool.isUnloadedClassLoader())
{
it.remove();
ClassLoader cl = pool.getClassLoader();
if (cl != null)
{
if (toUnregister == null)
{
toUnregister = new ArrayList();
}
toUnregister.add(cl);
}
}
}
if (toUnregister != null)
{
for (int i = 0; i < toUnregister.size(); i++)
{
unregisterClassLoader((ClassLoader) toUnregister.get(i));
}
}
}
}
public void unregisterClassLoader(ClassLoader cl)
{
synchronized (registeredCLs)
{
ScopedClassPool pool = (ScopedClassPool) registeredCLs.remove(cl);
if (pool != null) pool.close();
}
}
public void insertDelegate(ScopedClassPoolRepository delegate)
{
//Noop - this is the end
}
public void setClassPoolFactory(ScopedClassPoolFactory factory)
{
this.factory = factory;
}
public ScopedClassPoolFactory getClassPoolFactory()
{
return factory;
}
}
1.1 date: 2006/07/13 09:43:16; author: kkhan; state: Exp;javassist/src/main/javassist/scopedpool/SoftValueHashMap.java
Index: SoftValueHashMap.java
===================================================================
/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package javassist.scopedpool;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.AbstractMap;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* This Map will remove entries when the value in the map has been
* cleaned from garbage collection
*
* @version <tt>$Revision: 1.1 $</tt>
* @author <a href="mailto:bill at jboss.org">Bill Burke</a>
*/
public class SoftValueHashMap
extends AbstractMap
implements Map
{
private static class SoftValueRef extends SoftReference
{
public Object key;
private SoftValueRef(Object key, Object val, ReferenceQueue q)
{
super(val, q);
this.key = key;
}
private static SoftValueRef create(Object key, Object val, ReferenceQueue q)
{
if (val == null) return null;
else return new SoftValueRef(key, val, q);
}
}
public Set entrySet()
{
processQueue();
return hash.entrySet();
}
/* Hash table mapping WeakKeys to values */
private Map hash;
/* Reference queue for cleared WeakKeys */
private ReferenceQueue queue = new ReferenceQueue();
/* Remove all invalidated entries from the map, that is, remove all entries
whose values have been discarded.
*/
private void processQueue()
{
SoftValueRef ref;
while ((ref = (SoftValueRef)queue.poll()) != null) {
if (ref == (SoftValueRef) hash.get(ref.key)) {
// only remove if it is the *exact* same WeakValueRef
//
hash.remove(ref.key);
}
}
}
/* -- Constructors -- */
/**
* Constructs a new, empty <code>WeakHashMap</code> with the given
* initial capacity and the given load factor.
*
* @param initialCapacity The initial capacity of the
* <code>WeakHashMap</code>
*
* @param loadFactor The load factor of the <code>WeakHashMap</code>
*
* @throws IllegalArgumentException If the initial capacity is less than
* zero, or if the load factor is
* nonpositive
*/
public SoftValueHashMap(int initialCapacity, float loadFactor)
{
hash = new HashMap(initialCapacity, loadFactor);
}
/**
* Constructs a new, empty <code>WeakHashMap</code> with the given
* initial capacity and the default load factor, which is
* <code>0.75</code>.
*
* @param initialCapacity The initial capacity of the
* <code>WeakHashMap</code>
*
* @throws IllegalArgumentException If the initial capacity is less than
* zero
*/
public SoftValueHashMap(int initialCapacity)
{
hash = new HashMap(initialCapacity);
}
/**
* Constructs a new, empty <code>WeakHashMap</code> with the default
* initial capacity and the default load factor, which is
* <code>0.75</code>.
*/
public SoftValueHashMap()
{
hash = new HashMap();
}
/**
* Constructs a new <code>WeakHashMap</code> with the same mappings as the
* specified <tt>Map</tt>. The <code>WeakHashMap</code> is created with an
* initial capacity of twice the number of mappings in the specified map
* or 11 (whichever is greater), and a default load factor, which is
* <tt>0.75</tt>.
*
* @param t the map whose mappings are to be placed in this map.
* @since 1.3
*/
public SoftValueHashMap(Map t)
{
this(Math.max(2*t.size(), 11), 0.75f);
putAll(t);
}
/* -- Simple queries -- */
/**
* Returns the number of key-value mappings in this map.
* <strong>Note:</strong> <em>In contrast with most implementations of the
* <code>Map</code> interface, the time required by this operation is
* linear in the size of the map.</em>
*/
public int size()
{
processQueue();
return hash.size();
}
/**
* Returns <code>true</code> if this map contains no key-value mappings.
*/
public boolean isEmpty()
{
processQueue();
return hash.isEmpty();
}
/**
* Returns <code>true</code> if this map contains a mapping for the
* specified key.
*
* @param key The key whose presence in this map is to be tested
*/
public boolean containsKey(Object key)
{
processQueue();
return hash.containsKey(key);
}
/* -- Lookup and modification operations -- */
/**
* Returns the value to which this map maps the specified <code>key</code>.
* If this map does not contain a value for this key, then return
* <code>null</code>.
*
* @param key The key whose associated value, if any, is to be returned
*/
public Object get(Object key)
{
processQueue();
SoftReference ref = (SoftReference)hash.get(key);
if (ref != null) return ref.get();
return null;
}
/**
* Updates this map so that the given <code>key</code> maps to the given
* <code>value</code>. If the map previously contained a mapping for
* <code>key</code> then that mapping is replaced and the previous value is
* returned.
*
* @param key The key that is to be mapped to the given
* <code>value</code>
* @param value The value to which the given <code>key</code> is to be
* mapped
*
* @return The previous value to which this key was mapped, or
* <code>null</code> if if there was no mapping for the key
*/
public Object put(Object key, Object value)
{
processQueue();
Object rtn = hash.put(key, SoftValueRef.create(key, value, queue));
if (rtn != null) rtn = ((SoftReference)rtn).get();
return rtn;
}
/**
* Removes the mapping for the given <code>key</code> from this map, if
* present.
*
* @param key The key whose mapping is to be removed
*
* @return The value to which this key was mapped, or <code>null</code> if
* there was no mapping for the key
*/
public Object remove(Object key)
{
processQueue();
return hash.remove(key);
}
/**
* Removes all mappings from this map.
*/
public void clear()
{
processQueue();
hash.clear();
}
}
1.1 date: 2006/07/13 09:43:16; author: kkhan; state: Exp;javassist/src/main/javassist/scopedpool/ScopedClassPoolFactoryImpl.java
Index: ScopedClassPoolFactoryImpl.java
===================================================================
/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package javassist.scopedpool;
import javassist.ClassPool;
/**
*
* @author <a href="kabir.khan at jboss.com">Kabir Khan</a>
* @version $Revision: 1.1 $
*/
public class ScopedClassPoolFactoryImpl implements ScopedClassPoolFactory
{
public ScopedClassPool create(ClassLoader cl, ClassPool src, ScopedClassPoolRepository repository)
{
return new ScopedClassPool(cl, src, repository);
}
public ScopedClassPool create(ClassPool src, ScopedClassPoolRepository repository)
{
return new ScopedClassPool(null, src, repository);
}
}
More information about the jboss-cvs-commits
mailing list