use of net.sf.cglib.asm.$ClassReader in project intellij-community by JetBrains.
the class AbstractClassGenerator method create.
protected Object create(Object key) {
try {
Class gen = null;
synchronized (source) {
ClassLoader loader = getClassLoader();
Map cache2 = null;
cache2 = (Map) source.cache.get(loader);
if (cache2 == null) {
cache2 = new HashMap();
cache2.put(NAME_KEY, new HashSet());
source.cache.put(loader, cache2);
} else if (useCache) {
Reference ref = (Reference) cache2.get(key);
gen = (Class) SoftReference.dereference(ref);
}
if (gen == null) {
Object save = CURRENT.get();
CURRENT.set(this);
try {
this.key = key;
if (attemptLoad) {
try {
gen = loader.loadClass(getClassName());
} catch (ClassNotFoundException e) {
// ignore
}
}
if (gen == null) {
byte[] b = strategy.generate(this);
String className = ClassNameReader.getClassName(new $ClassReader(b));
getClassNameCache(loader).add(className);
gen = ReflectUtils.defineClass(className, b, loader);
}
if (useCache) {
cache2.put(key, new WeakReference(gen));
}
return firstInstance(gen);
} finally {
CURRENT.set(save);
}
}
}
return firstInstance(gen);
} catch (RuntimeException e) {
throw e;
} catch (Error e) {
throw e;
} catch (Exception e) {
throw new CodeGenerationException(e);
}
}
use of net.sf.cglib.asm.$ClassReader in project geronimo-xbean by apache.
the class XbeanAsmParameterNameLoader method getAllMethodParameters.
/**
* Gets the parameter names of all methods with the specified name or null if the class was compiled without debug symbols on.
* @param clazz the class for which the method parameter names should be retrieved
* @param methodName the of the method for which the parameters should be retrieved
* @return a map from Method object to the parameter names or null if the class was compiled without debug symbols on
*/
public Map<Method, List<String>> getAllMethodParameters(Class clazz, String methodName) {
// Determine the constructors?
Method[] methods = getMethods(clazz, methodName);
if (methods.length == 0) {
return Collections.emptyMap();
}
// Check the cache
if (methodCache.containsKey(methods[0])) {
Map<Method, List<String>> methodParameters = new HashMap<Method, List<String>>();
for (Method method : methods) {
methodParameters.put(method, methodCache.get(method));
}
return methodParameters;
}
// Load the parameter names using ASM
Map<Method, List<String>> methodParameters = new HashMap<Method, List<String>>();
try {
ClassReader reader = XbeanAsmParameterNameLoader.createClassReader(clazz);
XbeanAsmParameterNameLoader.AllParameterNamesDiscoveringVisitor visitor = new XbeanAsmParameterNameLoader.AllParameterNamesDiscoveringVisitor(clazz, methodName);
reader.accept(visitor, 0);
Map exceptions = visitor.getExceptions();
if (exceptions.size() == 1) {
throw new RuntimeException((Exception) exceptions.values().iterator().next());
}
if (!exceptions.isEmpty()) {
throw new RuntimeException(exceptions.toString());
}
methodParameters = visitor.getMethodParameters();
} catch (IOException ex) {
}
// Cache the names
for (Method method : methods) {
methodCache.put(method, methodParameters.get(method));
}
return methodParameters;
}
use of net.sf.cglib.asm.$ClassReader in project geronimo-xbean by apache.
the class XbeanAsmParameterNameLoader method getAllConstructorParameters.
/**
* Gets the parameter names of all constructor or null if the class was compiled without debug symbols on.
* @param clazz the class for which the constructor parameter names should be retrieved
* @return a map from Constructor object to the parameter names or null if the class was compiled without debug symbols on
*/
public Map<Constructor, List<String>> getAllConstructorParameters(Class clazz) {
// Determine the constructors?
List<Constructor> constructors = new ArrayList<Constructor>(Arrays.asList(clazz.getConstructors()));
constructors.addAll(Arrays.asList(clazz.getDeclaredConstructors()));
if (constructors.isEmpty()) {
return Collections.emptyMap();
}
// Check the cache
if (constructorCache.containsKey(constructors.get(0))) {
Map<Constructor, List<String>> constructorParameters = new HashMap<Constructor, List<String>>();
for (Constructor constructor : constructors) {
constructorParameters.put(constructor, constructorCache.get(constructor));
}
return constructorParameters;
}
// Load the parameter names using ASM
Map<Constructor, List<String>> constructorParameters = new HashMap<Constructor, List<String>>();
try {
ClassReader reader = XbeanAsmParameterNameLoader.createClassReader(clazz);
XbeanAsmParameterNameLoader.AllParameterNamesDiscoveringVisitor visitor = new XbeanAsmParameterNameLoader.AllParameterNamesDiscoveringVisitor(clazz);
reader.accept(visitor, 0);
Map exceptions = visitor.getExceptions();
if (exceptions.size() == 1) {
throw new RuntimeException((Exception) exceptions.values().iterator().next());
}
if (!exceptions.isEmpty()) {
throw new RuntimeException(exceptions.toString());
}
constructorParameters = visitor.getConstructorParameters();
} catch (IOException ex) {
}
// Cache the names
for (Constructor constructor : constructors) {
constructorCache.put(constructor, constructorParameters.get(constructor));
}
return constructorParameters;
}
use of net.sf.cglib.asm.$ClassReader in project tomee by apache.
the class TempClassLoader method isEnum.
/**
* Fast-parse the given class bytecode to determine if it is an
* enum class.
*/
private static boolean isEnum(final byte[] bytes) {
final IsEnumVisitor isEnumVisitor = new IsEnumVisitor();
final ClassReader classReader = new ClassReader(bytes);
classReader.accept(isEnumVisitor, ClassReader.SKIP_DEBUG);
return isEnumVisitor.isEnum;
}
use of net.sf.cglib.asm.$ClassReader in project tomee by apache.
the class DynamicSubclass method copyClassAnnotations.
private static void copyClassAnnotations(final Class<?> clazz, final ClassVisitor newClass) throws ProxyGenerationException {
try {
final ClassReader classReader = new ClassReader(readClassFile(clazz));
final ClassVisitor visitor = new CopyClassAnnotations(newClass);
classReader.accept(visitor, ClassReader.SKIP_CODE);
} catch (final IOException e) {
throw new ProxyGenerationException(e);
}
}
Aggregations