Esempio n. 1
0
  public SqlCreateStatement(
      Map<String, Element> elementMap, Element parent, SqlUpgradeScripts upgradeScripts) {
    this.tableName = parent.getSimpleName().toString();

    columnDefinitions = new ArrayList<>();
    columnDefinitions.add(ColumnDefinition.createPrimaryIdDefinition());

    for (String key : elementMap.keySet()) {
      Element element = elementMap.get(key);
      ColumnDefinition columnDefinition = new ColumnDefinition(element);

      Column column = element.getAnnotation(Column.class);
      ForeignObject foreignObject = element.getAnnotation(ForeignObject.class);

      if (column != null && upgradeScripts != null) {
        int version = column.version();
        if (version > 1) {
          upgradeScripts.addAlterAddColumn(columnDefinition, tableName, version);
        }
      } else if (foreignObject != null && upgradeScripts != null) {
        int version = foreignObject.version();
        if (version > 1) {
          upgradeScripts.addAlterAddColumn(columnDefinition, tableName, version);
        }
      }
      columnDefinitions.add(columnDefinition);
    }
  }
Esempio n. 2
0
 private void parseOnChanged(
     Element element,
     Map<TypeElement, BindingClass> targetClassMap,
     Set<String> erasedTargetNames,
     Class annotationClass) {
   TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
   BindingClass bindingClass =
       getOrCreateTargetClass(targetClassMap, enclosingElement, false, false);
   TypeMirror mirror = element.asType();
   if (!(mirror.getKind() == TypeKind.EXECUTABLE)) return;
   String method = element.toString().trim();
   String methodName = method.substring(0, method.indexOf("("));
   Matcher m = Pattern.compile("\\(([^)]+)\\)").matcher(method);
   if (m.find()) {
     String[] methodTypes = m.group(1).split(",");
     String key = null;
     if (annotationClass.equals(OnKStringChanged.class)) {
       KStringBinding binding = new KStringBinding(methodName, methodTypes);
       key = element.getAnnotation(OnKStringChanged.class).value();
       bindingClass.putGeneric(key, binding);
     } else if (annotationClass.equals(OnKBooleanChanged.class)) {
       KBooleanBinding binding = new KBooleanBinding(methodName, methodTypes);
       key = element.getAnnotation(OnKBooleanChanged.class).value();
       bindingClass.putGeneric(key, binding);
     } else {
       error(element, "unknow annotation class type @%s", annotationClass.getSimpleName());
     }
   }
   erasedTargetNames.add(enclosingElement.toString());
 }
Esempio n. 3
0
  private void parseConstructorParameterAnnotations(PropertyBuilder property, Element element) {
    if (element.getAnnotation(Nullable.class) != null) {
      property.setNullable(true);
    }

    if (element.getAnnotation(Volatile.class) != null) {
      property.setVolatile(true);
    }
  }
Esempio n. 4
0
 private void parseBind(
     Element element,
     Map<TypeElement, BindingClass> targetClassMap,
     Set<String> erasedTargetNames) {
   String data = element.getAnnotation(Bind.class).data();
   int id = element.getAnnotation(Bind.class).id();
   BindingClass bindingClass =
       getOrCreateTargetClass(targetClassMap, (TypeElement) element, false, false);
   bindingClass.addDoubleBinding(id, data);
 }
  @Override
  public Void visitBinary(BinaryTree node, Void p) {

    // No checking unless the operator is "==" or "!=".
    if (!(node.getKind() == Tree.Kind.EQUAL_TO || node.getKind() == Tree.Kind.NOT_EQUAL_TO))
      return super.visitBinary(node, p);

    ExpressionTree leftOp = node.getLeftOperand();
    ExpressionTree rightOp = node.getRightOperand();

    // Check passes if either arg is null.
    if (leftOp.getKind() == Tree.Kind.NULL_LITERAL || rightOp.getKind() == Tree.Kind.NULL_LITERAL)
      return super.visitBinary(node, p);

    AnnotatedTypeMirror left = atypeFactory.getAnnotatedType(leftOp);
    AnnotatedTypeMirror right = atypeFactory.getAnnotatedType(rightOp);

    // If either argument is a primitive, check passes due to auto-unboxing
    if (left.getKind().isPrimitive() || right.getKind().isPrimitive())
      return super.visitBinary(node, p);

    if (!(shouldCheckFor(leftOp) && shouldCheckFor(rightOp))) return super.visitBinary(node, p);

    // Syntactic checks for legal uses of ==
    if (suppressInsideComparison(node)) return super.visitBinary(node, p);
    if (suppressEarlyEquals(node)) return super.visitBinary(node, p);
    if (suppressEarlyCompareTo(node)) return super.visitBinary(node, p);

    if (suppressClassAnnotation(left, right)) {
      return super.visitBinary(node, p);
    }

    Element leftElt = null;
    Element rightElt = null;
    if (left
        instanceof org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType) {
      leftElt = ((DeclaredType) left.getUnderlyingType()).asElement();
    }
    if (right
        instanceof org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType) {
      rightElt = ((DeclaredType) right.getUnderlyingType()).asElement();
    }

    // if neither @Interned or @UsesObjectEquals, report error
    if (!(left.hasEffectiveAnnotation(INTERNED)
        || (leftElt != null && leftElt.getAnnotation(UsesObjectEquals.class) != null)))
      checker.report(Result.failure("not.interned", left), leftOp);
    if (!(right.hasEffectiveAnnotation(INTERNED)
        || (rightElt != null && rightElt.getAnnotation(UsesObjectEquals.class) != null)))
      checker.report(Result.failure("not.interned", right), rightOp);
    return super.visitBinary(node, p);
  }
  private <A extends Annotation> ActionModel processAction(
      int genericPosition, Element element, Element outputElement, Class<A> annotationClass) {
    A annotation = element.getAnnotation(annotationClass);
    if (annotation != null) {
      System.out.println("Element: " + element.getSimpleName());
      if (elementTools.isMethod(element)) {
        TypeMirror outputGeneric =
            ((DeclaredType) outputElement.asType()).getTypeArguments().get(genericPosition);
        List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters();
        if (parameters.size() == 1
            && processingEnv.getTypeUtils().isSameType(parameters.get(0).asType(), outputGeneric)) {
          ActionModel actionModel = new ActionModel();
          actionModel.setMethodName(elementTools.getFieldName(element));
          actionModel.setType(element.asType());
          if (element.getKind() == ElementKind.METHOD) {
            actionModel.setType(((ExecutableElement) element).getParameters().get(0).asType());
          }

          System.out.println("It maches!!!" + actionModel);
          return actionModel;
        } else {
          System.out.println("Does not match");
        }
      }
    }
    return null;
  }
 boolean getTreatUnknownKeyAsError(Element element) {
   JsonModel model = element.getAnnotation(JsonModel.class);
   if (model == null) {
     throw new IllegalArgumentException();
   }
   return model.treatUnknownKeyAsError();
 }
  @Override
  public void process(Element element, EComponentHolder holder) throws Exception {
    ExecutableElement executableElement = (ExecutableElement) element;
    JMethod delegatingMethod = codeModelHelper.overrideAnnotatedMethod(executableElement, holder);
    JBlock previousBody = codeModelHelper.removeBody(delegatingMethod);
    JDefinedClass anonymousRunnableClass =
        codeModelHelper.createDelegatingAnonymousRunnableClass(holder, previousBody);

    UiThread annotation = element.getAnnotation(UiThread.class);
    long delay = annotation.delay();
    UiThread.Propagation propagation = annotation.propagation();

    if (delay == 0) {
      if (propagation == UiThread.Propagation.REUSE) {
        // Put in the check for the UI thread.
        addUIThreadCheck(delegatingMethod, previousBody, holder);
      }

      delegatingMethod.body().invoke(holder.getHandler(), "post").arg(_new(anonymousRunnableClass));
    } else {
      delegatingMethod
          .body()
          .invoke(holder.getHandler(), "postDelayed")
          .arg(_new(anonymousRunnableClass))
          .arg(lit(delay));
    }
  }
Esempio n. 9
0
  @Override
  public void process(Element element, EBeanHolder holder) {
    final ExecutableElement afterPutMethod = (ExecutableElement) element;
    final UseModelHolder useModelHolder = holder.getPluginHolder(new UseModelHolder(holder));
    useModelHolder.setAfterPutMethod(afterPutMethod);

    List<Class<? extends Annotation>> annotations =
        Arrays.asList(UseModel.class, LocalDBModel.class, ServerModel.class);
    for (Class<? extends Annotation> annotation : annotations) {
      if (element.getAnnotation(annotation) != null) return;
    }

    List<? extends VariableElement> parameters = afterPutMethod.getParameters();

    JInvocation invocation =
        useModelHolder
            .getPutModelInitBlock()
            ._if(ref("result").ne(_null()))
            ._then()
            .invoke(afterPutMethod.getSimpleName().toString());

    for (VariableElement param : parameters) {
      final String paramName = param.getSimpleName().toString();
      ParamUtils.injectParam(paramName, invocation);
    }
  }
 private KeySpec getKey(Element element) {
   if (isDefaultAnnotationElement(element, BindExtra.class.getName(), "value")) {
     return new KeySpec(
         null, generateKey(IntentFieldBinding.KEY_PREFIX, element.getSimpleName().toString()));
   }
   return new KeySpec(null, element.getAnnotation(BindExtra.class).value());
 }
  private void parseBindExtra(
      Element element,
      Map<TypeElement, IntentBindingAdapterGenerator> targetClassMap,
      Set<String> erasedTargetNames)
      throws InvalidTypeException {
    TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();

    // Verify that the target has all the appropriate information for type
    TypeMirror type = element.asType();
    if (type instanceof TypeVariable) {
      TypeVariable typeVariable = (TypeVariable) type;
      type = typeVariable.getUpperBound();
    }

    validateNotRequiredArguments(element);
    validateForCodeGeneration(BindExtra.class, element);
    validateBindingPackage(BindExtra.class, element);

    // Assemble information on the bind point
    String name = element.getSimpleName().toString();
    String intentType = typeUtil.getIntentType(type);
    KeySpec key = getKey(element);
    boolean required = element.getAnnotation(NotRequired.class) == null;
    boolean hasDefault = typeUtil.isPrimitive(type);
    boolean needsToBeCast = typeUtil.needToCastIntentType(type);

    IntentBindingAdapterGenerator intentBindingAdapterGenerator =
        getOrCreateTargetClass(targetClassMap, enclosingElement);
    IntentFieldBinding binding =
        new IntentFieldBinding(name, type, intentType, key, needsToBeCast, hasDefault, required);
    intentBindingAdapterGenerator.addField(binding);

    // Add the type-erased version to the valid targets set.
    erasedTargetNames.add(enclosingElement.toString());
  }
Esempio n. 12
0
 private void addResponseHeaders(RestActionClass actionClass, MethodSpec.Builder builder) {
   for (Element element : actionClass.getAnnotatedElements(ResponseHeader.class)) {
     ResponseHeader annotation = element.getAnnotation(ResponseHeader.class);
     String fieldAddress = getFieldAddress(actionClass, element);
     builder.addStatement(
         fieldAddress + " = $L.get($S)", element.toString(), BASE_HEADERS_MAP, annotation.value());
   }
 }
Esempio n. 13
0
 private boolean hasRelevantAnnotation(Element element) {
   for (Class<? extends Annotation> annotation : annotations) {
     if (element.getAnnotation(annotation) != null) {
       return true;
     }
   }
   return false;
 }
  public TableEndpointDefinition(Element typeElement, ProcessorManager processorManager) {
    super(typeElement, processorManager);

    TableEndpoint endpoint = typeElement.getAnnotation(TableEndpoint.class);

    tableName = endpoint.name();

    contentProviderName = endpoint.contentProviderName();

    isTopLevel = typeElement.getEnclosingElement() instanceof PackageElement;

    List<? extends Element> elements =
        processorManager.getElements().getAllMembers((TypeElement) typeElement);
    for (Element innerElement : elements) {
      if (innerElement.getAnnotation(ContentUri.class) != null) {
        ContentUriDefinition contentUriDefinition =
            new ContentUriDefinition(innerElement, processorManager);
        if (!pathValidationMap.containsKey(contentUriDefinition.path)) {
          contentUriDefinitions.add(contentUriDefinition);
        } else {
          processorManager.logError(
              "There must be unique paths for the specified @ContentUri" + " %1s from %1s",
              contentUriDefinition.name, contentProviderName);
        }
      } else if (innerElement.getAnnotation(Notify.class) != null) {
        NotifyDefinition notifyDefinition = new NotifyDefinition(innerElement, processorManager);

        for (String path : notifyDefinition.paths) {
          Map<Notify.Method, List<NotifyDefinition>> methodListMap =
              notifyDefinitionPathMap.get(path);
          if (methodListMap == null) {
            methodListMap = Maps.newHashMap();
            notifyDefinitionPathMap.put(path, methodListMap);
          }

          List<NotifyDefinition> notifyDefinitionList = methodListMap.get(notifyDefinition.method);
          if (notifyDefinitionList == null) {
            notifyDefinitionList = Lists.newArrayList();
            methodListMap.put(notifyDefinition.method, notifyDefinitionList);
          }
          notifyDefinitionList.add(notifyDefinition);
        }
      }
    }
  }
Esempio n. 15
0
 private void addRequestHeaders(RestActionClass actionClass, MethodSpec.Builder builder) {
   for (Element element : actionClass.getAnnotatedElements(RequestHeader.class)) {
     RequestHeader annotation = element.getAnnotation(RequestHeader.class);
     builder.beginControlFlow("if (action.$L != null)", element);
     builder.addStatement(
         "requestBuilder.addHeader($S, action.$L.toString())", annotation.value(), element);
     builder.endControlFlow();
   }
 }
Esempio n. 16
0
 private void parseLBindLayout(
     Element element,
     Map<TypeElement, BindingClass> targetClassMap,
     Set<String> erasedTargetNames) {
   String id = element.getAnnotation(LBindLayout.class).value();
   BindingClass bindingClass =
       getOrCreateTargetClass(targetClassMap, (TypeElement) element, true, false);
   bindingClass.setLayoutId(id);
 }
Esempio n. 17
0
 public static <T extends Annotation> T getAnnotation(
     final Class<T> annotationClass, final Element... elements) {
   for (final Element element : elements) {
     final T annotation = element.getAnnotation(annotationClass);
     if (annotation != null) {
       return annotation;
     }
   }
   return null;
 }
 /**
  * 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);
     }
   }
 }
 @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;
 }
  /*
   * Method to implement the @UsesObjectEquals functionality.
   * If a class is marked @UsesObjectEquals, it must:
   *
   *    -not override .equals(Object)
   *    -be a subclass of Object or another class marked @UsesObjectEquals
   *
   * If a class is not marked @UsesObjectEquals, it must:
   *
   * 	  -not have a superclass marked @UsesObjectEquals
   *
   *
   * @see org.checkerframework.common.basetype.BaseTypeVisitor#visitClass(com.sun.source.tree.ClassTree, java.lang.Object)
   */
  @Override
  public Void visitClass(ClassTree node, Void p) {
    // Looking for an @UsesObjectEquals class declaration

    TypeElement elt = TreeUtils.elementFromDeclaration(node);
    UsesObjectEquals annotation = elt.getAnnotation(UsesObjectEquals.class);

    Tree superClass = node.getExtendsClause();
    Element elmt = null;
    if (superClass != null
        && (superClass instanceof IdentifierTree || superClass instanceof MemberSelectTree)) {
      elmt = TreeUtils.elementFromUse((ExpressionTree) superClass);
    }

    // if it's there, check to make sure does not override equals
    // and supertype is Object or @UsesObjectEquals
    if (annotation != null) {
      // check methods to ensure no .equals
      if (overridesEquals(node)) {
        checker.report(Result.failure("overrides.equals"), node);
      }

      if (!(superClass == null
          || (elmt != null && elmt.getAnnotation(UsesObjectEquals.class) != null))) {
        checker.report(Result.failure("superclass.unmarked"), node);
      }
    } else {
      // the class is not marked @UsesObjectEquals -> make sure its superclass isn't either.
      // this is impossible after design change making @UsesObjectEquals inherited?
      // check left in case of future design change back to non-inherited.
      if (superClass != null
          && (elmt != null && elmt.getAnnotation(UsesObjectEquals.class) != null)) {
        checker.report(Result.failure("superclass.marked"), node);
      }
    }

    return super.visitClass(node, p);
  }
Esempio n. 21
0
 @Override
 public boolean process(
     final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnv) {
   System.out.println(roundEnv);
   System.out.println(annotations);
   for (Element elem : roundEnv.getElementsAnnotatedWith(Decoder.class)) {
     Decoder decoder = elem.getAnnotation(Decoder.class);
     String message =
         String.format(
             "Annotation found in %s with decoder %s.", elem.getSimpleName(), decoder.value());
     processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, message);
   }
   return true;
 }
  public ValidateDescriptor(ModelDescriptor modelDescriptor, Element field) {
    super(modelDescriptor, field);
    this.validateIf = field.getAnnotation(ValidateIf.class);
    this.validateIfValue = field.getAnnotation(ValidateIfValue.class);

    ProcessingEnvironment processingEnv = modelDescriptor.getProcessingEnvironment();
    Types typeUtils = processingEnv.getTypeUtils();
    this.isMethodValidation = getField().getKind().equals(ElementKind.METHOD);

    if (this.isMethodValidation) {
      // Make sure our method validation returns a boolean value
      if (!((ExecutableElement) this.field).getReturnType().getKind().equals(TypeKind.BOOLEAN)) {
        modelDescriptor
            .getMessager()
            .printMessage(
                Diagnostic.Kind.ERROR,
                "Methods annotated with @Validate must return a boolean value!",
                field);
      }

      methodAnnotation = getField().getAnnotation(Validate.class);
      if (this.methodAnnotation == null) {
        modelDescriptor
            .getMessager()
            .printMessage(Diagnostic.Kind.ERROR, "Could not retrieve method validation annotation");
      }
    } else {
      this.isList =
          typeUtils.isAssignable(
              field.asType(),
              typeUtils.getDeclaredType(
                  processingEnv
                      .getElementUtils()
                      .getTypeElement(ListContainer.class.getCanonicalName()),
                  typeUtils.getWildcardType(null, null)));
    }
  }
Esempio n. 23
0
  private void addResponses(RestActionClass actionClass, MethodSpec.Builder builder) {
    List<Element> responseElements =
        actionClass.getAnnotatedElements(com.santarest.annotations.Response.class);

    for (Element element : responseElements) {
      int status = element.getAnnotation(com.santarest.annotations.Response.class).value();
      if (status > 0) {
        builder.beginControlFlow("if(response.getStatus() == $L)", status);
        addResponseStatements(actionClass, builder, element);
        builder.endControlFlow();
      } else {
        addResponseStatements(actionClass, builder, element);
      }
    }
  }
    @Override
    public JsonElement visitUndefinedClass(DeclaredType t, Element el) {

      TypeMirror tm = t.asElement().asType();
      Element type = processingEnv.getTypeUtils().asElement(tm);
      JsonModel model = type.getAnnotation(JsonModel.class);
      String converterClassName = getConverterClassName(el);
      if (model == null && converterClassName == null) {
        Log.e("expect for use decorated class by JsonModel annotation.", el);
        encountError = true;
        return defaultAction(t, el);
      }

      return genJsonElement(t, el, Kind.MODEL);
    }
 String getElementKeyString(Element element) {
   JsonKey key = element.getAnnotation(JsonKey.class);
   JsonModel model = element.getEnclosingElement().getAnnotation(JsonModel.class);
   String keyStr;
   if (!"".equals(key.value())) {
     keyStr = key.value();
   } else if ("".equals(key.value()) && key.decamelize()) {
     keyStr = decamelize(element.toString());
   } else if ("".equals(key.value()) && model.decamelize()) {
     keyStr = decamelize(element.toString());
   } else {
     keyStr = element.toString();
   }
   return keyStr;
 }
 private void processMethodsOfView(EnclosingView enclosingView, Element view) {
   List<? extends Element> enclosedElements = view.getEnclosedElements();
   for (Element e : enclosedElements) {
     System.out.println("Method process: " + e.toString());
     ViewMethod viewMethod = new ViewMethod();
     viewMethod.setMethodName(elementTools.getFieldName(e));
     viewMethod.setReturnType(((ExecutableElement) e).getReturnType());
     viewMethod.setDecorate(e.getAnnotation(NoDecorate.class) == null);
     List<? extends VariableElement> parameters = ((ExecutableElement) e).getParameters();
     for (VariableElement parameterElement : parameters) {
       viewMethod.getParameters().add(parameterElement.asType());
     }
     enclosingView.getMethods().add(viewMethod);
   }
 }
Esempio n. 27
0
 private void addPathParams(RestActionClass actionClass, MethodSpec.Builder builder) {
   for (Element element : actionClass.getAnnotatedElements(Path.class)) {
     Path param = element.getAnnotation(Path.class);
     String path = param.value();
     String name = element.getSimpleName().toString();
     if (StringUtils.isEmpty(path)) {
       path = name;
     }
     boolean encode = param.encode();
     builder.beginControlFlow("if (action.$L != null)", name);
     builder.addStatement(
         "requestBuilder.addPathParam($S, action.$L.toString(), $L)", path, name, encode);
     builder.endControlFlow();
   }
 }
  @Override
  public void process(Element element, EIntentServiceHolder holder) throws Exception {

    ExecutableElement executableElement = (ExecutableElement) element;
    String methodName = element.getSimpleName().toString();

    ServiceAction annotation = element.getAnnotation(ServiceAction.class);
    String extraKey = annotation.value();
    if (extraKey.isEmpty()) {
      extraKey = methodName;
    }

    JFieldVar actionKeyField = createStaticActionField(holder, extraKey, methodName);
    addActionInOnHandleIntent(holder, executableElement, methodName, actionKeyField);
    addActionToIntentBuilder(holder, executableElement, methodName, actionKeyField);
  }
    JsonElement genJsonElement(TypeMirror t, Element el, Kind kind) {
      if (kind == null) {
        Log.e("invalid state. this is APT bugs.");
        encountError = true;
        return defaultAction(t, el);
      }

      JsonElement jsonElement = new JsonElement();
      jsonElement.setKey(getElementKeyString(el));

      JsonKey key = el.getAnnotation(JsonKey.class);

      String setter = getElementSetter(el);
      if (key.in() && setter == null) {
        Log.e("can't find setter method", el);
        encountError = true;
        return defaultAction(t, el);
      }

      String getter = getElementGetter(el);
      if (key.out() && getter == null) {
        Log.e("can't find getter method", el);
        encountError = true;
        return defaultAction(t, el);
      }

      String converterClassName = getConverterClassName(el);
      if (converterClassName != null) {
        TypeElement element = processingEnv.getElementUtils().getTypeElement(converterClassName);
        Log.d(element != null ? element.asType().toString() : null);
        if (element == null
            || !isMethodExists(element, "getInstance", Modifier.PUBLIC, Modifier.STATIC)) {
          Log.e("converter needs [public static getInstance()].", element);
        }
        kind = Kind.CONVERTER;
      }

      jsonElement.setIn(key.in());
      jsonElement.setSetter(setter);
      jsonElement.setOut(key.out());
      jsonElement.setGetter(getter);
      jsonElement.setModelName(t.toString());
      jsonElement.setKind(kind);
      jsonElement.setConverter(converterClassName);

      return jsonElement;
    }
Esempio n. 30
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
  }