public static ClassGenerator newInstance(ClassLoader loader) { return new ClassGenerator(getClassPool(loader)); }
public ClassGenerator addConstructor(int mod, Class<?>[] pts, String body) { return addConstructor(mod, pts, null, body); }
public ClassGenerator addField(String name, int mod, Class<?> type, String def) { StringBuilder sb = new StringBuilder(); sb.append(modifier(mod)).append(' ').append(ReflectUtils.getName(type)).append(' '); sb.append(name); if( def != null && def.length() > 0 ) { sb.append('='); sb.append(def); } sb.append(';'); return addField(sb.toString()); }
cpf.append("String name = $1.readUTF(); if( name == null ) return null; return (").append(cn).append(")Enum.valueOf(").append(cn).append(".class, name); }"); ClassGenerator cg = ClassGenerator.newInstance(cl); cg.setClassName(bcn); cg.setSuperClass(Builder.class); cg.addDefaultConstructor(); cg.addMethod("public Class getType(){ return " + cn + ".class; }"); cg.addMethod(cwt.toString()); cg.addMethod(cpf.toString()); try Class<?> wc = cg.toClass(); return (Builder<?>)wc.newInstance(); cg.release();
public ClassGenerator addMethod(String name, int mod, Class<?> rt, Class<?>[] pts, Class<?>[] ets, String body) { StringBuilder sb = new StringBuilder(); sb.append(modifier(mod)).append(' ').append(ReflectUtils.getName(rt)).append(' ').append(name); sb.append('('); for(int i=0;i<pts.length;i++) { if( i > 0 ) sb.append(','); sb.append(ReflectUtils.getName(pts[i])); sb.append(" arg").append(i); } sb.append(')'); if( ets != null && ets.length > 0 ) { sb.append(" throws "); for(int i=0;i<ets.length;i++) { if( i > 0 ) sb.append(','); sb.append(ReflectUtils.getName(ets[i])); } } sb.append('{').append(body).append('}'); return addMethod(sb.toString()); }
public ClassGenerator addConstructor(int mod, Class<?>[] pts, Class<?>[] ets, String body) { StringBuilder sb = new StringBuilder(); sb.append(modifier(mod)).append(' ').append(SIMPLE_NAME_TAG); sb.append('('); for(int i=0;i<pts.length;i++) { if( i > 0 ) sb.append(','); sb.append(ReflectUtils.getName(pts[i])); sb.append(" arg").append(i); } sb.append(')'); if( ets != null && ets.length > 0 ) { sb.append(" throws "); for(int i=0;i<ets.length;i++) { if( i > 0 ) sb.append(','); sb.append(ReflectUtils.getName(ets[i])); } } sb.append('{').append(body).append('}'); return addConstructor(sb.toString()); }
parameterClass = (Class<?>) Class.forName(parameterClassName, true, clazz.getClassLoader()); } catch (ClassNotFoundException e) { ClassPool pool = ClassGenerator.getClassPool(clazz.getClassLoader()); parameterClass = parameterClassMap.get(parameterClassName); if (null == parameterClass) {
mCtc.addMethod(CtNewMethod.copy(getCtMethod(mCopyMethods.get(code.substring(1))), code.substring(1, code.indexOf('(')), mCtc, null)); else mCtc.addMethod(CtNewMethod.make(code, mCtc)); mCtc.addConstructor(CtNewConstructor.copy(getCtConstructor(mCopyConstructors.get(code.substring(1))), mCtc, null));
public ClassGenerator addMethod(String name, int mod, Class<?> rt, Class<?>[] pts, String body) { return addMethod(name, mod, rt, pts, null, body); }
private CtConstructor getCtConstructor(Constructor<?> c) throws NotFoundException { return getCtClass(c.getDeclaringClass()).getConstructor(ReflectUtils.getDesc(c)); }
public ClassGenerator addField(String name, int mod, Class<?> type) { return addField(name, mod, type, null); }
public ClassGenerator addInterface(Class<?> cl) { return addInterface(cl.getName()); }
ccp = ClassGenerator.newInstance(cl); ccp.addField("private " + dcs[i].getName() + " d" + i + ";"); ccp.addConstructor(Modifier.PUBLIC, new Class<?>[]{ Object[].class }, code.toString()); ccp.addInterface(ics[i]); String mn = method.getName(); if( Void.TYPE.equals(rt) ) ccp.addMethod(mn, method.getModifiers(), rt, method.getParameterTypes(), method.getExceptionTypes(), "d" + ix + "." + mn + "($$);"); else ccp.addMethod(mn, method.getModifiers(), rt, method.getParameterTypes(), method.getExceptionTypes(), "return ($r)d" + ix + "." + mn + "($$);"); ccp.setClassName(micn); ccp.toClass(); ccm = ClassGenerator.newInstance(cl); ccm.setClassName(fcn); ccm.addDefaultConstructor(); ccm.setSuperClass(Mixin.class.getName()); ccm.addMethod("public Object newInstance(Object[] delegates){ return new " + micn + "($1); }"); Class<?> mixin = ccm.toClass(); return (Mixin)mixin.newInstance(); ccp.release(); if( ccm != null )
public ClassGenerator addMethod(Method m) { addMethod(m.getName(), m); return this; }
private CtMethod getCtMethod(Method m) throws NotFoundException { return getCtClass(m.getDeclaringClass()).getMethod(m.getName(),ReflectUtils.getDescWithoutMethodName(m)); }
try ccp = ClassGenerator.newInstance(cl); ccp.addInterface(ics[i]); ccp.addMethod(method.getName(), method.getModifiers(), rt, pts, method.getExceptionTypes(), code.toString()); ccp.setClassName(pcn); ccp.addField("public static java.lang.reflect.Method[] methods;"); ccp.addField("private " + InvocationHandler.class.getName() + " handler;"); ccp.addConstructor(Modifier.PUBLIC, new Class<?>[]{ InvocationHandler.class }, new Class<?>[0], "handler=$1;"); ccp.addDefaultConstructor(); Class<?> clazz = ccp.toClass(); clazz.getField("methods").set(null, methods.toArray(new Method[0])); ccm = ClassGenerator.newInstance(cl); ccm.setClassName(fcn); ccm.addDefaultConstructor(); ccm.setSuperClass(Proxy.class); ccm.addMethod("public Object newInstance(" + InvocationHandler.class.getName() + " h){ return new " + pcn + "($1); }"); Class<?> pc = ccm.toClass(); proxy = (Proxy)pc.newInstance(); ccp.release(); if( ccm != null ) ccm.release(); synchronized( cache )
public static ClassGenerator newInstance() { return new ClassGenerator(getClassPool(Thread.currentThread().getContextClassLoader())); }
public ClassGenerator addMethod(String name, Method m) { String desc = name + ReflectUtils.getDescWithoutMethodName(m); addMethod(':' + desc); if( mCopyMethods == null ) mCopyMethods = new ConcurrentHashMap<String, Method>(8); mCopyMethods.put(desc, m); return this; }
public ClassGenerator addConstructor(Constructor<?> c) { String desc = ReflectUtils.getDesc(c); addConstructor(":"+desc); if( mCopyConstructors == null ) mCopyConstructors = new ConcurrentHashMap<String, Constructor<?>>(4); mCopyConstructors.put(desc, c); return this; }
cpf.append(" } return ret; }"); ClassGenerator cg = ClassGenerator.newInstance(cl); cg.setClassName(bcn); cg.setSuperClass(Builder.class); cg.addDefaultConstructor(); if( builder != null ) cg.addField("public static " + BUILDER_CLASS_NAME + " builder;"); cg.addMethod("public Class getType(){ return " + cn + ".class; }"); cg.addMethod(cwt.toString()); cg.addMethod(cpf.toString()); try Class<?> wc = cg.toClass(); cg.release();