public static void createJavaReflectionFieldInitializerUtilMethod(final ClassStructureBuilder<?> classBuilder) { if (classBuilder.getClassDefinition().getMethod(JAVA_REFL_FLD_UTIL_METH, Class.class, Field.class) != null) { return; } classBuilder.privateMethod(Field.class, JAVA_REFL_FLD_UTIL_METH).modifiers(Modifier.Static) .parameters(DefParameters.of(Parameter.of(Class.class, "cls"), Parameter.of(String.class, "name"))) .body() ._(Stmt.try_() ._(Stmt.declareVariable("fld", Stmt.loadVariable("cls").invoke("getDeclaredField", Stmt.loadVariable("name")))) ._(Stmt.loadVariable("fld").invoke("setAccessible", true)) ._(Stmt.loadVariable("fld").returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
private void implementGetContext(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(Context.class, "getProxyContext") .body() .append(loadVariable("proxyHelper").invoke("getProxyContext").returnValue()) .finish(); }
private Statement generateInterceptorLogic(ClassStructureBuilder<?> classBuilder, MetaMethod method, Statement requestLogic, List<Statement> parmVars, List<Class<?>> interceptors) { final Statement callContext = ProxyUtil.generateProxyMethodCallContext(context, RemoteCallContext.class, classBuilder.getClassDefinition(), method, requestLogic, interceptors).finish(); return Stmt.try_() .append( Stmt.declareVariable(CallContextStatus.class).asFinal().named("status").initializeWith( Stmt.newObject(CallContextStatus.class).withParameters(interceptors.toArray()))) .append( Stmt.declareVariable(RemoteCallContext.class).asFinal().named("callContext") .initializeWith(callContext)) .append( Stmt.loadVariable("callContext").invoke("setParameters", Stmt.newArray(Object.class).initialize(parmVars.toArray()))) .append( Stmt.loadVariable("callContext").invoke("proceed")) .finish() .catch_(Throwable.class, "throwable") .append( If.cond(Bool.notEquals(Stmt.loadVariable("errorCallback"), Stmt.loadLiteral(null))) .append( If.cond(Stmt.loadVariable("errorCallback").invoke("error", Stmt.load(null), Variable.get("throwable"))) .append(Stmt.loadVariable("this").invoke("invokeDefaultErrorHandlers", Variable.get("throwable"))) .finish() ).finish() .else_() .append(Stmt.loadVariable("this").invoke("invokeDefaultErrorHandlers", Variable.get("throwable"))) .finish()) .finish(); }
private void generateMethod(ClassStructureBuilder<?> classBuilder, MetaMethod method) { final List<Class<?>> interceptors = interceptorProvider.getInterceptors(remote, method); final boolean intercepted = !interceptors.isEmpty(); final Parameter[] parms = DefParameters.from(method).getParameters().toArray(new Parameter[0]); final Parameter[] finalParms = new Parameter[parms.length]; final List<Statement> parmVars = new ArrayList<Statement>(); for (int i = 0; i < parms.length; i++) { finalParms[i] = Parameter.of(parms[i].getType().getErased(), parms[i].getName(), true); parmVars.add(Stmt.loadVariable(parms[i].getName())); } final Statement parameters = (intercepted) ? new StringStatement("getParameters()", MetaClassFactory.get(Object[].class)) : Stmt.newArray(Object.class).initialize(parmVars.toArray()); final BlockBuilder<?> methodBlock = classBuilder.publicMethod(method.getReturnType().getErased(), method.getName(), finalParms); if (intercepted) { methodBlock.append(generateInterceptorLogic(classBuilder, method, generateRequest(classBuilder, method, parameters, true), parmVars, interceptors)); } else { methodBlock.append(generateRequest(classBuilder, method, parameters, false)); } final Statement returnStmt = ProxyUtil.generateProxyMethodReturnStatement(method); if (returnStmt != null) { methodBlock.append(returnStmt); } methodBlock.finish(); }
final long time = System.currentTimeMillis(); final MethodBlockBuilder<?> loadProxies = classBuilder.publicMethod(void.class, "loadProxies", Parameter.of(MessageBus.class, "bus", true)); loadProxies.append(new InnerClass(remoteProxy.getClassDefinition())); .extend() .publicOverridesMethod("getProxy") .append(Stmt.nestedCall(Stmt.newObject(remoteProxy.getClassDefinition())).returnValue()) .finish() .finish(); loadProxies.append(Stmt.invokeStatic(RemoteServiceProxyFactory.class, "addRemoteProxy", remote, proxyProvider));
.privateField(agentField, parameterizedAs(BindableProxyAgent.class, typeParametersOf(bindable))) .finish() .privateField(targetField, bindable) .finish() .publicConstructor() .callThis(Stmt.newObject(bindable)) .finish() .publicConstructor(Parameter.of(bindable, "targetVal")) .append(Stmt.loadVariable(agentField).assignValue( Stmt.newObject(parameterizedAs(BindableProxyAgent.class, typeParametersOf(bindable)), Variable.get("this"), Variable.get("targetVal")))) .append(Stmt.loadVariable(targetField).assignValue(Variable.get("targetVal"))) .append(generatePropertiesMap()) .append(agent().invoke("copyValues")) .appendAll(registerDeclarativeHandlers(bindable)) .finish() .publicMethod(BindableProxyAgent.class, "getBindableProxyAgent") .append(agent().returnValue()) .finish() .publicMethod(void.class, "updateWidgets") .append(agent().invoke("updateWidgetsAndFireEvents")) .finish() .publicMethod(bindable, "unwrap") .append(target().returnValue()) .finish() .finish() .publicMethod(boolean.class, "equals", Parameter.of(Object.class, "obj"))
builder.privateField(entry.getValue().getEncodedProperty(), entry.getValue().getType()).finish(); builder.packageMethod(void.class, "$set_" + entry.getKey(), Parameter.of(entry.getValue().getType(), "o")) .append(Stmt.loadVariable(entry.getValue().getEncodedProperty()).assignValue(Refs.get("o"))) .finish(); ifBody.appendAll(getAroundInvokeStatements(method)); ifBody.appendAll(getBeforeStatements(method)); ifBody._(loadVariable("this").invoke(PrivateAccessUtil.getPrivateMethodName(method), privateAccessStmts)); ifBody._(loadVariable("this").invoke(PrivateAccessUtil.getPrivateMethodName(method), privateAccessStmts).returnValue()); ifBody._(loadVariable(proxyVar).invoke(method, statementVars)); ifBody._(loadVariable(proxyVar).invoke(method, statementVars).returnValue()); ifBody.appendAll(getAfterStatements(method)); ifBody.appendAll(getAroundInvokeStatements(method)); BlockBuilder<StatementEnd> elseBody = ifBody.finish().else_(); elseBody.append(ProxyUtil.generateProxyMethodReturnStatement(method)); methBody.append(elseBody.finish()); methBody.finish(); .annotatedWith(OVERRIDE_ANNOTATION) .body() ._(
@Override public void createWritableField(final MetaClass type, final ClassStructureBuilder<?> classBuilder, final MetaField field, final Modifier[] modifiers) { final String cachedField = initCachedField(classBuilder, field); final String setterName = getReflectionFieldSetterName(field); final MethodCommentBuilder<? extends ClassStructureBuilder<?>> methodBuilder = classBuilder.privateMethod(void.class, PrivateAccessUtil.getPrivateFieldAccessorName(field)); if (!field.isStatic()) { methodBuilder .parameters( DefParameters.fromParameters( Parameter.of(field.getDeclaringClass().getErased(), "instance"), Parameter.of(field.getType(), "value") ) ); } methodBuilder.modifiers(modifiers) .body() ._(Stmt.try_() ._(Stmt.loadVariable(cachedField).invoke(setterName, Refs.get("instance"), Refs.get("value"))) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
If.isNull(Stmt.loadVariable("status").invoke("getNextInterceptor"))._(proceed).finish(); Stmt.loadVariable("status").invoke("getNextInterceptor"), interceptor)) .append(Stmt.declareFinalVariable("ctx", callContextType, Stmt.loadVariable("this"))) .append( Stmt.declareVariable(CreationalCallback.class).asFinal().named("icc") .initializeWith( Stmt.newObject(CreationalCallback.class).extend() .publicOverridesMethod("callback", Parameter.of(Object.class, "beanInstance", true)) .append(Stmt.loadVariable("status").invoke("setProceeding", false)) .append( Stmt.castTo(interceptor, Stmt.loadVariable("beanInstance")).invoke("aroundInvoke", Variable.get("ctx"))) .append( If.cond(Bool.and( Bool.notExpr(Stmt.loadVariable("status").invoke("isProceeding")), Bool.equals(Stmt.loadLiteral(interceptor), Stmt.loadVariable("status").invoke("getNextInterceptor")))) .append( Stmt.loadVariable("remoteCallback").invoke("callback", Stmt.loadVariable("ctx").invoke("getResult"))) .finish()) .finish() // finish the method override body .append(generateAsyncInterceptorCreation(context, interceptor)) .finish(); proceedLogic.addStatement(interceptorStack.else_().finish()); return proceedLogic;
AnonymousClassStructureBuilder callBack = Stmt.newObject(callBackType).extend(); callBackBlock = callBack.initialize(); for (final String qualifierName : qualifierNames) { callBackBlock.append(Stmt.loadClassMember("qualifierSet").invoke("add", qualifierName)); callBack = callBackBlock.finish(); callBackBlock = callBack.publicOverridesMethod("fireEvent", Parameter.finalOf(eventType, "event")) .appendAll(callbackStatements) .finish() .publicOverridesMethod("toString") ._(Stmt.load("Observer: " + parmClassName + " " + Arrays.toString(qualifiers)).returnValue()); final Statement subscribeStatement = Stmt.create(ctx).invokeStatic(CDI.class, subscribeMethod, parmClassName, callBackBlock.finish().finish()); destroyStatements.add(controller.getReferenceStmt(subscrVar, Subscription.class).invoke("remove")); } else { initStatements.add(subscribeStatement); final ContextualStatementBuilder routingSubStmt = Stmt.invokeStatic(ErraiBus.class, "get").invoke("subscribe", CDI.getSubjectNameByType(cls.getName()), Stmt.loadStatic(CDI.class, "ROUTING_CALLBACK")); if (isEnclosingTypeDependent) {
elementAccessor = Stmt.loadVariable("element").invoke("getStyle"); final boolean enclosingTypeIsDependent = decorable.isEnclosingTypeDependent(); if (!enclosingTypeIsDependent) { bindExecStmts.add(declareFinalVariable("instance", decorable.getEnclosingInjectable().getInjectedType(), castTo(decorable.getEnclosingInjectable().getInjectedType(), invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt())))); final ObjectBuilder bindExec = newObject(StyleBindingExecutor.class) .extend() .publicOverridesMethod("invokeBinding", Parameter.of(Element.class, "element")) .appendAll(bindExecStmts) .finish() .finish(); final List<Statement> destructionStmts = new ArrayList<Statement>(); initStmts.add(declareFinalVariable(hanldeVarName, parameterizedAs(RefHolder.class, typeParametersOf(BindingRegistrationHandle.class)), newObject(RefHolder.class))); initStmts.add(loadVariable(hanldeVarName).invoke("set", invokeStatic(StyleBindingsRegistry.class, "get") .invoke("addStyleBinding", decorable.getAnnotation().annotationType(), bindExec))); .castTo(BindingRegistrationHandle.class, controller.getReferenceStmt(registrationHandleVar, RefHolder.class).invoke("get")) .invoke("cleanup")); if (enclosingTypeIsDependent) { addCleanup(decorable, controller, destructionStmts);
wrapperDefParms.add(Parameter.of(method.getDeclaringClass().getErased(), "instance")); args[i++] = Refs.get(p.getName()); = classBuilder.publicMethod(method.getReturnType(), PrivateAccessUtil.getPrivateMethodName(method)) .parameters(DefParameters.fromParameters(wrapperDefParms)) .modifiers(modifiers) .body(); final BlockBuilder<CatchBlockBuilder> tryBuilder = Stmt.try_(); final ContextualStatementBuilder statementBuilder = Stmt.loadVariable(cachedMethod) .invoke("invoke", method.isStatic() ? null : Refs.get("instance"), args); tryBuilder._(statementBuilder); tryBuilder._(Stmt.castTo(method.getReturnType().asBoxed(), statementBuilder).returnValue()); body._(tryBuilder .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish();
@Test public void testDefineClassWithAccessorMethods() { final String cls = ClassBuilder.define("org.foo.Foo") .publicScope() .body() .privateField("name", String.class) .initializesWith(Stmt.load("default")) .finish() .publicMethod(String.class, "getName") .append(Stmt.loadVariable("name").returnValue()) .finish() .publicMethod(void.class, "setName", Parameter.of(String.class, "name")) .append(Stmt.loadClassMember("name").assignValue(Variable.get("name"))) .finish() .toJavaString(); assertEquals("failed to generate class definition with accessor methods", CLASS_WITH_ACCESSOR_METHODS, cls); }
private void createPutMarshallerMethod() { classStructureBuilder .privateMethod(boolean.class, "putMarshaller", Parameter.of(String.class, "fqcn"), Parameter.of(Marshaller.class, "m")) .append(Stmt.loadVariable(MARSHALLERS_VAR).invoke("put", Stmt.loadVariable("fqcn"), Stmt.loadVariable("m"))) .append(Stmt.loadLiteral(true).returnValue()) .finish(); }
private void generateCommonSetter(final ClassStructureBuilder<?> classBuilder) { classBuilder.privateMethod(void.class, "changeAndFire", Parameter.of(String.class, "property"), Parameter.of(Object.class, "value")) .append(Stmt.declareFinalVariable("oldValue", Object.class, Stmt.loadVariable("this").invoke("get", loadVariable("property")))) .append(Stmt.loadVariable("this").invoke("set", loadVariable("property"), loadVariable("value"))) .append(agent().invoke("updateWidgetsAndFireEvent", false, loadVariable("property"), Variable.get("oldValue"), loadVariable("value"))) .finish(); }
private void implementEquals(final ClassStructureBuilder<?> proxyImpl) { proxyImpl.publicMethod(boolean.class, "equals", Parameter.of(Object.class, "obj")).body() .append(loadVariable("obj").assignValue(invokeStatic(Factory.class, "maybeUnwrapProxy", loadVariable("obj")))) .append(loadVariable("proxyHelper").invoke("getInstance", loadVariable("this")).invoke("equals", loadVariable("obj")).returnValue()) .finish(); }
/** * Generates a getter method for the provided property plus the corresponding code for the * implementation of {@link HasProperties#get(String)}. */ private void generateGetter(final ClassStructureBuilder<?> classBuilder, final String property, final CaseBlockBuilder switchBlock) { final MetaMethod getterMethod = bindable.getBeanDescriptor().getReadMethodForProperty(property); if (getterMethod != null && !getterMethod.isFinal() && getterMethod.isPublic()) { BlockBuilder<CaseBlockBuilder> caseBlock = switchBlock.case_(property); caseBlock.append(Stmt.loadVariable("this").invoke(getterMethod.getName()).returnValue()).finish(); classBuilder.publicMethod(getterMethod.getReturnType(), getterMethod.getName()) .append(target().invoke(getterMethod.getName()).returnValue()) .finish(); proxiedAccessorMethods.add(getterMethod); } }
@Test public void testDefineClassWithMethodCallingMethodOnSuper() { final String cls = ClassBuilder.define("org.foo.Foo") .publicScope() .body() .publicMethod(void.class, "bar") .append(Stmt.loadVariable("this").invoke("foo")) .finish() .publicMethod(String.class, "foo") .append(Stmt.loadVariable("super").invoke("toString").returnValue()) .finish() .toJavaString(); assertEquals("failed to generate class with method calling method on this", CLASS_WITH_METHOD_CALLING_METHOD_ON_SUPER, cls); }
private BlockBuilder<AnonymousClassStructureBuilder> getSubscriptionCallback(final Decorable decorable, final FactoryController controller) { final MetaParameter parm = decorable.getAsParameter(); final MetaClass eventType = parm.getType().asBoxed(); final String parmClassName = eventType.getFullyQualifiedName(); final List<Annotation> annotations = InjectUtil.extractQualifiers(parm); final Annotation[] qualifiers = annotations.toArray(new Annotation[annotations.size()]); final Set<String> qualifierNames = new HashSet<>(CDI.getQualifiersPart(qualifiers)); final MetaClass callBackType = parameterizedAs(AbstractCDIEventCallback.class, typeParametersOf(eventType)); AnonymousClassStructureBuilder callBack = Stmt.newObject(callBackType).extend(); BlockBuilder<AnonymousClassStructureBuilder> callBackBlock; if (!qualifierNames.isEmpty()) { callBackBlock = callBack.initialize(); for (final String qualifierName : qualifierNames) { callBackBlock.append(Stmt.loadClassMember("qualifierSet").invoke("add", qualifierName)); } callBack = callBackBlock.finish(); } final List<Statement> fireEventStmts = new ArrayList<>(); if (!decorable.isEnclosingTypeDependent()) { fireEventStmts.add(Stmt.declareFinalVariable("instance", decorable.getEnclosingInjectable().getInjectedType(), Stmt.invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt()))); } fireEventStmts.add(decorable.call(Refs.get("event"))); callBackBlock = callBack.publicOverridesMethod("fireEvent", Parameter.finalOf(eventType, "event")) .appendAll(fireEventStmts) .finish() .publicOverridesMethod("toString") ._(Stmt.load("Observer: " + parmClassName + " " + Arrays.toString(qualifiers)).returnValue()); return callBackBlock; }
nonInitializedReturns = false; } else { nonInitializedCase = loadVariable("super").invoke(method.getName(), getParametersForInvocation(method)); nonInitializedReturns = true; final BlockBuilder<ElseBlockBuilder> ifBlock = if_( BooleanExpressionBuilder.create(loadVariable("proxyHelper"), BooleanOperator.NotEquals, null)) .append(proxiedInstanceDeclaration) .appendAll(controller.getInvokeBeforeStatements(method)); if (method.getReturnType().isVoid()) { ifBlock.append(proxyHelperInvocation); ifBlock.appendAll(controller.getInvokeAfterStatements(method)); body.append(ifBlock.finish().else_().append(nonInitializedCase).finish()); } else { ifBlock.append(declareFinalVariable("retVal", method.getReturnType().getErased(), proxyHelperInvocation)); ifBlock.appendAll(controller.getInvokeAfterStatements(method)); ifBlock.append(loadVariable("retVal").returnValue()); if (nonInitializedReturns) { body.append(ifBlock.finish().else_().append(nestedCall(nonInitializedCase).returnValue()).finish()); } else { body.append(ifBlock.finish().else_().append(nonInitializedCase).finish()); body.finish();