private static void processClasses(CompiledClass[] entries, int n) throws Exception Reflection implementor = new Reflection(); ClassPool pool = ClassPool.getDefault(); implementor.start(pool); classobj = entries[i].classobject; if (!implementor.makeReflective(c, pool.get(metaobj), pool.get(classobj))) System.err.println("Warning: " + c.getName() implementor.onLoad(pool, entries[i].classname); pool.get(entries[i].classname).writeFile();
String name = m.getName(); if (isExcluded(name)) // internally-used method inherited return; // from a reflective class. m2 = CtNewMethod.delegator(findOriginal(m, dontSearch), clazz); m2.setModifiers(mod); clazz.addMethod(m2);
+ clazz.getName()); registerReflectiveClass(clazz); return modifyClassfile(clazz, metaobject, metaclass);
clazz.addInterface(mlevel); processMethods(clazz, addMeta); processFields(clazz);
/** * Produces a reflective class. * If the super class is also made reflective, it must be done * before the sub class. * * @param clazz the reflective class. * @param metaobject the class of metaobjects. * It must be a subclass of * <code>Metaobject</code>. * @param metaclass the class of the class metaobject. * It must be a subclass of * <code>ClassMetaobject</code>. * @return <code>false</code> if the class is already reflective. * * @see javassist.tools.reflect.Metaobject * @see javassist.tools.reflect.ClassMetaobject */ public boolean makeReflective(String clazz, String metaobject, String metaclass) throws CannotCompileException, NotFoundException { return reflection.makeReflective(clazz, metaobject, metaclass); } }
/** * Constructs a new class loader. */ public Loader() throws CannotCompileException, NotFoundException { super(); delegateLoadingOf("javassist.tools.reflect.Loader"); reflection = new Reflection(); ClassPool pool = ClassPool.getDefault(); addTranslator(pool, reflection); }
private void processMethods(CtClass clazz, boolean dontSearch) throws CannotCompileException, NotFoundException { CtMethod[] ms = clazz.getMethods(); for (int i = 0; i < ms.length; ++i) { CtMethod m = ms[i]; int mod = m.getModifiers(); if (Modifier.isPublic(mod) && !Modifier.isAbstract(mod)) processMethods0(mod, clazz, m, i, dontSearch); } }
private boolean modifyClassfile(CtClass clazz, CtClass metaobject, CtClass metaclass) throws CannotCompileException, NotFoundException { if (clazz.getAttribute("Reflective") != null) return false; // this is already reflective. clazz.setAttribute("Reflective", new byte[0]); CtClass mlevel = classPool.get("javassist.tools.reflect.Metalevel"); boolean addMeta = !clazz.subtypeOf(mlevel); if (addMeta) clazz.addInterface(mlevel); processMethods(clazz, addMeta); processFields(clazz); CtField f; if (addMeta) { f = new CtField(classPool.get("javassist.tools.reflect.Metaobject"), metaobjectField, clazz); f.setModifiers(Modifier.PROTECTED); clazz.addField(f, CtField.Initializer.byNewWithParams(metaobject)); clazz.addMethod(CtNewMethod.getter(metaobjectGetter, f)); clazz.addMethod(CtNewMethod.setter(metaobjectSetter, f)); } f = new CtField(classPool.get("javassist.tools.reflect.ClassMetaobject"), classobjectField, clazz); f.setModifiers(Modifier.PRIVATE | Modifier.STATIC); clazz.addField(f, CtField.Initializer.byNew(metaclass, new String[] { clazz.getName() })); clazz.addMethod(CtNewMethod.getter(classobjectAccessor, f)); return true; }
/** * Produces a reflective class. * If the super class is also made reflective, it must be done * before the sub class. * * @param clazz the reflective class. * @param metaobject the class of metaobjects. * It must be a subclass of * <code>Metaobject</code>. * @param metaclass the class of the class metaobject. * It must be a subclass of * <code>ClassMetaobject</code>. * @return <code>false</code> if the class is already reflective. * * @see javassist.tools.reflect.Metaobject * @see javassist.tools.reflect.ClassMetaobject */ public boolean makeReflective(String clazz, String metaobject, String metaclass) throws CannotCompileException, NotFoundException { return reflection.makeReflective(clazz, metaobject, metaclass); } }
/** * Constructs a new class loader. */ public Loader() throws CannotCompileException, NotFoundException { super(); delegateLoadingOf("javassist.tools.reflect.Loader"); reflection = new Reflection(); ClassPool pool = ClassPool.getDefault(); addTranslator(pool, reflection); }
private void processMethods(CtClass clazz, boolean dontSearch) throws CannotCompileException, NotFoundException { CtMethod[] ms = clazz.getMethods(); for (int i = 0; i < ms.length; ++i) { CtMethod m = ms[i]; int mod = m.getModifiers(); if (Modifier.isPublic(mod) && !Modifier.isAbstract(mod)) processMethods0(mod, clazz, m, i, dontSearch); } }
private static void processClasses(CompiledClass[] entries, int n) throws Exception Reflection implementor = new Reflection(); ClassPool pool = ClassPool.getDefault(); implementor.start(pool); classobj = entries[i].classobject; if (!implementor.makeReflective(c, pool.get(metaobj), pool.get(classobj))) System.err.println("Warning: " + c.getName() implementor.onLoad(pool, entries[i].classname); pool.get(entries[i].classname).writeFile();
clazz.addInterface(mlevel); processMethods(clazz, addMeta); processFields(clazz);
+ clazz.getName()); registerReflectiveClass(clazz); return modifyClassfile(clazz, metaobject, metaclass);
String name = m.getName(); if (isExcluded(name)) // internally-used method inherited return; // from a reflective class. m2 = CtNewMethod.delegator(findOriginal(m, dontSearch), clazz); m2.setModifiers(mod); clazz.addMethod(m2);
/** * Produces a reflective class. * If the super class is also made reflective, it must be done * before the sub class. * * @param classname the name of the reflective class * @param metaobject the class name of metaobjects. * @param metaclass the class name of the class metaobject. * @return <code>false</code> if the class is already reflective. * * @see javassist.tools.reflect.Metaobject * @see javassist.tools.reflect.ClassMetaobject */ public boolean makeReflective(String classname, String metaobject, String metaclass) throws CannotCompileException, NotFoundException { return makeReflective(classPool.get(classname), classPool.get(metaobject), classPool.get(metaclass)); }
/** * Constructs a new class loader. */ public Loader() throws CannotCompileException, NotFoundException { super(); delegateLoadingOf("javassist.tools.reflect.Loader"); reflection = new Reflection(); ClassPool pool = ClassPool.getDefault(); addTranslator(pool, reflection); }
private void processMethods(CtClass clazz, boolean dontSearch) throws CannotCompileException, NotFoundException { CtMethod[] ms = clazz.getMethods(); for (int i = 0; i < ms.length; ++i) { CtMethod m = ms[i]; int mod = m.getModifiers(); if (Modifier.isPublic(mod) && !Modifier.isAbstract(mod)) processMethods0(mod, clazz, m, i, dontSearch); } }
private static void processClasses(CompiledClass[] entries, int n) throws Exception Reflection implementor = new Reflection(); ClassPool pool = ClassPool.getDefault(); implementor.start(pool); classobj = entries[i].classobject; if (!implementor.makeReflective(c, pool.get(metaobj), pool.get(classobj))) System.err.println("Warning: " + c.getName() implementor.onLoad(pool, entries[i].classname); pool.get(entries[i].classname).writeFile();
clazz.addInterface(mlevel); processMethods(clazz, addMeta); processFields(clazz);