public void enhance(CtClass managedCtClass) { // Add the Managed interface managedCtClass.addInterface( loadCtClassFromClass( ManagedMappedSuperclass.class ) ); super.enhance( managedCtClass ); }
ifaceClass = ClassUtils.forName(packages, iface).getName(); cls.addInterface(pool.get(ifaceClass));
ifaceClass = ClassUtils.forName(packages, iface).getName(); cls.addInterface(pool.get(ifaceClass));
private static TemplateRenderer tryToCompile(String source, Map<String, String> expressions, Map<String, String> constants, Class<?> modelType) throws NotFoundException, CannotCompileException, InstantiationException, IllegalAccessException { ClassPool cp = ClassPool.getDefault(); CtClass sup = cp.get(Object.class.getCanonicalName()); CtClass cls = cp.makeClass("RapidoidTemplate" + ID_GEN.incrementAndGet(), sup); cls.addInterface(cp.get(TemplateRenderer.class.getCanonicalName())); cls.addConstructor(CtNewConstructor.defaultConstructor(cls)); addExpressions(expressions, cls); addConstants(constants, cls); CtClass[] params = {cp.get(RenderCtx.class.getCanonicalName())}; CtClass clsVoid = cp.get(void.class.getCanonicalName()); cls.addMethod(CtNewMethod.make(Modifier.PUBLIC, clsVoid, "render", params, new CtClass[0], source, cls)); return (TemplateRenderer) cls.toClass().newInstance(); }
if (beanType.equals(HtmlBean)) { CtClass htmlBeanInterface = pool.get("com.geccocrawler.gecco.spider.HtmlBean"); clazz.addInterface(htmlBeanInterface); } else { CtClass jsonBeanInterface = pool.get("com.geccocrawler.gecco.spider.JsonBean"); clazz.addInterface(jsonBeanInterface);
mCtc.setSuperclass(ctcs); mCtc.addInterface(mPool.get(DC.class.getName())); // add dynamic class tag. if (mInterfaces != null) { for (String cl : mInterfaces) { mCtc.addInterface(mPool.get(cl));
mCtc.setSuperclass(ctcs); mCtc.addInterface(mPool.get(DC.class.getName())); // add dynamic class tag. if (mInterfaces != null) { for (String cl : mInterfaces) { mCtc.addInterface(mPool.get(cl));
private void addCompositeOwnerInterface(CtClass managedCtClass) throws NotFoundException, CannotCompileException { CtClass compositeOwnerCtClass = managedCtClass.getClassPool().get( CompositeOwner.class.getName() ); // HHH-10540 only add the interface once for ( CtClass i : managedCtClass.getInterfaces() ) { if ( i.subclassOf( compositeOwnerCtClass ) ) { return; } } managedCtClass.addInterface( compositeOwnerCtClass ); if ( enhancementContext.isCompositeClass( managedCtClass ) ) { // if a composite have a embedded field we need to implement the TRACKER_CHANGER_NAME method as well MethodWriter.write( managedCtClass, "public void %1$s(String name) {%n" + " if (%2$s != null) { %2$s.callOwner(\".\" + name); }%n}", EnhancerConstants.TRACKER_CHANGER_NAME, EnhancerConstants.TRACKER_COMPOSITE_FIELD_NAME ); } }
private void addInLineDirtyHandling(CtClass managedCtClass) { managedCtClass.addInterface( loadCtClassFromClass( CompositeTracker.class ) ); final CtClass compositeCtType = loadCtClassFromClass( CompositeOwnerTracker.class ); FieldWriter.addField( managedCtClass, compositeCtType, EnhancerConstants.TRACKER_COMPOSITE_FIELD_NAME ); createCompositeTrackerMethod( managedCtClass ); }
protected void addInterceptorHandling(CtClass managedCtClass) { // interceptor handling is only needed if class has lazy-loadable attributes if ( !enhancementContext.hasLazyLoadableAttributes( managedCtClass ) ) { return; } log.debugf( "Weaving in PersistentAttributeInterceptable implementation on [%s]", managedCtClass.getName() ); managedCtClass.addInterface( loadCtClassFromClass( PersistentAttributeInterceptable.class ) ); FieldWriter.addFieldWithGetterAndSetter( managedCtClass, loadCtClassFromClass( PersistentAttributeInterceptor.class ), EnhancerConstants.INTERCEPTOR_FIELD_NAME, EnhancerConstants.INTERCEPTOR_GETTER_NAME, EnhancerConstants.INTERCEPTOR_SETTER_NAME ); } }
public void enhance(CtClass managedCtClass) { // add the ManagedComposite interface managedCtClass.addInterface( loadCtClassFromClass( ManagedComposite.class ) ); addInterceptorHandling( managedCtClass ); if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) { addInLineDirtyHandling( managedCtClass ); } super.enhance( managedCtClass ); }
boolean addMeta = !clazz.subtypeOf(mlevel); if (addMeta) clazz.addInterface(mlevel);
CtClass mCtc = mPool.makeClass(interfaceName + "_proxy_" + counter.getAndIncrement()); if (interfaceClass.isInterface()) { mCtc.addInterface(mPool.get(interfaceName)); } else { throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");
CtClass mCtc = mPool.makeClass(interfaceName + "_proxy_" + counter.getAndIncrement()); if (interfaceClass.isInterface()) { mCtc.addInterface(mPool.get(interfaceName)); } else { throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");
cc.addConstructor(cons); cc.addInterface(pool.get(ActorState.class.getName()));
private void addInLineDirtyHandling(CtClass managedCtClass) { managedCtClass.addInterface( loadCtClassFromClass( SelfDirtinessTracker.class ) ); FieldWriter.addField( managedCtClass, loadCtClassFromClass( DirtyTracker.class ), EnhancerConstants.TRACKER_FIELD_NAME ); if ( collectCollectionFields( managedCtClass ).isEmpty() ) { createDirtyTrackerMethodsWithoutCollections( managedCtClass ); } else { FieldWriter.addField( managedCtClass, loadCtClassFromClass( CollectionTracker.class ), EnhancerConstants.TRACKER_COLLECTION_NAME ); createDirtyTrackerMethodsWithCollections( managedCtClass ); } }
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; }
final CtClass ccActorReference = pool.get(RemoteReference.class.getName()); cc.setSuperclass(ccActorReference); cc.addInterface(ccInterface); cc.addConstructor(CtNewConstructor.make(new CtClass[]{ pool.get(String.class.getName()) }, null, "{ super($1); }", cc));
if (mSuperClass != null) mCtc.setSuperclass(ctcs); mCtc.addInterface(mPool.get(DC.class.getName())); // add dynamic class tag. if (mInterfaces != null) for (String cl : mInterfaces) mCtc.addInterface(mPool.get(cl)); if (mFields != null) for (String code : mFields) mCtc.addField(CtField.make(code, mCtc));
public void enhance(CtClass managedCtClass) { // add the ManagedEntity interface managedCtClass.addInterface( loadCtClassFromClass( ManagedEntity.class ) ); addEntityInstanceHandling( managedCtClass ); addEntityEntryHandling( managedCtClass ); addLinkedPreviousHandling( managedCtClass ); addLinkedNextHandling( managedCtClass ); addInterceptorHandling( managedCtClass ); if ( enhancementContext.doDirtyCheckingInline( managedCtClass ) ) { addInLineDirtyHandling( managedCtClass ); } super.enhance( managedCtClass ); }