/** * 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); } }
private ContextualStatementBuilder agent(final String field) { return agent().loadField(field); }
@Override public String generate(Context context) { if (param instanceof Parameter) { return Stmt.castTo(PathSegmentImpl.class, Stmt.loadVariable(((Parameter) param).getName())) .invoke("getEncodedPathWithParameters").generate(context); } else { return Stmt.castTo(PathSegmentImpl.class, param).invoke("getEncodedPathWithParameters").generate(context); } }
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(); }
@Override protected List<Statement> generateCreateInstanceStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { return Collections.<Statement> singletonList( Stmt.castTo(injectable.getInjectedType(), invokeStatic(WindowInjectionContextStorage.class, "createOrGet") .invoke("getBean", injectable.getInjectedType().getFullyQualifiedName())).returnValue()); }
return Stmt.newObject(callContextType).extend() .publicOverridesMethod("getMethodName") .append(Stmt.load(method.getName()).returnValue()) .finish() .publicOverridesMethod("getReturnType") .append(Stmt.load(method.getReturnType()).returnValue()) .append(Stmt.load(filter(method.getAnnotations(), translatablePackages)).returnValue()) Stmt.load(filter(method.getDeclaringClass().getAnnotations(), translatablePackages)).returnValue()) .append(Stmt.load(null).returnValue()) .finish() .publicOverridesMethod("proceed", Parameter.of(RemoteCallback.class, "interceptorCallback", true)) .append(Stmt.declareVariable(RemoteCallback.class).asFinal().named("providedCallback").initializeWith( Stmt.loadStatic(proxyClass, "this").loadField("remoteCallback"))) .append( Stmt.loadVariable("remoteCallback").assignValue(Stmt.newObject(RemoteCallback.class).extend() .publicOverridesMethod("callback", Parameter.of(Object.class, "response")) Stmt.loadStatic(proxyClass, "this").loadField("errorCallback"))) .append(Stmt.load(false).returnValue()) Variable.get("message"), Variable.get("throwable"))) .returnValue()) .finish()) .append(Stmt.load(true).returnValue())
"The event argument of %s.%s must specify event types " + "either with @%s on the call site or @%s on the event type.", declaringClass.getName(), method.getName(), ForEvent.class.getSimpleName(), BrowserEvent.class.getSimpleName())))); .newInstanceOf(org.jboss.errai.common.client.dom.EventListener.class) .extend() .publicOverridesMethod("call", Parameter.of(org.jboss.errai.common.client.dom.Event.class, "event")) .append(InjectUtil .invokePublicOrPrivateMethod(controller, method, invokeStatic(Js.class, "cast", loadVariable("event")))) .finish() .finish(); final ContextualStatementBuilder elementStmt; if (dataFieldTypes.containsKey(dataFieldName) && !"this".equals(dataFieldName)) { final MetaClass fieldType = dataFieldTypes.get(dataFieldName); if (fieldType.isAssignableTo(Widget.class)) { elementStmt = castTo(Widget.class, nestedCall(fieldsMap).invoke("get", dataFieldName)); elementStmt = nestedCall(fieldsMap).invoke("get", dataFieldName); elementStmt = loadVariable(dataFieldElementsVarName).invoke("get", dataFieldName); final String listenerVarName = "listenerFor" + eventType.getName() + "Calling" + capitalize(method.getName());
final String targetVar = "t"; final BlockStatement block = new BlockStatement(); block.addStatement(Stmt.declareFinalVariable(cloneVar, bindable, Stmt.newObject(bindable))); block.addStatement(Stmt.declareFinalVariable(targetVar, bindable, Stmt.loadVariable("this").invoke("unwrap"))); for (final String property : bindable.getBeanDescriptor().getProperties()) { final MetaMethod readMethod = bindable.getBeanDescriptor().getReadMethodForProperty(property); final MetaMethod writeMethod = bindable.getBeanDescriptor().getWriteMethodForProperty(property); if (readMethod != null && writeMethod != null && readMethod.isPublic() && writeMethod.isPublic()) { final MetaClass type = readMethod.getReturnType(); if (!DataBindingUtil.isBindableType(type)) { loadVariable(targetVar).invoke(readMethod))); colBlock.append(Stmt.declareFinalVariable(colVarName, type.getErased(), Stmt.newObject(clazz))); colBlock.append(Stmt.declareFinalVariable(colVarName, type.getErased(), Stmt.newObject(type.getErased()))); colBlock.append( Stmt.nestedCall(loadVariable(targetVar).invoke(readMethod)).foreach(elemVarName, Object.class) .invoke("add", Stmt.castTo(BindableProxy.class, Stmt.loadVariable(elemVarName)).invoke(methodName)) Stmt.castTo(BindableProxy.class, Stmt.loadVariable("this").invoke(readMethod)).invoke(methodName) "getBindableProxy", loadVariable(targetVar).invoke(readMethod))).invoke(methodName)
method.append(Stmt.declareFinalVariable("pageState", Map.class, new HashMap<String, Object>())); for (MetaField field : pageClass.getFieldsAnnotatedWith(PageState.class)) { PageState psAnno = field.getAnnotation(PageState.class); String fieldName = field.getName(); MetaClass erasedFieldType = field.getType().getErased(); if (erasedFieldType.isAssignableTo(Collection.class)) { MetaClass elementType = MarshallingGenUtil.getConcreteCollectionElementType(field.getType()); if (elementType == null) { method.append(Stmt.declareVariable(fieldName, Stmt.newObject(HashSet.class))); method.append(Stmt.declareVariable(fieldName, Stmt.newObject(ArrayList.class))); Stmt.loadVariable("state").invoke("getState").invoke("get", queryParamName).foreach("elem", Object.class) Stmt.loadVariable(fieldName).invoke("add", Stmt.loadVariable("pageState").invoke( "getState").invoke("get", queryParamName))); method.append( If.cond( .invoke("next")))) "put", fieldName, Stmt.loadVariable("fv" + idx).invoke("iterator").invoke("next")))
Parameter.of(String.class, "property")); Parameter.of(String.class, "property"), Parameter.of(Object.class, "value")); CaseBlockBuilder getSwitchBlock = Stmt.switch_(loadVariable("property")); CaseBlockBuilder setSwitchBlock = Stmt.switch_(loadVariable("property")); for (final String property : bindable.getBeanDescriptor().getProperties()) { generateGetter(classBuilder, property, getSwitchBlock); 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(); .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();
.define("Dynamic" + fullyQualifiedClassNameToCamelCase(validator.getFullyQualifiedName()), validator) .publicScope() .implementsInterface(parameterizedAs(GeneratedDynamicValidator.class, typeParametersOf(valueType))) finalOf(parameterizedAs(Map.class, typeParametersOf(String.class, Object.class)), "parameters"), finalOf(valueType, "value")) .body(); .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();
if (!method.isStatic()) { 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)) .body(); final BlockBuilder<CatchBlockBuilder> tryBuilder = Stmt.try_(); final ContextualStatementBuilder statementBuilder = Stmt.loadVariable(cachedMethod) .invoke("invoke", method.isStatic() ? null : Refs.get("instance"), args); if (method.getReturnType().isVoid()) { 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())
@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 ); }
final MethodBlockBuilder<AnonymousClassStructureBuilder> isEqualBuilder = clsBuilder .publicMethod(boolean.class, "isEqual", Parameter.of(MC_annotationClass, "a1"), Parameter.of(MC_annotationClass, "a2")) .annotatedWith(new Override() { @Override if (method.getReturnType().isPrimitive()) { isEqualBuilder._( If.notEquals(Stmt.loadVariable("a1").invoke(method), Stmt.loadVariable("a2").invoke(method)) ._(Stmt.load(false).returnValue()) .finish() ); ._(Stmt.load(false).returnValue()) .finish() ); If.not(Stmt.loadVariable("a1").invoke(method).invoke("equals", Stmt.loadVariable("a2").invoke(method))) ._(Stmt.load(false).returnValue()) .finish() ); isEqualBuilder._(Stmt.load(true).returnValue()); = clsBuilder.publicOverridesMethod("hashCodeOf", Parameter.of(MC_annotationClass, "a1")); hashCodeOfBuilder._(Stmt.declareVariable(int.class).named("hash") .initializeWith(Stmt.loadVariable("a1").invoke("annotationType").invoke("hashCode")));
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; }
final long time = System.currentTimeMillis(); final MethodBlockBuilder<?> loadProxies = classBuilder.publicMethod(void.class, "loadProxies", Parameter.of(MessageBus.class, "bus", true)); if (remote.isInterface()) { .extend() .publicOverridesMethod("getProxy") .append(Stmt.nestedCall(Stmt.newObject(remoteProxy.getClassDefinition())).returnValue()) .finish() .finish(); loadProxies.append(Stmt.invokeStatic(RemoteServiceProxyFactory.class, "addRemoteProxy", remote, proxyProvider));
private BlockBuilder<ElseBlockBuilder> updateGetMarshallerConditionalBlock(BlockBuilder<ElseBlockBuilder> getMarshallerConditionalBlock, final String helperMethodName) { getMarshallerConditionalBlock = getMarshallerConditionalBlock.finish().elseif_(StringStatement.of(helperMethodName + "(a0)", boolean.class)) .append(Stmt.loadVariable(MARSHALLERS_VAR).invoke("get", Stmt.loadVariable("a0")).returnValue()); return getMarshallerConditionalBlock; }
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(); } }
statements.add(Stmt.declareFinalVariable("objectClass", Class.class, Stmt.loadLiteral(Object.class))); Stmt.newObject(QueryParamInitCallback.class).extend().publicOverridesMethod("getQueryParams"); queryParamCallback.append(Stmt.declareFinalVariable("paramsMap", Map.class, Stmt.newObject(HashMap.class))); if (val.startsWith("{") && val.endsWith("}")) { String fieldName = val.substring(1, val.length() - 1); MetaField field = decorable.getDecorableDeclaringType().getInheritedField(fieldName); fieldValueStmt = InjectUtil.getPublicOrPrivateFieldValue(controller, field); fieldValueStmt = Stmt.loadLiteral(val); queryParamCallback.append(Stmt.loadVariable("paramsMap").invoke("put", param.name(), fieldValueStmt)); queryParamCallback.append(Stmt.loadVariable("paramsMap").returnValue()); statements.add(Stmt.declareFinalVariable("paramsCallback", Stmt.nestedCall(syncWorkerRef).invoke("addSyncCallback", createSyncCallback(decorable))); statements.add( Stmt.nestedCall(syncWorkerRef).invoke("start", Refs.get("instance"), Stmt.loadVariable("paramsCallback")));
final MetaClass methodReturnType = resourceMethod.getMethod().getReturnType(); 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()