Examples of javax.lang.model.element.TypeElement

javax.lang.model.element.TypeElement
Represents a class or interface program element. Provides access to information about the type and its members. Note that an enum type is a kind of class and an annotation type is a kind of interface.
While a {@code TypeElement} represents a class or interfaceelement, a {@link DeclaredType} represents a classor interface type, the latter being a use (or invocation) of the former. The distinction is most apparent with generic types, for which a single element can define a whole family of types. For example, the element {@code java.util.Set} corresponds to the parameterized types{@code java.util.Set} and {@code java.util.Set}(and many others), and to the raw type {@code java.util.Set}.
Each method of this interface that returns a list of elements will return them in the order that is natural for the underlying source of program information. For example, if the underlying source of information is Java source code, then the elements will be returned in source code order. @author Joseph D. Darcy @author Scott Seligman @author Peter von der Ahé @see DeclaredType @since 1.6

    AnnotationValue scopeValue = AnnotationProcessingUtils
        .getAnnotationElementValue(procEnv, annotation, "scope");


    DeclaredType referencedAnnotationClass = (DeclaredType) referencedAnnotationClassValue
        .getValue();
    TypeElement referencedAnnotationTypeElement = (TypeElement) referencedAnnotationClass
        .asElement();
    ConstraintScope scope = ConstraintScope.valueOf(scopeValue.getValue()
        .toString());
    Boolean nullable = Boolean.valueOf(nullableValue.getValue().toString());
    Map<Element, Set<Element>> elements = new HashMap<Element, Set<Element>>();


    switch (scope) {
    case GLOBAL:
      elements.put(e, (Set<Element>) roundEnv
          .getElementsAnnotatedWith(referencedAnnotationTypeElement));
      break;
    case CLASS:
      switch (e.getKind()) {
      case CONSTRUCTOR:
      case FIELD:
      case METHOD:
        elements.put(e, new HashSet<Element>());


        for (Element classMemberElement : procEnv.getElementUtils()
            .getAllMembers((TypeElement) e.getEnclosingElement())) {
          if (AnnotationProcessingUtils
              .findAnnotationMirror(procEnv, classMemberElement,
                  referencedAnnotationTypeElement) != null) {
            elements.get(e).add(classMemberElement);
          }
        }


        break;
      case ENUM:
      case INTERFACE:
      case CLASS:
        elements.put(e, new HashSet<Element>());


        for (Element classMemberElement : procEnv.getElementUtils()
            .getAllMembers((TypeElement) e)) {
          if (AnnotationProcessingUtils
              .findAnnotationMirror(procEnv, classMemberElement,
                  referencedAnnotationTypeElement) != null) {
            elements.get(e).add(classMemberElement);
          }
        }


        break;
      case ANNOTATION_TYPE:
        AnnotationMirror stereotypeAnnotationMirror = AnnotationProcessingUtils
            .findAnnotationMirror(procEnv, e,
                "javax.enterprise.inject.Stereotype");


        if (stereotypeAnnotationMirror == null) {
          procEnv.getMessager()
              .printMessage(
                  Diagnostic.Kind.ERROR,
                  "Annotation targets other than stereotyped annotation, enum, interface, class, constructor, field and methods are not supported",
                  e, annotation);
          break;
        }


        Set<Element> stereotypeAnnotatedElements = (Set<Element>) roundEnv
            .getElementsAnnotatedWith((TypeElement) e);


        for (Element stereotypeAnnotatedElement : stereotypeAnnotatedElements) {


          // Always add the element to the map, otherwise it won't be
          // validated
          elements.put(stereotypeAnnotatedElement,
              new HashSet<Element>());


          switch (stereotypeAnnotatedElement.getKind()) {
          case CONSTRUCTOR:
          case FIELD:
          case METHOD:
            for (Element classMemberElement : procEnv
                .getElementUtils()
                .getAllMembers(
                    (TypeElement) stereotypeAnnotatedElement
                        .getEnclosingElement())) {
              if (AnnotationProcessingUtils.findAnnotationMirror(
                  procEnv, classMemberElement,
                  referencedAnnotationTypeElement) != null) {
                elements.get(stereotypeAnnotatedElement).add(
                    classMemberElement);
              }
            }


            break;
          case INTERFACE:
          case CLASS:
            // Maybe add here support for subtype checking, so that
            // abstract classes or interfaces must not explicitly
            // fullfill a
            // referencing constraint, but also a subtype can do
          case ENUM:
            for (Element classMemberElement : procEnv
                .getElementUtils()
                .getAllMembers(
                    (TypeElement) stereotypeAnnotatedElement)) {
              if (AnnotationProcessingUtils.findAnnotationMirror(
                  procEnv, classMemberElement,
                  referencedAnnotationTypeElement) != null) {
                elements.get(stereotypeAnnotatedElement).add(
                    classMemberElement);
              }
            }


            break;
          default:
            procEnv.getMessager().printMessage(
                Diagnostic.Kind.ERROR,
                "Feature not yet implemented",
                stereotypeAnnotatedElement, annotation);
            break;
          }
        }


        break;
      default:
        procEnv.getMessager()
            .printMessage(
                Diagnostic.Kind.ERROR,
                "Annotation targets other than stereotyped annotation, enum, interface, class, constructor, field and methods are not supported",
                e, annotation);
        break;
      }
      break;
    case ELEMENT:
      if (AnnotationProcessingUtils.findAnnotationMirror(procEnv, e,
          referencedAnnotationTypeElement) != null) {
        elements.put(e, new HashSet<Element>(Arrays.asList(e)));
      }


      break;
    }


    OUTER: for (Map.Entry<Element, Set<Element>> elementEntry : elements
        .entrySet()) {
      for (Element lookupElement : elementEntry.getValue()) {
        AnnotationMirror referencedAnnotationMirror = AnnotationProcessingUtils
            .findAnnotationMirror(procEnv, lookupElement,
                referencedAnnotationTypeElement);
        Object memberName = null;


        // Should never be null here
        assert (referencedAnnotationMirror != null);


        AnnotationValue referencedAnnotationValue = AnnotationProcessingUtils
            .getAnnotationElementValue(procEnv,
                referencedAnnotationMirror,
                referencedAnnotationMemberValue.getValue()
                    .toString());


        if (referencedAnnotationValue != null) {
          memberName = referencedAnnotationValue.getValue();
        }


        if (memberName == null) {
          procEnv.getMessager().printMessage(
              Diagnostic.Kind.ERROR,
              "Cannot find member name '"
                  + referencedAnnotationMemberValue
                      .getValue().toString()
                  + "' in annotation class '"
                  + referencedAnnotationTypeElement
                      .getQualifiedName() + "'",
              annotationType, annotation,
              referencedAnnotationMemberValue);
        } else {
          if (value.equals(memberName)) {

View Full Code Here

        // TODO Check if multiple super types are supported
        // Loop through super types and parse out id/fields
        List<? extends TypeMirror> typeMirrors = typeUtils.directSupertypes(element.asType());
        for (TypeMirror typeMirror : typeMirrors) {
          logger.d("SuperType: " + typeMirror.toString());
          TypeElement typeElement = elementUtils.getTypeElement(typeMirror.toString());
          List<? extends Element> enclosedElements = typeElement.getEnclosedElements();
          for (Element enclosedElement : enclosedElements) {
            checkForTableId(tableObject, enclosedElement);
            checkForFields(tableObject, enclosedElement);
          }
        }

View Full Code Here

      if (typeUtils.asElement(typeMirror).getAnnotation(Table.class) == null) {
        logger.e("One to many relationship in class %s where %s is not annotated with @Table",
            tableObject.getTableName(), tableColumn.getColumnName());
      }
      oneToManyCache.put(typeMirror.toString(), tableObject);
      TypeElement childColumnElement = elementUtils.getTypeElement(typeMirror.toString());
      tableColumn.setType(getClassName(childColumnElement, getPackageName(childColumnElement)));
    } else if (tableColumn.getSqlType() == SqliteType.UNKNOWN) {
      @SuppressWarnings("ConstantConditions")
      Table annotation = typeElement.getAnnotation(Table.class);
      if (annotation == null) {

View Full Code Here

            return true;
        }


        final Map<TypeElement, List<VariableElement>> buildableToFluentlyMap = new HashMap<>();
        for (Element eachBuildable : buildables) {
            TypeElement eachBuildableTypeElement = (TypeElement) eachBuildable;
            buildableToFluentlyMap.put(eachBuildableTypeElement, new ArrayList<VariableElement>());


            addEachFluentlyEnclosedElement(eachBuildableTypeElement, eachBuildableTypeElement, buildableToFluentlyMap,
                    roundEnvironment);
        }




        for (Element eachBuildableClass : buildables) {
            TypeElement eachBuildableTypeElement = (TypeElement) eachBuildableClass;


            Name simpleClassName = eachBuildableTypeElement.getSimpleName();
            Name qualifiedClassName = eachBuildableTypeElement.getQualifiedName();
            String packageName = getPackageNameFrom(qualifiedClassName);


            try {
                final Buildable theBuildable = eachBuildableTypeElement.getAnnotation(Buildable.class);
                final JavaFileObject javaFileObject = processingEnv.getFiler().createSourceFile(packageName + "." +
                        createBuilderName(theBuildable, simpleClassName), eachBuildableClass);




                final OutputStream outputStream = javaFileObject.openOutputStream();

View Full Code Here

        this.processingEnv.getMessager().printMessage(NOTE, "Beginning superclass processing for " + superclassName);


        final Set<? extends Element> buildableSubclasses = roundEnvironment.getElementsAnnotatedWith(BuildableSubclasses.class);


        for (Element eachBuildableSubclassElement : buildableSubclasses) {
            TypeElement eachBuildableSubclassTypeElement = (TypeElement) eachBuildableSubclassElement;
            final String eachBuildableSubclassClassName = eachBuildableSubclassTypeElement.getQualifiedName().toString();
            this.processingEnv.getMessager().printMessage(NOTE, "Checking " + eachBuildableSubclassClassName);


            if (eachBuildableSubclassTypeElement.getKind().isClass()) {


                this.processingEnv.getMessager().printMessage(NOTE, "Checking " + superclassName + " equals " + eachBuildableSubclassClassName);
                if (superclassName.equals(eachBuildableSubclassClassName)) {
                    addEachFluentlyEnclosedElement(buildable, eachBuildableSubclassTypeElement, buildableToFluentlyMap, roundEnvironment);
                }

View Full Code Here

          processingEnv.getMessager().printMessage(
                  Kind.ERROR, "@EventHandler methods must return void", target);
        }
        
        AnnotationMirror eventHandlerAnnotation = getAnnotation(target, TypeNames.EVENT_HANDLER);
        TypeElement enclosingClassElement = (TypeElement) target.getEnclosingElement();
        boolean hasSinkNative = hasAnnotation(target, TypeNames.SINK_NATIVE);
        
        AnnotationValue eventHandlerAnnotationValue = getAnnotationParamValueWithoutDefaults(target, TypeNames.EVENT_HANDLER, "value");
        
        // if there is no annotation parameter value, this method handles events from the templated widget itself: nothing more to check.

View Full Code Here

        if (!types.isAssignable(targetType, gwtWidgetType)) {
          processingEnv.getMessager().printMessage(
                  Kind.ERROR, "@Bound must target a type assignable to Widget", target); // FIXME actually HasText or HasValue
        }


        TypeElement enclosingClass = getEnclosingTypeElement(target);
        List<Element> boundThings = classesWithBoundThings.get(enclosingClass);
        if (boundThings == null) {
          boundThings = new ArrayList<Element>();
          classesWithBoundThings.put(enclosingClass, boundThings);
        }

View Full Code Here

        public void started(TaskEvent taskEvent) {}


        @Override
        public void finished(TaskEvent taskEvent) {
            if (taskEvent.getKind().equals(eventKind)) {
                TypeElement typeElem = taskEvent.getTypeElement();
                Tree tree = trees.getTree(typeElem);
                if (tree != null) {
                    JavaFileObject prevSource = log.currentSourceFile();
                    try {
                        log.useSource(taskEvent.getCompilationUnit().getSourceFile());

View Full Code Here

    /**
     * Including super class fields.
     */
    List<VariableElement> getAllFields(TypeElement subclazz) {
        List<VariableElement> fields = new ArrayList<VariableElement>();
        TypeElement cd = null;
        Stack<TypeElement> s = new Stack<TypeElement>();


        cd = subclazz;
        while (true) {
            s.push(cd);
            TypeElement c = (TypeElement) (types.asElement(cd.getSuperclass()));
            if (c == null)
                break;
            cd = c;
        }

View Full Code Here

        sb.append(")");
        return sb.toString();
    }


    protected final String jniType(TypeMirror t) {
        TypeElement throwable = elements.getTypeElement("java.lang.Throwable");
        TypeElement jClass = elements.getTypeElement("java.lang.Class");
        TypeElement jString = elements.getTypeElement("java.lang.String");
        Element tclassDoc = types.asElement(t);




        switch (t.getKind()) {
            case ARRAY: {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.lang.model.element.TypeElement

buildable.annotation.processor.BuildableAnnotationProcessor

ch.powerunit.impl.validator.ParametersProcessorValidator

ch.powerunit.impl.validator.RuleProcessorValidator

ch.ralscha.extdirectspring.generator.ModelAnnotationProcessor

ch.rasc.extclassgenerator.ModelAnnotationProcessor

com.antwerkz.critter.CriteriaBuilder

com.arconsis.android.datarobot.builder.schema.reader.SchemaReader

com.arconsis.android.datarobot.processor.EntityAnnotationProcessor

com.artemis.FactoryModel

com.artemis.ProcessorUtil

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.