How to use

ContextualStatementBuilder

in

org.jboss.errai.codegen.builder

/**
 * 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()