Example usage for com.google.gwt.core.ext RebindMode USE_EXISTING

List of usage examples for com.google.gwt.core.ext RebindMode USE_EXISTING

  1. HOME
  2. Java
  3. com.google.gwt
  4. com.google.gwt.core.ext.*
  5. RebindMode
  6. USE_EXISTING

Introduction

In this page you can find the example usage for com.google.gwt.core.ext RebindMode USE_EXISTING.

Prototype

RebindMode USE_EXISTING

To view the source code for com.google.gwt.core.ext RebindMode USE_EXISTING.

Click Source Link

Document

Indicates no generated code is needed to satisfy this rebind.

Usage

From source file:com.guit.rebind.common.AbstractGenerator.java

License:Apache License

@Override
public RebindResult generateIncrementally(TreeLogger logger, GeneratorContext context, String typeName)
        throws UnableToCompleteException {
    saveVariables(logger, context, typeName);

    baseClass = getType(typeName);/* w  ww. j  a va 2  s .  c om*/
    generatedPackage = baseClass.getPackage().getName();
    implName = baseClass.getSimpleSourceName() + implementationPostfix;
    implName = processImplName(implName);
    JClassType enclosingType = baseClass.getEnclosingType();
    if (enclosingType != null) {
        implName = enclosingType.getSimpleSourceName() + implName;
    }

    RebindMode rebindMode = context.isGeneratorResultCachingEnabled() ? rebindMode()
            : RebindMode.USE_ALL_NEW_WITH_NO_CACHING;
    if (rebindMode.equals(RebindMode.USE_ALL_CACHED) || rebindMode.equals(RebindMode.USE_EXISTING)) {
        return new RebindResult(rebindMode, generatedPackage + "." + implName);
    }

    ClassSourceFileComposerFactory composer = createComposer();
    processComposer(composer);
    createdClassName = composer.getCreatedClassName();
    PrintWriter printWriter = createPrintWriter();
    if (printWriter != null) {
        SourceWriter writer = composer.createSourceWriter(context, printWriter);
        generate(writer);

        writer.commit(logger);
    }

    RebindResult result = new RebindResult(rebindMode, composer.getCreatedClassName());
    saveClientData(result);
    return result;
}

From source file:com.guit.rebind.gin.GinInjectorGenerator.java

License:Apache License

@Override
public RebindResult generateIncrementally(TreeLogger logger, GeneratorContext context, String typeName)
        throws UnableToCompleteException {
    saveVariables(logger, context, typeName);
    if (typeOracle.findType(GinOracle.packageName, GinOracle.className) != null) {
        return new RebindResult(RebindMode.USE_EXISTING, GinOracle.packageName + "." + GinOracle.className);
    }/* www. j a  v  a2  s  .  c om*/

    // Clear
    injectedClasses.clear();
    providedClasses.clear();
    asyncProvidedClasses.clear();
    gmodules.clear();

    // Call gin contributors
    List<String> contributors = getConfigurationProperty("app.gin.contributor").getValues();
    for (String c : contributors) {
        GinContributor contributor = instantiateContributor(c);
        contributor.collaborate(this, logger, context);
    }

    // Generate the modules string
    StringBuilder sb = new StringBuilder();
    sb.append("({");
    for (Class<?> m : gmodules) {
        if (sb.length() > 2) {
            sb.append(", ");
        }
        sb.append(m.getCanonicalName() + ".class");
    }
    sb.append("})");

    GinOracle.setModules(gmodules);

    ClassSourceFileComposerFactory composer = new ClassSourceFileComposerFactory(GinOracle.packageName,
            GinOracle.className);
    composer.makeInterface();
    composer.addImplementedInterface(Ginjector.class.getCanonicalName());
    composer.addAnnotationDeclaration("@" + GinModules.class.getCanonicalName() + sb.toString());
    PrintWriter printWriter = context.tryCreate(logger, GinOracle.packageName, GinOracle.className);

    // Convert to linked to remove possible duplicated entries
    injectedClasses = findClassOrLinkedInjectionKey(injectedClasses);
    providedClasses = findClassOrLinkedInjectionKey(providedClasses);
    asyncProvidedClasses = findClassOrLinkedInjectionKey(asyncProvidedClasses);

    if (printWriter != null) {
        SourceWriter writer = composer.createSourceWriter(context, printWriter);

        writer.println(SINGLETON_DECLARATION);

        for (String classType : injectedClasses) {
            load(classType);
            writer.println(classType + " " + GinOracle.getGetterMethodName(classType) + "();");
        }

        for (String classType : providedClasses) {
            load(classType);
            writer.println(Provider.class.getCanonicalName() + "<" + classType + "> "
                    + GinOracle.getProviderGetterMethodName(classType) + "();");
        }

        for (String classType : asyncProvidedClasses) {
            load(classType);
            writer.println(AsyncProvider.class.getCanonicalName() + "<" + classType + "> "
                    + GinOracle.getAsyncProviderGetterMethodName(classType) + "();");
        }

        writer.commit(logger);
    }

    return new RebindResult(RebindMode.USE_PARTIAL_CACHED, GinOracle.packageName + "." + GinOracle.className);
}

From source file:com.mvp4g.rebind.Mvp4gGenerator.java

License:Apache License

private RebindResult create(TreeLogger logger, GeneratorContext context, String moduleName)
        throws UnableToCompleteException {

    Date start = new Date();

    String generatedClassQualifiedName;

    try {//  ww  w . java  2s  . c om
        TypeOracle typeOracle = context.getTypeOracle();

        JClassType module = typeOracle.findType(moduleName);
        if (module == null) {
            logger.log(TreeLogger.ERROR, "Unable to find metadata for type '" + moduleName + "'", null);
            throw new UnableToCompleteException();
        }

        @SuppressWarnings("unchecked")
        Map<Class<? extends Annotation>, List<JClassType>> scanResult = AnnotationScanner.scan(logger,
                typeOracle, new Class[] { Presenter.class, History.class, Events.class, Service.class,
                        EventHandler.class });

        Mvp4gConfiguration configuration = new Mvp4gConfiguration(logger, context);

        String suffix = "Impl" + configuration.load(module, scanResult);

        generatedClassQualifiedName = module.getParameterizedQualifiedSourceName() + suffix;

        String packageName = module.getPackage().getName();
        String originalClassName = module.getSimpleSourceName();
        String generatedClassName = originalClassName + suffix;

        // check weather there is a usual version or not.
        if (checkAlreadyGenerated(logger, context, configuration)) {
            // Log
            logger.log(TreeLogger.INFO, "Reuse already generated files", null);
            // stop generating
            return new RebindResult(RebindMode.USE_EXISTING, packageName + "." + generatedClassName);
        }

        // Log
        logger.log(TreeLogger.INFO, "Start generate files ... ", null);

        // No, there is non. Create a new one.
        SourceWriter sourceWriter = getSourceWriter(logger, context, module, packageName, generatedClassName);

        if (sourceWriter != null) {
            logger.log(TreeLogger.INFO, "Generating source for " + generatedClassQualifiedName + " ", null);
            Mvp4gConfigurationFileWriter writer = new Mvp4gConfigurationFileWriter(sourceWriter, configuration);
            writer.writeConf();
            sourceWriter.commit(logger);
        } else {
            // don't expect this to occur, but could happen if an instance was
            // recently generated but not yet committed
            new RebindResult(RebindMode.USE_EXISTING, generatedClassQualifiedName);
        }

        Date end = new Date();

        logger.log(TreeLogger.INFO, "Mvp4g Compilation: " + (end.getTime() - start.getTime()) + "ms.");

        return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING, packageName + "." + generatedClassName);
    } catch (InvalidMvp4gConfigurationException e) {
        logger.log(TreeLogger.ERROR, e.getMessage(), e);
        throw new UnableToCompleteException();
    }
}

From source file:com.mvp4g.rebind.Mvp4gRunAsyncGenerator.java

License:Apache License

private RebindResult create(JClassType originalType, TreeLogger logger, GeneratorContext context,
        String typeName) throws UnableToCompleteException {

    Date start = new Date();

    String packageName = originalType.getPackage().getName();
    String originalClassName = originalType.getSimpleSourceName();
    String generatedClassName = originalClassName + "Impl";
    String generatedClassQualifiedName = packageName + "." + generatedClassName;

    // check weather there is a usual version or not.
    if (checkAlreadyGenerated(logger, context, generatedClassQualifiedName)) {
        // Log//  w  w  w . j  a v a  2  s  .  co  m
        logger.log(TreeLogger.INFO, "reuse already generated files", null);
        // stop generating
        return new RebindResult(RebindMode.USE_EXISTING, generatedClassQualifiedName);
    }

    logger.log(TreeLogger.INFO, "Generating writer for " + packageName + "." + generatedClassName, null);

    PrintWriter printWriter = context.tryCreate(logger, packageName, generatedClassName);

    ClassSourceFileComposerFactory classFactory = new ClassSourceFileComposerFactory(packageName,
            generatedClassName);

    classFactory.addImplementedInterface(originalType.getName());
    String[] classesToImport = getClassesToImport();
    for (String classToImport : classesToImport) {
        classFactory.addImport(classToImport);
    }

    if (printWriter != null) {
        SourceWriter sourceWriter = classFactory.createSourceWriter(context, printWriter);
        logger.log(TreeLogger.INFO, "Generating source for " + generatedClassQualifiedName + " ", null);
        writeClass(sourceWriter, getRunAsync(originalType));
        sourceWriter.commit(logger);
    }

    Date end = new Date();

    logger.log(TreeLogger.INFO, "Mvp4g Module Cretor: " + (end.getTime() - start.getTime()) + "ms.");

    return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING, generatedClassQualifiedName);
}

From source file:com.seanchenxi.gwt.storage.rebind.StorageTypeSerializerGenerator.java

License:Apache License

@Override
public RebindResult generateIncrementally(TreeLogger logger, GeneratorContext context, String typeName)
        throws UnableToCompleteException {
    TypeOracle typeOracle = context.getTypeOracle();

    JClassType serializerType = typeOracle.findType(typeName);
    if (serializerType == null || serializerType.isInterface() == null)
        throw new UnableToCompleteException();

    final Set<JType> serializables = StorageTypeFinder.getInstance(context, logger).findStorageTypes();

    String typeSerializerClassName = serializerType.getQualifiedSourceName() + TYPE_SERIALIZER_SUFFIX;
    String typeSerializerSimpleName = serializerType.getSimpleSourceName() + TYPE_SERIALIZER_SUFFIX;
    JClassType typeSerializer = typeOracle.findType(typeSerializerClassName);

    SerializableTypeOracle serializationOracle = buildSerializableTypeOracle(logger, context, serializables);

    if (typeSerializer != null && typeSerializer.isClass() != null
            && isNothingChanged(logger, context, serializables, serializationOracle)) {
        return new RebindResult(RebindMode.USE_EXISTING, typeSerializerClassName);
    }/* w ww .  jav a2s . c o  m*/

    TypeSerializerCreator tsc = new TypeSerializerCreator(logger, serializationOracle, serializationOracle,
            context, typeSerializerClassName, typeSerializerSimpleName);
    tsc.realize(logger);

    if (context.isGeneratorResultCachingEnabled()) {
        RebindResult result = new RebindResult(RebindMode.USE_PARTIAL_CACHED, typeSerializerClassName);
        CachedRpcTypeInformation cti = new CachedRpcTypeInformation(serializationOracle, serializationOracle,
                serializables, new HashSet<JType>());
        result.putClientData(ProxyCreator.CACHED_TYPE_INFO_KEY, cti);
        return result;
    } else {
        return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING, typeSerializerClassName);
    }
}

From source file:org.cruxframework.crux.core.rebind.AbstractGenerator.java

License:Apache License

@Override
public RebindResult generateIncrementally(TreeLogger logger, GeneratorContext context, String typeName)
        throws UnableToCompleteException {
    TypeOracle typeOracle = context.getTypeOracle();
    assert (typeOracle != null);

    JClassType baseIntf = typeOracle.findType(typeName);
    if (baseIntf == null) {
        logger.log(TreeLogger.ERROR, "Unable to find source for type [" + typeName + "]", null);
        throw new UnableToCompleteException();
    }//from  w  w w.j a v a2 s  .c  om

    AbstractProxyCreator proxy = createProxy(logger, context, baseIntf);
    String returnType = proxy.create();
    if (returnType == null) {
        return new RebindResult(RebindMode.USE_EXISTING, typeName);
    } else if (proxy.isCacheable()) {
        return new RebindResult(RebindMode.USE_PARTIAL_CACHED, returnType);
    } else {
        return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING, returnType);
    }
}

From source file:org.cruxframework.crux.core.rebind.rpc.CruxProxyCreator.java

License:Apache License

/**
 * @param logger//from  w ww.  j  av a  2 s .co m
 * @param context
 * @param asyncServiceTypeName
 * @return
 * @throws UnableToCompleteException 
 */
private RebindResult createAsyncWrapper(GeneratorContext context, String asyncServiceTypeName)
        throws UnableToCompleteException {
    JClassType serviceAsync = context.getTypeOracle().findType(serviceIntf.getQualifiedSourceName() + "Async");
    String asyncWrapperName = getProxyWrapperQualifiedName();

    if (checkAlreadyGenerated(context, asyncWrapperName)) {
        return new RebindResult(RebindMode.USE_EXISTING, asyncWrapperName);
    }

    SourceWriter srcWriter = getSourceWriter(logger, context, asyncServiceTypeName, asyncWrapperName);
    if (srcWriter == null) {
        return new RebindResult(RebindMode.USE_EXISTING, asyncWrapperName);
    }

    generateWrapperProxyFields(srcWriter, asyncServiceTypeName);

    generateWrapperProxyContructor(srcWriter);

    generateProxyWrapperMethods(srcWriter, serviceAsync);

    if (this.hasSyncTokenMethod) {
        generateProxyWrapperStartMethod(srcWriter);

        generateProxyWrapperEndMethod(srcWriter);

        generateProxyWrapperUpdateTokenMethod(srcWriter);

        generateSetServiceEntryPointMethod(srcWriter);
    }

    srcWriter.commit(logger);

    return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING, asyncWrapperName);
}

From source file:org.cruxframework.crux.plugin.gadget.rebind.rpc.CruxGadgetProxyCreator.java

License:Apache License

/**
 * @param logger/*from w w w  .  j  av a2 s.  c o m*/
 * @param context
 * @param cruxServiceTypeName
 * @return
 * @throws UnableToCompleteException 
 */
private RebindResult createGadgetWrapper(GeneratorContext context, String cruxServiceTypeName)
        throws UnableToCompleteException {
    SourceWriter srcWriter = getSourceWriter(logger, context, cruxServiceTypeName);

    String gadgetWrapperName = getGadgetProxyQualifiedName();
    if (srcWriter == null) {
        return new RebindResult(RebindMode.USE_EXISTING, gadgetWrapperName);
    }

    generateGadgetProxyContructor(srcWriter);

    srcWriter.commit(logger);

    return new RebindResult(RebindMode.USE_ALL_NEW_WITH_NO_CACHING, gadgetWrapperName);
}

From source file:org.jboss.errai.ioc.rebind.ioc.bootstrapper.FactoryGenerator.java

License:Apache License

@Override
public RebindResult generateIncrementally(final TreeLogger logger, final GeneratorContext generatorContext,
        final String typeName) throws UnableToCompleteException {
    final long start = System.currentTimeMillis();
    final DependencyGraph graph = assertGraphSet();
    final InjectionContext injectionContext = assertInjectionContextSet();
    final Injectable injectable = graph
            .getConcreteInjectable(typeName.substring(typeName.lastIndexOf('.') + 1));
    final InjectableType factoryType = injectable.getInjectableType();

    final ClassStructureBuilder<?> factoryBuilder = define(getFactorySubTypeName(typeName),
            parameterizedAs(Factory.class, typeParametersOf(injectable.getInjectedType()))).publicScope()
                    .body();//ww  w.  j av  a  2s. c o m
    final FactoryBodyGenerator generator = selectBodyGenerator(factoryType, typeName, injectable);

    final String factorySimpleClassName = getFactorySubTypeSimpleName(typeName);
    final PrintWriter pw = generatorContext.tryCreate(logger, GENERATED_PACKAGE, factorySimpleClassName);

    final RebindResult retVal;
    if (pw != null) {
        final String factorySource;
        if (isCacheUsable(typeName, injectable)) {
            log.debug("Reusing cached factory for " + typeName);
            factorySource = generatedSourceByFactoryTypeName.get(typeName);
        } else {
            log.debug("Generating factory for " + typeName);
            generator.generate(factoryBuilder, injectable, graph, injectionContext, logger, generatorContext);
            factorySource = factoryBuilder.toJavaString();
            generatedSourceByFactoryTypeName.put(typeName, factorySource);
            injectablesByFactoryTypeName.put(typeName, injectable);

            writeToDotErraiFolder(factorySimpleClassName, factorySource);
        }

        pw.write(factorySource);
        generatorContext.commit(logger, pw);

        retVal = new RebindResult(RebindMode.USE_ALL_NEW,
                factoryBuilder.getClassDefinition().getFullyQualifiedName());
    } else {
        log.debug("Reusing factory for " + typeName);
        retVal = new RebindResult(RebindMode.USE_EXISTING, getFactorySubTypeName(typeName));
    }

    final long ellapsed = System.currentTimeMillis() - start;
    totalTime += ellapsed;
    log.debug("Factory for {} completed in {}ms. Total factory generation time: {}ms", typeName, ellapsed,
            totalTime);

    return retVal;
}

From source file:org.jboss.errai.marshalling.rebind.MarshallerGenerator.java

License:Apache License

@Override
public RebindResult generateIncrementally(final TreeLogger logger, final GeneratorContext context,
        final String typeName) throws UnableToCompleteException {
    final String fullyQualifiedTypeName = distillTargetTypeName(typeName);
    final MetaClass type = MetaClassFactory.get(fullyQualifiedTypeName);
    final String className = MarshallerGeneratorFactory.getMarshallerImplClassName(type, true);
    final String marshallerTypeName = packageName + "." + className;
    final MetaClass cachedType = cachedPortableTypes.get(fullyQualifiedTypeName);

    final PrintWriter printWriter = context.tryCreate(logger, packageName, className);
    if (printWriter != null) {
        if (!RebindUtils.NO_CACHE && cachedType != null && cachedType.hashContent() == type.hashContent()) {
            log.debug("Reusing cached marshaller for {}", fullyQualifiedTypeName);
            printWriter.append(cachedSourceByTypeName.get(fullyQualifiedTypeName));
            context.commit(logger, printWriter);
        } else {//w w w.j a v  a2 s  . c  o  m
            log.debug("Generating marshaller for {}", fullyQualifiedTypeName);
            final String generatedSource = generateMarshaller(context, type, className, marshallerTypeName,
                    logger, printWriter);
            cachedPortableTypes.put(fullyQualifiedTypeName, type);
            cachedSourceByTypeName.put(fullyQualifiedTypeName, generatedSource);
        }

        return new RebindResult(RebindMode.USE_ALL_NEW, marshallerTypeName);
    } else {
        log.debug("Reusing existing marshaller for {}", fullyQualifiedTypeName);
        return new RebindResult(RebindMode.USE_EXISTING, marshallerTypeName);
    }
}