final long time = System.currentTimeMillis(); final MethodBlockBuilder<?> loadProxies = classBuilder.publicMethod(void.class, "loadProxies", Parameter.of(MessageBus.class, "bus", true)); if (remote.isInterface()) { 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));
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(); }
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(); } }
private Statement generateRequest(ClassStructureBuilder<?> classBuilder, MetaMethod method, Statement methodParams, boolean intercepted) { final Statement sendable = Stmt .invokeStatic(MessageBuilder.class, "createCall") .invoke("call", remote.getFullyQualifiedName()) .invoke("endpoint", ProxyUtil.createCallSignature(method), Stmt.loadClassMember("qualifiers"), methodParams) .invoke("respondTo", method.getReturnType().asBoxed(), Stmt.loadVariable("remoteCallback")) .invoke("errorsHandledBy", Stmt.loadVariable("errorCallback")); final BlockStatement requestBlock = new BlockStatement(); requestBlock.addStatement(Stmt.declareVariable("sendable", RemoteCallSendable.class, sendable)); requestBlock.addStatement(Stmt.loadStatic(classBuilder.getClassDefinition(), "this") .invoke("sendRequest", Variable.get("bus"), Variable.get("sendable"))); return requestBlock; } }
private void generateMethod(ClassStructureBuilder<?> classBuilder, MetaMethod method) { final List<Class<?>> interceptors = interceptorProvider.getInterceptors(remote, method); final boolean intercepted = !interceptors.isEmpty(); final Parameter[] parms = DefParameters.from(method).getParameters().toArray(new Parameter[0]); final Parameter[] finalParms = new Parameter[parms.length]; final List<Statement> parmVars = new ArrayList<Statement>(); for (int i = 0; i < parms.length; i++) { finalParms[i] = Parameter.of(parms[i].getType().getErased(), parms[i].getName(), true); parmVars.add(Stmt.loadVariable(parms[i].getName())); } final Statement parameters = (intercepted) ? new StringStatement("getParameters()", MetaClassFactory.get(Object[].class)) : Stmt.newArray(Object.class).initialize(parmVars.toArray()); final BlockBuilder<?> methodBlock = classBuilder.publicMethod(method.getReturnType().getErased(), method.getName(), finalParms); if (intercepted) { methodBlock.append(generateInterceptorLogic(classBuilder, method, generateRequest(classBuilder, method, parameters, true), parmVars, interceptors)); } else { methodBlock.append(generateRequest(classBuilder, method, parameters, false)); } final Statement returnStmt = ProxyUtil.generateProxyMethodReturnStatement(method); if (returnStmt != null) { methodBlock.append(returnStmt); } methodBlock.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 ); }
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 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); } }
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(); }
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); } }
private void implementUnwrappedInstance(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(Object.class, "unwrap") .body() .append(loadVariable("proxyHelper").invoke("getInstance", loadVariable("this")).returnValue()) .finish(); }
private Statement createJsTypeProviderFor(final Injectable injectable) { final MetaClass type = injectable.getInjectedType(); final AnonymousClassStructureBuilder jsTypeProvider = newInstanceOf(parameterizedAs(JsTypeProvider.class, typeParametersOf(type))).extend(); jsTypeProvider .publicOverridesMethod("getInstance") .append(Stmt.castTo(type, loadVariable("contextManager").invoke("getInstance", injectable.getFactoryName())) .returnValue()).finish() .publicOverridesMethod("getName") .append(Stmt.loadLiteral(getBeanName(injectable)).returnValue()) .finish() .publicOverridesMethod("getFactoryName") .append(Stmt.loadLiteral(injectable.getFactoryName()).returnValue()) .finish() .publicOverridesMethod("getQualifiers") .append(Stmt.nestedCall(Stmt.newObject(parameterizedAs(JsArray.class, typeParametersOf(String.class)), Stmt.loadLiteral(AnnotationSerializer.serialize(injectable.getQualifier().iterator())))).returnValue()) .finish(); return jsTypeProvider.finish(); }
private void implementSetContext(final ClassStructureBuilder<?> proxyImpl, final Injectable injectable) { proxyImpl.publicMethod(void.class, "setProxyContext", finalOf(Context.class, "context")) .body() .append(loadVariable("proxyHelper").invoke("setProxyContext", loadVariable("context"))) .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(); }
private Object createHandlerForMethod(final MetaMethod method) { return ObjectBuilder .newInstanceOf(PropertyChangeHandler.class) .extend() .publicOverridesMethod("onPropertyChange", finalOf(PropertyChangeEvent.class, "event")) .append(castTo(method.getDeclaringClass(), loadVariable("agent").loadField("target")).invoke(method, loadVariable("event"))) .finish() .finish(); }
public Statement unwrapJSON(final Statement valueStatement, final MetaClass toType, final MetaClass targetType) { if (toType.isEnum()) { return demarshallEnum(Stmt.nestedCall(valueStatement).invoke("isObject"), valueStatement, toType); } else { final String varName = MarshallingGenUtil.getVarName(toType); if (toType.equals(MetaClassFactory.get(Object.class))) { return Stmt.castTo(ObjectMarshaller.class, Stmt.loadVariable(varName)) .invoke("demarshall", targetType.asClass(), valueStatement, loadVariable("a1")); } return Stmt.loadVariable(varName) .invoke("demarshall", valueStatement, loadVariable("a1")); } }
private Statement generateFactoryLoader(final Injectable injectable, final MetaClass factoryClass) { final Statement runAsyncCallback = ObjectBuilder.newInstanceOf(DefaultRunAsyncCallback.class).extend() .publicOverridesMethod("onSuccess").append(loadVariable("callback").invoke("callback", castTo(Factory.class, invokeStatic(GWT.class, "create", loadLiteral(factoryClass))))) .finish().finish(); final Class<?> fragmentId = getAsyncFragmentId(injectable); final Object[] runAsyncParams = (fragmentId.equals(LoadAsync.NO_FRAGMENT.class) ? new Object[] { runAsyncCallback } : new Object[] { fragmentId, runAsyncCallback }); return ObjectBuilder.newInstanceOf(FactoryLoader.class).extend() .publicOverridesMethod("call", finalOf(FactoryLoaderCallback.class, "callback")) .append(invokeStatic(GWT.class, "runAsync", runAsyncParams)).finish().finish(); }
private static ObjectBuilder anonymousAttributeAccessorFor(final MetaMethod attr) { return newInstanceOf(Function.class).extend() .publicOverridesMethod("apply", Parameter.finalOf(Object.class, "anno")) .append(invokeStatic(SharedAnnotationSerializer.class, "stringify", castTo(attr.getDeclaringClass(), loadVariable("anno")).invoke(attr)) .returnValue()) .finish().finish(); }