Example #1
0
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   // check if process was done on previous round
   if (OcelotProcessor.isDone()
       || roundEnv.processingOver()) { // Returns true if types generated by this round will not be
     // subject to a subsequent round of annotation processing; returns
     // false otherwise.
     return true; // if is it : stop
   }
   // Create provider of ocelot-services.js
   String js = createJSServicesProvider();
   // Create file ocelot-services.js
   try {
     FileObject resource = filer.createResource(StandardLocation.CLASS_OUTPUT, "", js);
     try (Writer writer = resource.openWriter()) {
       ElementVisitor visitor = new DataServiceVisitor(processingEnv);
       for (Element element : roundEnv.getElementsAnnotatedWith(DataService.class)) {
         messager.printMessage(
             Diagnostic.Kind.MANDATORY_WARNING, " javascript generation class : " + element);
         element.accept(visitor, writer);
       }
     }
   } catch (IOException e) {
     messager.printMessage(Diagnostic.Kind.ERROR, e.getMessage());
   }
   OcelotProcessor.setDone(true);
   return true;
 }
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   // System.out.println("supported options: "+
   // Arrays.toString(getSupportedOptions().toArray()));
   if (!roundEnv.processingOver()) {
     for (TypeElement currAnno : annotations) {
       // System.out.println("Found " + currAnno.getQualifiedName());
       if (currAnno.getQualifiedName().contentEquals(GENERATE_POJO_BUILDER_CLASS.getName())) {
         Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(currAnno);
         // System.out.println("[GenerateBuilder] annotatedElements="+
         // Arrays.toString(annotatedElements.toArray()));
         for (Element elem : annotatedElements) {
           if (elem.getKind() == ElementKind.CLASS) {
             TypeElement typeElem = (TypeElement) elem;
             GeneratePojoBuilder annotation = typeElem.getAnnotation(GENERATE_POJO_BUILDER_CLASS);
             generatePojoBuilderProcessor.process(typeElem, annotation);
           } else if (elem.getKind() == ElementKind.METHOD) {
             ExecutableElement execElem = (ExecutableElement) elem;
             GeneratePojoBuilder annotation = execElem.getAnnotation(GENERATE_POJO_BUILDER_CLASS);
             generatePojoBuilderProcessor.process(execElem, annotation);
           }
         }
       }
     }
   }
   return false;
 }
Example #3
0
  /** {@inheritDoc} */
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    if (roundEnv.processingOver()) return false;

    // We have: A sorted set of all priority levels: 'priorityLevels'

    // Step 1: Take all CUs which aren't already in the map. Give them the first priority level.

    for (Element element : roundEnv.getRootElements()) {
      JCCompilationUnit unit = toUnit(element);
      if (unit == null) continue;
      if (roots.containsKey(unit)) continue;
      roots.put(unit, priorityLevels[0]);
    }

    while (true) {
      // Step 2: For all CUs (in the map, not the roundEnv!), run them across all handlers at their
      // current prio level.

      for (long prio : priorityLevels) {
        List<JCCompilationUnit> cusForThisRound = new ArrayList<JCCompilationUnit>();
        for (Map.Entry<JCCompilationUnit, Long> entry : roots.entrySet()) {
          Long prioOfCu = entry.getValue();
          if (prioOfCu == null || prioOfCu != prio) continue;
          cusForThisRound.add(entry.getKey());
        }
        transformer.transform(prio, processingEnv.getContext(), cusForThisRound);
      }

      // Step 3: Push up all CUs to the next level. Set level to null if there is no next level.

      Set<Long> newLevels = new HashSet<Long>();
      for (int i = priorityLevels.length - 1; i >= 0; i--) {
        Long curLevel = priorityLevels[i];
        Long nextLevel = (i == priorityLevels.length - 1) ? null : priorityLevels[i + 1];
        for (Map.Entry<JCCompilationUnit, Long> entry : roots.entrySet()) {
          if (curLevel.equals(entry.getValue())) {
            entry.setValue(nextLevel);
            newLevels.add(nextLevel);
          }
        }
      }
      newLevels.remove(null);

      // Step 4: If ALL values are null, quit. Else, either do another loop right now or force a
      // resolution reset by forcing a new round in the annotation processor.

      if (newLevels.isEmpty()) return false;
      newLevels.retainAll(priorityLevelsRequiringResolutionReset);
      if (newLevels.isEmpty()) {
        // None of the new levels need resolution, so just keep going.
        continue;
      } else {
        // Force a new round to reset resolution. The next round will cause this method (process) to
        // be called again.
        forceNewRound((JavacFiler) processingEnv.getFiler());
        return false;
      }
    }
  }
Example #4
0
 @Override
 public boolean process(
     Set<? extends TypeElement> annotations, RoundEnvironment roundEnvironment) {
   if (!roundEnvironment.processingOver()) {
     Set<? extends Element> elements = roundEnvironment.getRootElements();
     elements.forEach(
         element -> {
           JCTree tree = (JCTree) trees.getTree(element);
           tree.accept(visitor);
         });
   }
   return false;
 }
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    if (roundEnv.processingOver()) {
      return true;
    }

    for (Element element : roundEnv.getElementsAnnotatedWith(ServiceProvider.class)) {
      assert element.getKind().isClass();
      processElement((TypeElement) element);
    }

    return true;
  }
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   this.metadataCollector.processing(roundEnv);
   Elements elementUtils = this.processingEnv.getElementUtils();
   TypeElement annotationType = elementUtils.getTypeElement(configurationPropertiesAnnotation());
   if (annotationType != null) { // Is @ConfigurationProperties available
     for (Element element : roundEnv.getElementsAnnotatedWith(annotationType)) {
       processElement(element);
     }
   }
   if (roundEnv.processingOver()) {
     writeMetaData();
   }
   return false;
 }
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Processing @Implemented...");
    for (TypeElement annotation : annotations) {
      for (Element element : roundEnv.getElementsAnnotatedWith(annotation)) {
        TypeElement serviceElement = (TypeElement) element;
        PackageElement packageElement = getPackage(serviceElement);
        final String packageName =
            packageElement == null ? "" : packageElement.getQualifiedName().toString();
        Implemented implemented = serviceElement.getAnnotation(Implemented.class);
        final String implName =
            "".equals(implemented.value())
                ? serviceElement.getSimpleName().toString() + "Impl"
                : implemented.value();
        final List<FieldDescriptor> fields = createFieldList(serviceElement);
        final String localName = determineLocalName(serviceElement);
        final boolean isPublic = serviceElement.getModifiers().contains(Modifier.PUBLIC);
        ImplementedDescriptor annotationDescriptor =
            new ImplementedDescriptor(isPublic, packageName, implName, localName, fields);
        createImplSourceFile(annotationDescriptor, serviceElement, packageName + "." + implName);
      }
    }

    return true;
  }
Example #8
0
 @Override
 public boolean process(Set<? extends TypeElement> types, RoundEnvironment env) {
   remainingTypes.putAll(providerMethodsByClass(env));
   for (Iterator<String> i = remainingTypes.keySet().iterator(); i.hasNext(); ) {
     String typeName = i.next();
     TypeElement type = processingEnv.getElementUtils().getTypeElement(typeName);
     List<ExecutableElement> providesTypes = remainingTypes.get(typeName);
     try {
       // Attempt to get the annotation. If types are missing, this will throw
       // IllegalStateException.
       Map<String, Object> parsedAnnotation = CodeGen.getAnnotation(Module.class, type);
       try {
         writeModuleAdapter(type, parsedAnnotation, providesTypes);
       } catch (IOException e) {
         error("Code gen failed: " + e, type);
       }
       i.remove();
     } catch (IllegalStateException e) {
       // a dependent type was not defined, we'll catch it on another pass
     }
   }
   if (env.processingOver() && remainingTypes.size() > 0) {
     processingEnv
         .getMessager()
         .printMessage(
             Diagnostic.Kind.ERROR,
             "Could not find types required by provides methods for " + remainingTypes.keySet());
   }
   return false; // FullGraphProcessor needs an opportunity to process.
 }
 @Override
 public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   for (TypeElement elem : ElementFilter.typesIn(roundEnv.getRootElements())) {
     elements.add(elem.getQualifiedName());
   }
   return false;
 }
 @Override
 public Observable<ElementScanner> call(RoundEnvironment roundEnv, TypeElement element) {
   return Observable.from(roundEnv.getElementsAnnotatedWith(element))
       .map(new GetEnclosingElement())
       .filter(new NotNestedClass(mProcessingEnv))
       .filter(
           new Func1<Element, Boolean>() {
             @Override
             public Boolean call(Element element) {
               return mSingleHit.add(element);
             }
           })
       .map(
           new Func1<Element, ElementScanner>() {
             @Override
             public ElementScanner call(Element element) {
               if (mProcessingEnv.isSubtype(element.asType(), "android.app.Activity")) {
                 return new ActivityScanner(mProcessingEnv, (TypeElement) element);
               } else if (mProcessingEnv.isSubtype(element.asType(), "android.app.Fragment")) {
                 return new FragmentScanner(mProcessingEnv, (TypeElement) element);
               } else if (mProcessingEnv.isSubtype(element.asType(), "android.view.View")) {
                 return new ViewScanner(mProcessingEnv, (TypeElement) element);
               }
               return new ElementScanner(mProcessingEnv, (TypeElement) element) {
                 @Override
                 protected void scan() {
                   mProcessingEnv.printMessage(
                       Diagnostic.Kind.ERROR,
                       getOrigin(),
                       "Expected subtype of Activity, Fragment or View");
                 }
               };
             }
           });
 }
  @Override
  public boolean process(final Set<? extends TypeElement> elements, final RoundEnvironment env) {
    // processingEnv is a predefined member in AbstractProcessor class
    // Messager allows the processor to output messages to the environment
    final Messager messager = processingEnv.getMessager();

    // Create a hash table to hold the option switch to option bean mapping
    final HashMap<String, String> values = new HashMap<String, String>();

    // Loop through the annotations that we are going to process
    // In this case there should only be one: Option
    for (final TypeElement te : elements) {

      // Get the members that are annotated with Option
      for (final Element e : env.getElementsAnnotatedWith(te)) {
        // Process the members. processAnnotation is our own method
        processAnnotation(e, values, messager);
      }
    }

    // If there are any annotations, we will proceed to generate the annotation
    // processor in generateOptionProcessor method
    if (values.size() > 0) {
      try {
        // Generate the option process class
        generateOptionProcessor(processingEnv.getFiler(), values);
      } catch (final Exception e) {
        messager.printMessage(Diagnostic.Kind.ERROR, e.getMessage());
      }
    }
    return true;
  }
  public Map<TypeElement, IntentBindingAdapterGenerator> findAndParseTargets(RoundEnvironment env) {
    Map<TypeElement, IntentBindingAdapterGenerator> targetClassMap =
        new LinkedHashMap<TypeElement, IntentBindingAdapterGenerator>();
    Set<String> erasedTargetNames = new LinkedHashSet<String>();

    // Process each @BindExtra
    for (Element element : env.getElementsAnnotatedWith(BindExtra.class)) {
      try {
        parseBindExtra(element, targetClassMap, erasedTargetNames);
      } catch (Exception e) {
        StringWriter stackTrace = new StringWriter();
        e.printStackTrace(new PrintWriter(stackTrace));
        error(element, "Unable to generate intent adapter for @BindExtra.\n\n%s", stackTrace);
      }
    }

    // Try to find a parent adapter for each adapter
    for (Map.Entry<TypeElement, IntentBindingAdapterGenerator> entry : targetClassMap.entrySet()) {
      TypeElement parent = findParent(entry.getKey(), erasedTargetNames);
      if (parent != null) {
        entry
            .getValue()
            .setParentAdapter(
                getPackageName(parent), parent.getSimpleName() + INTENT_ADAPTER_SUFFIX);
      }
    }

    return targetClassMap;
  }
Example #13
0
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   // Here is where we store all attributes per class that we need to generate code for.
   List<CollectedClass> collectedClasses = new ArrayList<>();
   for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(PostmanEnabled.class)) {
     // Filter out everything but the classes
     CollectedClass collectedClass =
         CollectedClasses.obtain(mLogger, mTypes, mElements, annotatedElement);
     if (collectedClass != null) {
       collectedClasses.add(collectedClass);
     }
   }
   // Generate code
   for (CollectedClass annotatedClass : collectedClasses) {
     //            mLogger.other("Processing type %s", annotatedClass.toString());
     try {
       CollectedClassWriter writer = annotatedClass.getWriter();
       writer.writeToFile(mElements, mFiler);
     } catch (IOException e) {
       mLogger.error(
           annotatedClass.getClassElement(),
           "Unable to write code for type %s: %s",
           annotatedClass,
           e.getMessage());
     }
   }
   return true;
 }
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   try {
     Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(Parcelable.class);
     for (Element element : set) {
       try {
         TypeElement enclosingElement = (TypeElement) element;
         ProxyInfo pi = new ProxyInfo(enclosingElement.getQualifiedName().toString());
         writeLog(pi.getFullName());
         JavaFileObject jfo = filer.createSourceFile(pi.getFullName(), enclosingElement);
         Writer writer = jfo.openWriter();
         writeLog(pi.createCode());
         writer.write(pi.createCode());
         writer.flush();
         writer.close();
         writeLog("ok");
       } catch (Exception e) {
         e.printStackTrace();
         writeLog(e.getMessage());
       }
     }
   } catch (Exception e) {
     e.printStackTrace();
     writeLog(e.getMessage());
   }
   return true;
 }
Example #15
0
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    // Are we finished, if so, clean up
    if (roundEnv.processingOver()) {
      state = null;
      return false;
    }

    // Newly initialized or being reused?
    if (state == null) {
      state = forceErrors ? new State.ForTesting(processingEnv) : new State(processingEnv);
      if (state.isPoisoned()) {
        // Could not initialize State object, bail out
        return false;
      }
      // Produce a "lite" map just for JRE-only clients
      state.setClientOnly(clientOnly);
      // Disallow @ProxyForName or @ServiceName that can't be resolved
      state.setMustResolveAllMappings(mustResolveAllMappings);
    }

    try {
      // Bootstrap the State's work queue
      new Finder().scan(getTypesToProcess(state, roundEnv), state);
      // Execute the work items
      state.executeJobs();
    } catch (HaltException ignored) {
      // Already logged. Let any unhandled RuntimeExceptions fall out.
    }
    return false;
  }
Example #16
0
  private Set<TypeElement> getMappers(
      final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnvironment) {
    Set<TypeElement> mapperTypes = new HashSet<TypeElement>();

    for (TypeElement annotation : annotations) {
      // Indicates that the annotation's type isn't on the class path of the compiled
      // project. Let the compiler deal with that and print an appropriate error.
      if (annotation.getKind() != ElementKind.ANNOTATION_TYPE) {
        continue;
      }

      try {
        Set<? extends Element> annotatedMappers =
            roundEnvironment.getElementsAnnotatedWith(annotation);
        for (Element mapperElement : annotatedMappers) {
          TypeElement mapperTypeElement = asTypeElement(mapperElement);

          // on some JDKs, RoundEnvironment.getElementsAnnotatedWith( ... ) returns types with
          // annotations unknown to the compiler, even though they are not declared Mappers
          if (mapperTypeElement != null && MapperPrism.getInstanceOn(mapperTypeElement) != null) {
            mapperTypes.add(mapperTypeElement);
          }
        }
      } catch (Throwable t) { // whenever that may happen, but just to stay on the save side
        handleUncaughtError(annotation, t);
        continue;
      }
    }
    return mapperTypes;
  }
Example #17
0
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    for (Element elem : roundEnv.getElementsAnnotatedWith(FixedRecord.class)) {
      String classPackage =
          processingEnv.getElementUtils().getPackageOf(elem).getQualifiedName().toString();
      ClassWrapper classWrapper = new ClassWrapper(classPackage, elem.getSimpleName().toString());

      List<Element> listGetter = getFixedFieldAnnotateMethod(elem);

      for (Element elemMethod : listGetter) {
        TypeWrapper typeWrapper;
        MethodWrapper methodWrapper = new MethodWrapper();
        FixedField fixedField = elemMethod.getAnnotation(FixedField.class);
        String decoratorClass = getDecoratorClass(fixedField);

        methodWrapper.setName(elemMethod.getSimpleName().toString());
        methodWrapper.setFixedField(fixedField);
        methodWrapper.setDecoratorClass(decoratorClass);

        String fullName = ((ExecutableType) elemMethod.asType()).getReturnType().toString();
        if (fullName.contains("<") && fixedField.collectionSize() > 0) {
          fullName = fullName.substring(fullName.indexOf("<") + 1, fullName.indexOf(">"));
        }
        String packageName = fullName.substring(0, fullName.lastIndexOf("."));
        String typeName = fullName.substring(packageName.length() + 1);

        if (fixedField.length() == 0 && fixedField.collectionSize() == 0) {
          methodWrapper.setBean(true);
        } else if (fixedField.collectionSize() > 0) {
          methodWrapper.setList(true);
        }

        typeWrapper = new TypeWrapper(packageName, typeName);
        methodWrapper.setType(typeWrapper);
        classWrapper.addMethod(methodWrapper);
      }

      parser.createParserClass(classWrapper);
      // TODO
      processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "");
    }
    if (roundEnv.processingOver()) {
      parser.getJavaFileBuilder().writeJavaFile(processingEnv);
      return false;
    }
    return true; // no further processing of this annotation type
  }
 @Override
 public final boolean process(Set<? extends TypeElement> annotations, RoundEnvironment round) {
   try {
     StaticEnvironment.init(annotations, round, processingEnv);
     if (!round.processingOver() && !round.errorRaised()) {
       process();
     }
     StaticEnvironment.shutdown();
   } catch (Exception ex) {
     processingEnv
         .getMessager()
         .printMessage(
             Diagnostic.Kind.ERROR,
             getClass().getName() + " threw " + Throwables.getStackTraceAsString(ex));
   }
   return false;
 }
 private Collection<EnclosingView> processAnnotations(RoundEnvironment roundEnv) {
   Set<? extends Element> views = roundEnv.getElementsAnnotatedWith(ThreadDecoratedView.class);
   ArrayList<EnclosingView> modelViews = new ArrayList<>();
   for (Element e : views) {
     modelViews.add(processView(e));
   }
   return modelViews;
 }
Example #20
0
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    if (roundEnv.processingOver()) {
      return true;
    }
    final List<LabelTemplateMethod> methods = new ArrayList<LabelTemplateMethod>();
    for (Element element : roundEnv.getElementsAnnotatedWith(MessageBundle.class)) {
      if (element.getKind() != ElementKind.INTERFACE) {
        continue;
      }
      final TypeElement bundleType = (TypeElement) element;
      processLabels(bundleType, methods);
      try {

        FileObject file = null;
        switch (generationType) {
          case SOURCE:
            file =
                processingEnv
                    .getFiler()
                    .createSourceFile(getTargetClassName(bundleType), bundleType);
            break;

          case RESSOURCE:
            file =
                processingEnv
                    .getFiler()
                    .createResource(
                        SOURCE_OUTPUT,
                        bundleType.getEnclosingElement().toString(),
                        getTargetSimpleName(bundleType) + ".properties");
            break;
        }

        final Writer writer = file.openWriter();
        writer.write(getCode(bundleType, methods));
        writer.close();
      } catch (IOException e) {
        processingEnv.getMessager().printMessage(Kind.ERROR, e.getMessage(), bundleType);
      } finally {
        methods.clear();
      }
    }
    return false;
  }
Example #21
0
 public boolean process(Set<? extends TypeElement> annos, RoundEnvironment rEnv) {
   Trees trees = Trees.instance(processingEnv);
   Test test = new Test();
   for (Element e : rEnv.getRootElements()) {
     Tree t = trees.getTree(e);
     test.scan(t, null);
   }
   return true;
 }
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   for (TypeElement t : annotations) {
     for (Element e : roundEnv.getElementsAnnotatedWith(t)) {
       System.out.println(e + " " + t);
     }
   }
   return true;
 }
 @Override
 protected boolean handleProcess(
     Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   for (Element el : roundEnv.getElementsAnnotatedWith(EventDoc.class)) {
     EventDoc event = el.getAnnotation(EventDoc.class);
     debug("Found event: " + event.module() + " " + event.code() + " " + event.desc());
     addLine(getLine(event), getFilePath(event));
   }
   return true;
 }
  private Map<TypeElement, ViewInjector> findAndParseTargets(RoundEnvironment env) {
    Map<TypeElement, ViewInjector> targetClassMap = new LinkedHashMap<TypeElement, ViewInjector>();
    Set<String> erasedTargetNames = new LinkedHashSet<String>();

    // Process each @InjectView element.
    for (Element element : env.getElementsAnnotatedWith(InjectView.class)) {
      try {
        parseInjectView(element, targetClassMap, erasedTargetNames);
      } catch (Exception e) {
        StringWriter stackTrace = new StringWriter();
        e.printStackTrace(new PrintWriter(stackTrace));

        error(element, "Unable to generate view injector for @InjectView.\n\n%s", stackTrace);
      }
    }

    // Process each @InjectViews element.
    for (Element element : env.getElementsAnnotatedWith(InjectViews.class)) {
      try {
        parseInjectViews(element, targetClassMap, erasedTargetNames);
      } catch (Exception e) {
        StringWriter stackTrace = new StringWriter();
        e.printStackTrace(new PrintWriter(stackTrace));

        error(element, "Unable to generate view injector for @InjectViews.\n\n%s", stackTrace);
      }
    }

    // Process each annotation that corresponds to a listener.
    for (Class<? extends Annotation> listener : LISTENERS) {
      findAndParseListener(env, listener, targetClassMap, erasedTargetNames);
    }

    // Try to find a parent injector for each injector.
    for (Map.Entry<TypeElement, ViewInjector> entry : targetClassMap.entrySet()) {
      String parentClassFqcn = findParentFqcn(entry.getKey(), erasedTargetNames);
      if (parentClassFqcn != null) {
        entry.getValue().setParentInjector(parentClassFqcn + SUFFIX);
      }
    }

    return targetClassMap;
  }
 /**
  * Check parameter annotations for being qualifiers.
  *
  * @param round The round environment.
  */
 private void checkParameters(RoundEnvironment round) {
   Set<? extends Element> params = round.getElementsAnnotatedWith(Parameter.class);
   note("processing %d parameter annotations", params.size());
   for (Element param : params) {
     Qualifier q = param.getAnnotation(Qualifier.class);
     if (q == null) {
       warning(param, "parameter %s is not annotated as a qualifier", param);
     }
   }
 }
Example #26
0
  /** {@inheritDoc} */
  @Override
  public boolean process(
      final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnv) {

    for (final Element element : roundEnv.getElementsAnnotatedWith(Emits.class)) {
      final TypeElement typeElement = (TypeElement) element;
      for (final Emit emit : typeElement.getAnnotation(Emits.class).value()) {
        processEmit(emit, typeElement);
      }
    }
    for (final Element element : roundEnv.getElementsAnnotatedWith(Emit.class)) {
      final TypeElement typeElement = (TypeElement) element;
      processEmit(typeElement.getAnnotation(Emit.class), typeElement);
    }
    if (roundEnv.processingOver() && !roundEnv.errorRaised()) {
      try {
        final PrintWriter metaWriter =
            new PrintWriter(
                processingEnv
                    .getFiler()
                    .createResource(
                        StandardLocation.SOURCE_OUTPUT,
                        "",
                        "META-INF/services/javax.annotation.processing.Processor",
                        elementCollection.toArray(new Element[0]))
                    .openWriter());
        for (final String processor : annotationProcessors) {
          metaWriter.println(processor);
        }
        metaWriter.close();
      } catch (final IOException e) {
        final String msg =
            MessageFormat.format(
                LOG.getResourceBundle().getString("ioerror"),
                "META-INF/services/javax.annotation.processing.Processor",
                e.getMessage());
        processingEnv.getMessager().printMessage(Kind.ERROR, msg);
        throw new IllegalStateException(msg, e);
      }
    }
    return true;
  }
 @Override
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   for (TypeElement type :
       ElementFilter.typesIn(roundEnv.getElementsAnnotatedWith(RequireDefault.class))) {
     if (!type.getKind().isInterface() && type.getKind() != ElementKind.ANNOTATION_TYPE) {
       hasConstructor(type);
     }
   }
   for (TypeElement annotation : annotations) {
     RequireDefault constructor = annotation.getAnnotation(RequireDefault.class);
     if (constructor != null) {
       for (TypeElement type :
           ElementFilter.typesIn(roundEnv.getElementsAnnotatedWith(annotation))) {
         if (!type.getKind().isInterface()) {
           hasConstructor(type);
         }
       }
     }
   }
   return true;
 }
Example #28
0
 public boolean process(Set<? extends TypeElement> tes, RoundEnvironment renv) {
   try {
     if (renv.processingOver()) createSymbols();
   } catch (IOException e) {
     processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getLocalizedMessage());
   } catch (Throwable t) {
     Throwable cause = t.getCause();
     if (cause == null) cause = t;
     processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, cause.getLocalizedMessage());
   }
   return true;
 }
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    try {

      if (verbose) {
        processingEnv
            .getMessager()
            .printMessage(Diagnostic.Kind.NOTE, "Adding classes to " + outputFile);
      }

      // Loop around elements
      for (Element elem : roundEnv.getElementsAnnotatedWith(GenerateBeanInfo.class)) {
        // Only process class level elements
        if (elem.getKind().equals(ElementKind.CLASS)) {
          // Create XYZBeanInfo.java for each element
          createBeanInfo((TypeElement) elem);
          // Add class name to XstreamJavabeans.properties file
          beanNames.add(((TypeElement) elem).getQualifiedName().toString());
        }
      }

      // If we are done processing, write the file
      if (roundEnv.processingOver()) {
        appendExistingClasses(beanNames);
        FileObject fo =
            processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", outputFile);
        try (PrintWriter w = new PrintWriter(fo.openWriter())) {
          for (String name : beanNames) {
            w.println(name);
          }
        }
        beanNames.clear();
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }

    return true;
  }
  @Override
  public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    TYPES = processingEnv.getTypeUtils();
    ELEMENTS = processingEnv.getElementUtils();

    processingEnv
        .getMessager()
        .printMessage(Diagnostic.Kind.NOTE, "Running " + getClass().getSimpleName());

    if (roundEnv.processingOver() || annotations.size() == 0) {
      return ALLOW_OTHER_PROCESSORS_TO_CLAIM_ANNOTATIONS;
    }

    if (roundEnv.getRootElements() == null || roundEnv.getRootElements().isEmpty()) {
      processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "No sources to process");
      return ALLOW_OTHER_PROCESSORS_TO_CLAIM_ANNOTATIONS;
    }

    conf = createConfiguration(roundEnv);
    context = new Context();
    Set<Class<? extends Annotation>> entityAnnotations = conf.getEntityAnnotations();
    TypeMappings typeMappings = conf.getTypeMappings();
    QueryTypeFactory queryTypeFactory = conf.getQueryTypeFactory();
    this.typeFactory =
        new ExtendedTypeFactory(
            processingEnv, conf, entityAnnotations, typeMappings, queryTypeFactory);
    elementHandler = new TypeElementHandler(conf, typeFactory, typeMappings, queryTypeFactory);
    this.roundEnv = roundEnv;

    // process annotations
    processAnnotations();

    validateMetaTypes();

    // serialize created types
    serializeMetaTypes();

    return ALLOW_OTHER_PROCESSORS_TO_CLAIM_ANNOTATIONS;
  }