private void implementClearInstance(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(void.class, "clearInstance") .body() .append(loadVariable("proxyHelper").invoke("clearInstance")) .finish(); }
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(); }
log.info("generating RPC proxy loader class..."); ClassStructureBuilder<?> classBuilder = ClassBuilder.implement(RpcProxyLoader.class); 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)); String gen = classBuilder.toJavaString(); log.info("generated RPC proxy loader class in " + (System.currentTimeMillis() - time) + "ms."); return gen;
private void implementInitProxyProperties(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { final BlockBuilder<?> initBody = proxyImpl .publicMethod(void.class, "initProxyProperties", finalOf(injectable.getInjectedType(), "instance")).body(); for (final Entry<String, Statement> prop : controller.getProxyProperties()) { proxyImpl.privateField(prop.getKey(), prop.getValue().getType()).finish(); initBody.append(loadVariable(prop.getKey()).assignValue(prop.getValue())); } initBody.finish(); }
initMethod = classStructureBuilder.privateMethod(void.class, "lazyInit"); classStructureBuilder.privateField("EMPTY_ARRAY", arrayType).initializesWith(Stmt.newArray(toMap, 0)).finish(); classStructureBuilder.publicMethod(arrayType, "getEmptyArray") .append(Stmt.loadClassMember("EMPTY_ARRAY").returnValue()) .finish(); classStructureBuilder.publicMethod(toMap, "demarshall", Parameter.of(EJValue.class, "a0"), Parameter.of(MarshallingSession.class, "a1")); classStructureBuilder.declaresInnerClass(new InnerClass(arrayMarshaller)); classStructureBuilder.getClassDefinition(), PrivateAccessUtil.getPrivateMethodName(constructor), (Object[]) constructorParameters))); classStructureBuilder.declaresInnerClass(new InnerClass(arrayMarshaller)); if (!context.isExposed(field, classStructureBuilder.getClassDefinition().getName())) { PrivateAccessUtil.addPrivateAccessStubs(gwtTarget ? "jsni" : "reflection", classStructureBuilder, field); context.markExposed(field, classStructureBuilder.getClassDefinition().getName()); bindingStatement = Stmt.invokeStatic(classStructureBuilder.getClassDefinition(), final BlockBuilder<?> marshallMethodBlock = classStructureBuilder.publicMethod(String.class, "marshall", Parameter.of(toMap, "a0"), Parameter.of(MarshallingSession.class, "a1"));
.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()) .publicMethod(BindableProxyAgent.class, "getBindableProxyAgent") .append(agent().returnValue()) .finish() .publicMethod(void.class, "updateWidgets") .append(agent().invoke("updateWidgetsAndFireEvents")) .finish() .publicMethod(bindable, "unwrap") .append(target().returnValue()) .finish() .publicMethod(bindable, "deepUnwrap") .publicMethod(boolean.class, "equals", Parameter.of(Object.class, "obj")) .append( If.instanceOf(Variable.get("obj"), classBuilder.getClassDefinition()) .append(Stmt.loadVariable("obj").assignValue(
.define("Dynamic" + fullyQualifiedClassNameToCamelCase(validator.getFullyQualifiedName()), validator) .publicScope() .implementsInterface(parameterizedAs(GeneratedDynamicValidator.class, typeParametersOf(valueType))) .body(); .publicMethod(parameterizedAs(Set.class, typeParametersOf(ConstraintViolation.class)), "validate", finalOf(parameterizedAs(Map.class, typeParametersOf(String.class, Object.class)), "parameters"), finalOf(valueType, "value")) .body(); bodyBlockBuilder.declaresInnerClass(new InnerClass(generatedValidatorBuilder.getClassDefinition())); .append(loadVariable("this").invoke("initialize", annoImpl)) .append(if_(Bool.expr(loadVariable("this").invoke("isValid", loadVariable("value"), castTo(ConstraintValidatorContext.class, loadLiteral(null))))) .append(invokeStatic(Collections.class, "emptySet").returnValue()) .finish().else_() .append(Stmt.declareVariable("paramMessage", String.class, castTo(String.class, loadVariable("parameters").invoke("get", Stmt.loadLiteral("message"))))) .append(Stmt.loadVariable("paramMessage").assignValue( new TernaryStatement(Bool.isNotNull(Stmt.loadVariable("paramMessage")), return loadVariable("dynamicValidator").invoke("addValidator", loadLiteral(annoType.getFullyQualifiedName()), loadLiteral(valueType.getFullyQualifiedName()), newObject(generatedValidatorBuilder.getClassDefinition()));
@Test public void testDefineClassWithMethodCallingMethodOnThis() { 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.load(null).returnValue()) .finish() .toJavaString(); assertEquals("failed to generate class with method calling method on this", CLASS_WITH_METHOD_CALLING_METHOD_ON_THIS, cls); }
builder.getClassDefinition().getContext().setPermissiveMode(true); builder.privateField(COMPARATOR_MAP_VAR, mapStringAnnoComp) .initializesWith(Stmt.newObject(mapStringAnnoComp)).finish(); final ConstructorBlockBuilder<? extends ClassStructureBuilder<?>> constrBuilder = builder.publicConstructor(); constrBuilder._(Stmt.loadVariable(COMPARATOR_MAP_VAR) .invoke("put", MC_annotationClass.getFullyQualifiedName(), generateComparatorFor(MC_annotationClass, methods))); builder.publicMethod(boolean.class, "isEqual", Parameter.of(annotationClazz, "a1"), Parameter.of(annotationClazz, "a2")) .body() ._(If.cond(invokeStatic(QualifierUtil.class, "isSameType", Refs.get("a1"), Refs.get("a2"))) ._( If.cond(Stmt.loadVariable(COMPARATOR_MAP_VAR).invoke("containsKey", Stmt.loadVariable("a1").invoke("annotationType").invoke("getName"))) ._(Stmt.castTo(AnnotationComparator.class, Stmt.loadVariable(COMPARATOR_MAP_VAR) .invoke("get", Stmt.loadVariable("a1").invoke("annotationType").invoke("getName")) ).invoke("isEqual", Refs.get("a1"), Refs.get("a2")).returnValue()) builder.publicMethod(int.class, "hashCodeOf", Parameter.of(Annotation.class, "a1")) .body() ._( If.cond(Stmt.loadVariable(COMPARATOR_MAP_VAR).invoke("containsKey", final String csq = builder.toJavaString();
@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 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(); }
classContext = classStructureBuilder.getClassDefinition().getContext(); mappingContext = GeneratorMappingContextFactory.create(context, target, this, classStructureBuilder, new ArrayMarshallerCallbackImpl()); classStructureBuilder.getClassDefinition().addAnnotation(() -> Dependent.class); autoInitializedField(classStructureBuilder, javaUtilMap, MARSHALLERS_VAR, mapClass); final ConstructorBlockBuilder<?> constructor = classStructureBuilder.publicConstructor(); classStructureBuilder.publicMethod(parameterizedAs(Marshaller.class, typeParametersOf(Object.class)), "getMarshaller").parameters(String.class) .body() .append( If.isNull(loadVariable("a0")) .append(Stmt.loadLiteral(null).returnValue()).finish()) .append(Stmt.declareVariable("m", Marshaller.class, Stmt.loadVariable(MARSHALLERS_VAR).invoke("get", loadVariable("a0")))); classStructureBuilder.publicMethod(void.class, "registerMarshaller").parameters(String.class, Marshaller.class) .body() .append(Stmt.loadVariable(MARSHALLERS_VAR).invoke("put", Stmt.loadVariable("a0"), Stmt.loadVariable("a1"))) .finish(); refresh = true; return classStructureBuilder.toJavaString();
@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(); }
protected void maybeImplementCreateProxy(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable) { final MetaClass proxyImpl = maybeCreateProxyImplementation(injectable, bodyBlockBuilder); if (proxyImpl != null) { final BlockBuilder<?> createProxyBody = bodyBlockBuilder .publicMethod(parameterizedAs(Proxy.class, typeParametersOf(injectable.getInjectedType())), "createProxy", finalOf(Context.class, "context")) .body(); final Object proxyInstanceStmt; if (injectable.getInjectedType().isInterface() || getAccessibleNoArgConstructor(injectable.getInjectedType()) != null) { proxyInstanceStmt = newObject(proxyImpl); } else { bodyBlockBuilder .privateMethod(parameterizedAs(Proxy.class, typeParametersOf(injectable.getInjectedType())), "createProxyWithErrorMessage") .body() .append(try_().append(load(newObject(proxyImpl)).returnValue()).finish() .catch_(Throwable.class, "t").append(throw_(RuntimeException.class, loadLiteral(injectableConstructorErrorMessage(injectable)), loadVariable("t"))) .finish()) .finish(); proxyInstanceStmt = loadVariable("this").invoke("createProxyWithErrorMessage"); } createProxyBody .append(declareFinalVariable("proxyImpl", parameterizedAs(Proxy.class, typeParametersOf(injectable.getInjectedType())), proxyInstanceStmt)) .append(loadVariable("proxyImpl").invoke("setProxyContext", loadVariable("context"))) .append(loadVariable("proxyImpl").returnValue()).finish(); } }
@Test public void testDefineInnerClassInMethod() { final ClassStructureBuilder<?> innerClass = ClassBuilder.define("Inner") .packageScope() .implementsInterface(Serializable.class) .body() .privateField("name", String.class) .finish() .publicMethod(void.class, "setName", Parameter.of(String.class, "name", true)) .append(Stmt.loadClassMember("name").assignValue(Variable.get("name"))) .finish(); final String cls = ClassBuilder.define("foo.bar.Baz") .publicScope() .body() .publicMethod(void.class, "someMethod") .append(new InnerClass(innerClass.getClassDefinition())) .append(Stmt.newObject(innerClass.getClassDefinition())) .finish() .toJavaString(); assertEquals("failed to generate class with method using inner class", CLASS_WITH_METHOD_USING_INNER_CLASS, 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(); }
@Test public void testDefineClassWithStaticMethod() { final String cls = ClassBuilder.define("my.test.Clazz") .publicScope().body() .publicMethod(void.class, "test").modifiers(Modifier.Static) .body() .append(Stmt.loadStatic(System.class, "out").invoke("println", "Hello, World!")) .finish() .toJavaString(); assertEquals("failed to generate class with static method", CLASS_WITH_STATIC_METHOD, cls); }
final ConstructorBlockBuilder<?> ctor = classBuilder.publicConstructor(); ctor.append(Stmt.loadVariable("this").invoke("registerTranslation", name, value, null)); classBuilder.getClassDefinition().addInnerClass(new InnerClass(messageBundleResourceInterface)); ctor.append(Stmt.declareVariable(messageBundleResourceInterface).named(msgBundleVarName) .initializeWith(Stmt.invokeStatic(GWT.class, "create", messageBundleResourceInterface))); ctor.append(Stmt.loadVariable("this").invoke(registerBundleMethod, Stmt.loadVariable(msgBundleVarName).invoke("getContents").invoke("getText"), locale)); return classBuilder.toJavaString();