/** * @return A statement for getting an instance of the type produced by this * factory in * {@link Factory#init(org.jboss.errai.ioc.client.container.Context)}. */ public Statement contextGetInstanceStmt() { return castTo(producedType, loadVariable("context").invoke("getInstance", factoryName)); }
/** * @param instanceStmt * The statement for the instance that will be the first parameter to * {@link ContextManager#getInstanceProperty(Object, String, Class)}. * @param name * The name of the property. * @param refType * The type of the property. * @return A statement that looks up a property of an instance from another * factory via * {@link ContextManager#getInstanceProperty(Object, String, Class)}. */ public ContextualStatementBuilder getInstancePropertyStmt(final Statement instanceStmt, final String name, final Class<?> refType) { return Stmt.castTo(refType, loadVariable("contextManager").invoke("getInstanceProperty", instanceStmt, name, refType)); }
@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); } }
/** * Generates code to call * {@link Factory#getReferenceAs(Object, String, Class)} for an instance in * {@link Factory#createInstance(org.jboss.errai.ioc.client.container.ContextManager)} * and * {@link Factory#destroyInstance(Object, org.jboss.errai.ioc.client.container.ContextManager)} * methods. */ public static ContextualStatementBuilder constructGetReference(final String name, final Class<?> refType) { // This cast is for the benefit of codegen, which is sometimes unable to // identify the value for the type parameter of Factory.getReferenceAs. return castTo(refType, loadVariable("thisInstance").invoke("getReferenceAs", loadVariable("instance"), name, refType)); }
private ContextualStatementBuilder addHandler(final String handlerVar) { return castTo(ErraiUncaughtExceptionHandler.class, invokeStatic(GWT.class, "getUncaughtExceptionHandler")) .invoke("addHandler", Refs.get(handlerVar)); }
protected ContextualStatementBuilder lookupProviderStmt(final Injectable providerInjectable, final MetaClass paramterizedProviderType) { final ContextualStatementBuilder provider = castTo(paramterizedProviderType, loadVariable("contextManager").invoke("getInstance", loadLiteral(providerInjectable.getFactoryName()))); return provider; }
@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()); }
/** * Generates code to call * {@link Factory#getReferenceAs(Object, String, Class)} for an instance in * {@link Factory#createInstance(org.jboss.errai.ioc.client.container.ContextManager)} * and * {@link Factory#destroyInstance(Object, org.jboss.errai.ioc.client.container.ContextManager)} * methods. */ public static ContextualStatementBuilder constructGetReference(final String name, final MetaClass refType) { // This cast is for the benefit of codegen, which is sometimes unable to // identify the value for the type parameter of Factory.getReferenceAs. return castTo(refType, loadVariable("thisInstance").invoke("getReferenceAs", loadVariable("instance"), name, loadLiteral(refType))); }
@Override protected List<Statement> generateDestroyInstanceStatements(final ClassStructureBuilder<?> bodyBlockBuilder, final Injectable injectable, final DependencyGraph graph, final InjectionContext injectionContext) { final Injectable provider = getProviderInjectable(injectable); if (provider.getInjectedType().isAssignableTo(Disposer.class)) { return singletonList(castTo(Disposer.class, loadVariable("this").invoke("getReferenceAs", loadVariable("instance"), "disposer", Disposer.class)) .invoke("dispose", loadVariable("instance"))); } else { return emptyList(); } }
@SuppressWarnings("unchecked") private void declareAsyncBeanManagerSetupField(final IOCProcessingContext processingContext) { processingContext.getBootstrapBuilder() .privateField("asyncBeanManagerSetup", AsyncBeanManagerSetup.class) .initializesWith(castTo(AsyncBeanManagerSetup.class, invokeStatic(IOC.class, "getAsyncBeanManager"))) .finish(); }
private void registerFactoryWithContext(final Injectable injectable, final MetaClass factoryClass, final Map<Class<? extends Annotation>, MetaClass> scopeContexts, @SuppressWarnings("rawtypes") final BlockBuilder registerFactoriesBody) { final Class<? extends Annotation> scope = injectable.getScope(); final MetaClass injectedType = injectable.getInjectedType(); final MetaClass scopeContextImpl = Assert.notNull("No scope context for " + scope.getSimpleName(), scopeContexts.get(scope)); final String contextVarName = getContextVarName(scopeContextImpl); registerFactoriesBody.append(loadVariable(contextVarName).invoke("registerFactory", Stmt.castTo(parameterizedAs(Factory.class, typeParametersOf(injectedType)), invokeStatic(GWT.class, "create", factoryClass)))); }
private ObjectBuilder createAnnoImpl(final MetaClass annoType) { final AnonymousClassStructureBuilder builder = ObjectBuilder.newInstanceOf(annoType).extend(); Arrays.stream(annoType.getDeclaredMethods()) .forEach(m -> builder.publicOverridesMethod(m.getName()) .append(castTo(m.getReturnType(), loadVariable("parameters").invoke("get", m.getName())).returnValue()).finish()); builder.publicOverridesMethod("annotationType").append(loadLiteral(annoType).returnValue()).finish(); return builder.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 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(); }
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(); }
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(); }
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 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 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 declareAndInitHandlerVar(final Decorable decorable, final FactoryController controller, final String name, final boolean enclosingTypeDependent) { final MetaClass throwableConsumerClass = parameterizedAs(Consumer.class, typeParametersOf(Throwable.class)); final BlockBuilder<AnonymousClassStructureBuilder> initBuilder = newObject(throwableConsumerClass) .extend().publicOverridesMethod("accept", Parameter.of(Throwable.class, "t")); if (!enclosingTypeDependent) { final MetaClass enclosingType = decorable.getEnclosingInjectable().getInjectedType(); initBuilder.append(declareFinalVariable("instance", enclosingType, castTo(enclosingType, invokeStatic(Factory.class, "maybeUnwrapProxy", controller.contextGetInstanceStmt())))); } final ObjectBuilder initStmt = initBuilder.append(decorable.call(Refs.get("t"))).finish().finish(); final Statement handlerStatement = declareFinalVariable(name, throwableConsumerClass, initStmt); return handlerStatement; } }