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(); }
@Override protected List<Statement> generateCreateInstanceStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { final List<Statement> stmts = new ArrayList<>(); final String elementVar = "element"; stmts.add(declareFinalVariable(elementVar, Element.class, loadStatic(DomGlobal.class, "document").invoke("createElement", tagName))); for (final Property property : properties) { stmts.add(loadVariable(elementVar).invoke("setAttribute", loadLiteral(property.name()), loadLiteral(property.value()))); } if (!classNames.isEmpty()) { stmts.add(loadVariable(elementVar).loadField("className") .assignValue(loadLiteral(classNames.stream().collect(joining(" "))))); } final String retValVar = "retVal"; stmts.add(declareFinalVariable(retValVar, type, invokeStatic(Js.class, "cast", loadVariable(elementVar)))); if (implementsNativeHasValueAndRequiresGeneratedInvocation(type)) { stmts.add(Stmt.invokeStatic(NativeHasValueAccessors.class, "registerAccessor", loadVariable(retValVar), createAccessorImpl(type, retValVar))); } stmts.add(loadVariable(retValVar).returnValue()); return stmts; }
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(); }
protected void addReturnStatement(final List<Statement> createInstanceStatements) { createInstanceStatements.add(loadVariable("this").invoke("setIncompleteInstance", loadLiteral(null))); createInstanceStatements.add(loadVariable("instance").returnValue()); }
classStructureBuilder.publicMethod(arrayType, "getEmptyArray") .append(Stmt.loadClassMember("EMPTY_ARRAY").returnValue()) .finish(); builder.append(Stmt.loadVariable("this").invoke("lazyInit")); builder.append(Stmt.declareVariable(EJObject.class).named("obj") .initializeWith(loadVariable("a0").invoke("isObject"))); .invoke("get", SerializationParts.OBJECT_ID) .invoke("isString").invoke("stringValue"))); Stmt.if_(Bool.expr(loadVariable("a1").invoke("hasObject", loadVariable("objId")))) .append(loadVariable("a1") .invoke("getObject", toMap, loadVariable("objId")).returnValue()).finish()); deferred); constructorParameters[parmIndex] = Stmt.loadVariable(MarshallingGenUtil.getVarName(type)).invoke("demarshall", builder._(loadVariable("a1").invoke("recordObject", loadVariable("obj").invoke("keySet"))); .foreach("key", String.class) .append(Stmt.if_(Bool.or(loadVariable("key").invoke("equals", SerializationParts.ENCODED_TYPE), loadVariable("key").invoke("equals", SerializationParts.OBJECT_ID))) caseBlock.append(loadVariable("entity").loadField(field.getName()).assignValue(val))
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"))); .assignValue(demarshallerStatement); dmBuilder.append(Stmt.loadVariable("this").invoke("lazyInit")); dmBuilder.append(autoForLoop("i", Stmt.loadVariable("newArray").loadField("length")) .append(dim == 1 ? outerAccessorStatement : loadVariable("newArray", loadVariable("i")).assignValue( Stmt.loadVariable("this").invoke( "_demarshall" + (dim - 1), Stmt.loadVariable("a0").invoke("get", Stmt.loadVariable("i")).invoke("isArray"), .append(Stmt.loadVariable("newArray").returnValue()); mBuilder.append(Stmt.loadVariable("this").invoke("lazyInit")); .append(autoForLoop("i", Stmt.loadVariable("a0").loadField("length")) .append(Stmt.if_(Bool.greaterThan(Stmt.loadVariable("i"), 0)) .append(Stmt.loadVariable("sb").invoke("append", ",")).finish()) .append(Stmt.loadVariable("sb").invoke("append", dim == 1 ? Stmt.loadVariable(MarshallingGenUtil.getVarName(MetaClassFactory.get(Object.class))) .invoke("marshall", Stmt.loadVariable("this").invoke(
@Override protected List<Statement> generateCreateInstanceStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { final StatementBuilder anchorDeclaration = declareFinalVariable( "anchor", Anchor.class, castTo(Anchor.class, invokeStatic(Window.class, "getDocument") .invoke("createElement", "a"))); final ObjectBuilder clickListener = newObject(EventListener.class) .extend() .publicOverridesMethod("call", finalOf(Event.class, "event")) .append(navigationGoToInvocation(targetType)) .finish() .finish(); final ContextualStatementBuilder setClickListener = loadVariable("anchor").invoke("setOnclick", clickListener); final Statement returnValue = loadVariable("anchor").returnValue(); return Arrays.asList( anchorDeclaration, setClickListener, returnValue ); }
private void implementGetContext(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(Context.class, "getProxyContext") .body() .append(loadVariable("proxyHelper").invoke("getProxyContext").returnValue()) .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(); } }
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(); }
@Override public void createReadableField(final MetaClass type, final ClassStructureBuilder<?> classBuilder, final MetaField field, final Modifier[] modifiers) { final String cachedField = initCachedField(classBuilder, field); final String getterName = getReflectionFieldGetterName(field); final MethodCommentBuilder<? extends ClassStructureBuilder<?>> methodBuilder = classBuilder.privateMethod(field.getType().getErased(), PrivateAccessUtil.getPrivateFieldAccessorName(field)); if (!field.isStatic()) { methodBuilder.parameters( DefParameters.fromParameters( Parameter.of(field.getDeclaringClass().getErased(), "instance") ) ); } methodBuilder.modifiers(modifiers) .body() ._(Stmt.try_() ._(Stmt.nestedCall(Cast.to(field.getType().getErased(), Stmt.loadVariable(cachedField) .invoke(getterName, field.isStatic() ? null : Refs.get("instance")))).returnValue()) .finish() .catch_(Throwable.class, "e") ._(Stmt.loadVariable("e").invoke("printStackTrace")) ._(Stmt.throw_(RuntimeException.class, Refs.get("e"))) .finish()) .finish(); }
/** * Appends a method that destroys the IOC bean associated with a page node if the bean is * dependent scope. * * @param pageImplBuilder * The class builder for the implementation of PageNode we are adding the method to. * @param pageClass * The "content type" (Widget subclass) of the page. This is the type the user annotated * with {@code @Page}. */ private void appendDestroyMethod(AnonymousClassStructureBuilder pageImplBuilder, MetaClass pageClass) { BlockBuilder<?> method = pageImplBuilder.publicMethod( void.class, "destroy", Parameter.of(pageClass, "widget")).body(); if (pageClass.getAnnotation(Singleton.class) == null && pageClass.getAnnotation(ApplicationScoped.class) == null && pageClass.getAnnotation(EntryPoint.class) == null) { method.append(Stmt.loadVariable("bm").invoke("destroyBean", Stmt.loadVariable("widget"))); } method.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(); }
/** * 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); } }
public Statement extractJSONObjectProperty(final String fieldName, final MetaClass fromType) { if (fromType.getFullyQualifiedName().equals(EJObject.class.getName())) { return loadVariable("obj").invoke("get", fieldName); } else { return Stmt.nestedCall(Cast.to(fromType, loadVariable("a0"))).invoke("get", fieldName); } }
@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); }
final Statement result; if (methodReturnType.equals(MetaClassFactory.get(void.class))) { result = load(null).returnValue(); else if (methodReturnType.isAssignableTo(javax.ws.rs.core.Response.class)) { result = loadVariable("response").returnValue(); loadVariable("response").invoke("getText"), resourceMethod.getAcceptHeader()); result = if_(Bool.equals(loadVariable("response").invoke("getStatusCode"), 204)) .append(load(null).returnValue()) .finish() .else_() .append(nestedCall(demarshalStmt).returnValue()) .finish(); .newInstanceOf(ResponseDemarshallingCallback.class) .extend() .publicOverridesMethod("demarshallResponse", Parameter.of(Response.class, "response")) .append(result) .finish()
private static Object createAccessorImpl(final MetaClass type, final String varName) { final MetaClass propertyType = type.getMethod("getValue", new Class[0]).getReturnType(); return ObjectBuilder.newInstanceOf(NativeHasValueAccessors.Accessor.class) .extend() .publicMethod(Object.class, "get") .append(loadVariable(varName).invoke("getValue").returnValue()) .finish() .publicMethod(void.class, "set", finalOf(Object.class, "value")) .append(loadVariable(varName).invoke("setValue", castTo(propertyType, loadVariable("value")))) .finish() .finish(); } }