final BlockBuilder<?> getMethod = classBuilder.publicMethod(Object.class, "get", Parameter.of(String.class, "property")); final BlockBuilder<?> setMethod = classBuilder.publicMethod(void.class, "set", Parameter.of(String.class, "property"), Parameter.of(Object.class, "value")); CaseBlockBuilder getSwitchBlock = Stmt.switch_(loadVariable("property")); CaseBlockBuilder setSwitchBlock = Stmt.switch_(loadVariable("property")); generateSetter(classBuilder, property, setSwitchBlock); getSwitchBlock.case_("this").append(target().returnValue()).finish(); setSwitchBlock.case_("this") .append(Stmt.loadClassMember(targetField).assignValue(Stmt.castTo(bindable, Stmt.loadVariable("value")))) .append(agent().loadField("target").assignValue(Stmt.loadClassMember(targetField))) .append(Stmt.break_()) .finish(); setMethod.append(setSwitchBlock).finish(); classBuilder.publicMethod(Map.class, "getBeanProperties") .append(Stmt.declareFinalVariable("props", Map.class, ObjectBuilder.newInstanceOf(HashMap.class) .withParameters(agent().loadField("propertyTypes")))) .append(Stmt.loadVariable("props").invoke("remove", "this")) .append(Stmt.invokeStatic(Collections.class, "unmodifiableMap", Stmt.loadVariable("props")).returnValue()) .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(); }
private void addCssResourceMethod( final ClassStructureBuilder<ClassStructureBuilderAbstractMethodOption> componentTemplateResource, final String templateStyleSheetPath) { componentTemplateResource.publicMethod(CssResource.class, "getStyle").annotatedWith(new Source() { @Override public Class<? extends Annotation> annotationType() { return Source.class; } @Override public String[] value() { return new String[] { templateStyleSheetPath }; } }, new CssResource.NotStrict() { @Override public Class<? extends Annotation> annotationType() { return CssResource.NotStrict.class; } }).finish(); }
private void maybeImplementDestroyInstance(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final List<Statement> destroyInstanceStatements) { if (!destroyInstanceStatements.isEmpty()) { bodyBlockBuilder .publicMethod(void.class, "generatedDestroyInstance", finalOf(Object.class, "instance"), finalOf(ContextManager.class, "contextManager")) .append(loadVariable("this").invoke("destroyInstanceHelper", Stmt.castTo(injectable.getInjectedType(), loadVariable("instance")), loadVariable("contextManager"))) .finish(); bodyBlockBuilder.publicMethod(void.class, "destroyInstanceHelper", finalOf(injectable.getInjectedType(), "instance"), finalOf(ContextManager.class, "contextManager")) .appendAll(destroyInstanceStatements).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(); }
.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")), Stmt.loadVariable("paramMessage") .invoke("replaceAll", Stmt.loadLiteral("{"), Stmt.loadLiteral("")) .invoke("replaceAll", Stmt.loadLiteral("}"), Stmt.loadLiteral("")) ,Stmt.loadLiteral("")))) .append(Stmt.declareFinalVariable("message", String.class, Stmt.loadVariable("messageResolver").invoke("get", Refs.get("paramMessage")))) .append(invokeStatic(Collections.class, "singleton", createConstraintViolation()).returnValue()) .finish()) .finish();
dimParms[0] = Stmt.loadVariable("a0").invoke("size"); final Statement demarshallerStatement = Stmt.castTo(toMap.asBoxed().asClass(), Stmt.loadVariable(marshallerVarName).invoke("demarshall", loadVariable("a0") .invoke("get", loadVariable("i")), Stmt.loadVariable("a1"))); classBuilder.privateMethod(arrayType, "_demarshall" + dim) .parameters(EJArray.class, MarshallingSession.class).body(); dmBuilder.append(Stmt.loadVariable("this").invoke("lazyInit")); dmBuilder.append(Stmt .declareVariable(arrayType).named("newArray") .initializeWith(Stmt.newArray(toMap, dimParms))); dmBuilder.finish(); final BlockBuilder<?> mBuilder = classBuilder.privateMethod(String.class, "_marshall" + dim) .parameters(arrayType, MarshallingSession.class).body(); "_marshall" + (dim - 1), Stmt.loadVariable("a0", Stmt.loadVariable("i")), loadVariable("a1")))) .finish()) .append(Stmt.loadVariable("sb").invoke("append", "]").invoke("toString").returnValue()) .finish();
builder.privateField(proxyVar, toProxy).finish(); builder.privateField(stateVar, boolean.class).finish(); 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(); methodParms.add(Parameter.of(parameters[i].getType().getErased(), "a" + i)); .annotatedWith(OVERRIDE_ANNOTATION) .parameters(defParameters) .throws_(method.getCheckedExceptions()); statementVars[i] = loadVariable(parms.get(i).getName()); ifBody._(loadVariable("this").invoke(PrivateAccessUtil.getPrivateMethodName(method), privateAccessStmts)); ifBody._(loadVariable("this").invoke(PrivateAccessUtil.getPrivateMethodName(method), privateAccessStmts).returnValue()); ifBody._(loadVariable(proxyVar).invoke(method, statementVars).returnValue()); .annotatedWith(OVERRIDE_ANNOTATION) .annotatedWith(OVERRIDE_ANNOTATION) builder.publicMethod(void.class, PROXY_BIND_METHOD).parameters(DefParameters.of(Parameter.of(toProxy, "proxy")))
initMethod = classStructureBuilder.privateMethod(void.class, "lazyInit"); classStructureBuilder.publicMethod(arrayOfArrayType, "getEmptyArray") .append(Stmt.load(null).returnValue()) .finish(); final BlockBuilder<?> bBuilder = classStructureBuilder.publicMethod(arrayType, "demarshall", Parameter.of(EJValue.class, "a0"), Parameter.of(MarshallingSession.class, "a1")); bBuilder.append( If.isNull(loadVariable("a0")) .append(Stmt.load(null).returnValue()) .finish() .else_() .append(Stmt.nestedCall(Stmt.loadVariable("this")).invoke("_demarshall" + dimensions, Stmt.loadVariable("a0").invoke("isArray"), loadVariable("a1")).returnValue()) .finish()); bBuilder.finish(); final BlockBuilder<?> marshallMethodBlock = classStructureBuilder.publicMethod(String.class, "marshall", Parameter.of(toMap.asArrayOf(dimensions), "a0"), Parameter.of(MarshallingSession.class, "a1")); marshallMethodBlock.append(
@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(); }
.body(); builder.getClassDefinition().getContext().setPermissiveMode(true); builder.privateField(COMPARATOR_MAP_VAR, mapStringAnnoComp) .initializesWith(Stmt.newObject(mapStringAnnoComp)).finish(); final ConstructorBlockBuilder<? extends ClassStructureBuilder<?>> constrBuilder = builder.publicConstructor(); 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()) .finish() .else_() builder.publicMethod(int.class, "hashCodeOf", Parameter.of(Annotation.class, "a1")) .body() ._( If.cond(Stmt.loadVariable(COMPARATOR_MAP_VAR).invoke("containsKey",
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(); } }
classBuilder.publicMethod(ErraiEntityManager.class, "createEntityManager") .append( Stmt.nestedCall(Stmt.newObject(ErraiEntityManager.class, Stmt.loadVariable("this").invoke("createMetamodel"), Stmt.loadVariable("this").invoke("createNamedQueries"), Stmt.loadStatic(WebStorageBackend.class, "FACTORY"))) .returnValue()) .finish(); MethodCommentBuilder<?> cnqm = classBuilder.protectedMethod(Map.class, "createNamedQueries"); cnqm.append(Stmt.declareFinalVariable("namedQueries", Map.class, Stmt.newObject(HashMap.class))); MetaDataScanner scanner = ScannerSingleton.getOrCreateInstance(); cnqm._(Stmt.codeComment("**")); cnqm._(Stmt.codeComment("** NamedQuery \"" + namedQuery.name() + "\"")); cnqm._(Stmt.codeComment("** " + namedQuery.query())); cnqm._(Stmt.codeComment("**")); TypedQueryFactoryGenerator generator = new TypedQueryFactoryGenerator(em, namedQuery); Statement generatedFactory = generator.generate(classBuilder.getClassDefinition().getContext()); cnqm._(Stmt.loadVariable("namedQueries") .invoke("put", Stmt.loadLiteral(namedQuery.name()), generatedFactory)); cnqm.append(Stmt.loadVariable("namedQueries").returnValue()); cnqm.finish();
@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); }
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")))); getMarshallerMethod.append(getMarshallerConditional); getMarshallerMethod.append(Stmt.loadLiteral(null).returnValue()).finish(); 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();
private void appendPageShowingMethod(AnonymousClassStructureBuilder pageImplBuilder, MetaClass pageClass) { BlockBuilder<?> method = pageImplBuilder.publicMethod(void.class, createMethodNameFromAnnotation(PageShowing.class), Parameter.of(pageClass, "widget"), Parameter.of(HistoryToken.class, "state"), Parameter.of(NavigationControl.class, "control")) .body(); MetaMethod pageShowMethod = appendPageShowMethod(method, pageImplBuilder, pageClass, PageShowing.class, true, Parameter.of(HistoryToken.class, "state"), Parameter.of(NavigationControl.class, "control")); /* * If the user did not provide a control parameter, we must proceed for them after the method is invoked. */ if (pageShowMethod == null || pageShowMethod.getParameters().length != 2) { method.append(Stmt.loadVariable("control").invoke("proceed")); } method.finish(); }
private void implementGetContext(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(Context.class, "getProxyContext") .body() .append(loadVariable("proxyHelper").invoke("getProxyContext").returnValue()) .finish(); }
@Override public void makeConstructorAccessible(final ClassStructureBuilder<?> classBuilder, final MetaConstructor constructor) { final DefParameters methodDefParms = DefParameters.from(constructor); final String cachedMethod = initCachedMethod(classBuilder, constructor); final Object[] args = new Object[methodDefParms.getParameters().size()]; int i = 0; for (final Parameter p : methodDefParms.getParameters()) { args[i++] = Refs.get(p.getName()); } final BlockBuilder<? extends ClassStructureBuilder> body = classBuilder.publicMethod(constructor.getReturnType(), PrivateAccessUtil.getPrivateMethodName(constructor)) .parameters(methodDefParms) .modifiers(Modifier.Static) .body(); final Statement tryBuilder = Stmt.try_() .append( Stmt.nestedCall( Stmt.castTo(constructor.getReturnType(), Stmt.loadVariable(cachedMethod).invoke("newInstance", (Object) args))).returnValue()) .finish() .catch_(Throwable.class, "e") .append(Stmt.loadVariable("e").invoke("printStackTrace")) .append(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish(); body.append(tryBuilder).finish(); }
final MethodBlockBuilder<AnonymousClassStructureBuilder> isEqualBuilder = clsBuilder .publicMethod(boolean.class, "isEqual", Parameter.of(MC_annotationClass, "a1"), Parameter.of(MC_annotationClass, "a2")) .annotatedWith(new Override() { @Override public Class<? extends Annotation> annotationType() { isEqualBuilder._( If.not(Stmt.invokeStatic(Arrays.class, "equals", Stmt.loadVariable("a1").invoke(method), Stmt.loadVariable("a2").invoke(method)) ._(Stmt.load(false).returnValue()) .finish() ); If.not(Stmt.loadVariable("a1").invoke(method).invoke("equals", Stmt.loadVariable("a2").invoke(method))) ._(Stmt.load(false).returnValue()) .finish() = clsBuilder.publicOverridesMethod("hashCodeOf", Parameter.of(MC_annotationClass, "a1")); hashCodeOfBuilder._(Stmt.declareVariable(int.class).named("hash")
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())