Example usage for javax.lang.model.type TypeMirror toString

List of usage examples for javax.lang.model.type TypeMirror toString

  1. HOME
  2. Java
  3. javax
  4. javax.lang.model.type.*
  5. TypeMirror
  6. toString

Introduction

In this page you can find the example usage for javax.lang.model.type TypeMirror toString.

Prototype

String toString();

Source Link

Document

Returns an informative string representation of this type.

Usage

From source file:org.kie.workbench.common.stunner.core.processors.MainProcessor.java

private void processDefinitionModelBuilder(final Element e, final String className,
        final Map<String, String> processingContextMap) {
    Definition definitionAnn = e.getAnnotation(Definition.class);
    TypeMirror bMirror = null;
    try {//from  www  . j  av a 2 s .c o  m
        Class<?> builderClass = definitionAnn.builder();
    } catch (MirroredTypeException mte) {
        bMirror = mte.getTypeMirror();
    }
    if (null != bMirror && !VoidBuilder.class.getName().equals(bMirror.toString())) {
        String fqcn = bMirror.toString();
        processingContextMap.put(className, fqcn);
    }
}

From source file:org.kie.workbench.common.stunner.core.processors.MainProcessor.java

private void processDefinitionSetModelBuilder(final Element e, final String className,
        final Map<String, String> processingContextMap) {
    DefinitionSet definitionAnn = e.getAnnotation(DefinitionSet.class);
    TypeMirror bMirror = null;
    try {//w  w  w  . j  ava  2  s. c o m
        Class<?> builderClass = definitionAnn.builder();
    } catch (MirroredTypeException mte) {
        bMirror = mte.getTypeMirror();
    }
    if (null != bMirror && !VoidBuilder.class.getName().equals(bMirror.toString())) {
        String fqcn = bMirror.toString();
        processingContextMap.put(className, fqcn);
    }
}

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void allowedType(Element element, IsValid valid, TypeMirror fieldTypeMirror, List<String> allowedTypes) {

    String qualifiedName = fieldTypeMirror.toString();

    if (!allowedTypes.contains(qualifiedName)) {
        valid.invalidate();//w  w  w .j  ava  2 s  . c o m
        annotationHelper.printAnnotationError(element, "%s can only be used on a field which is a "
                + allowedTypes.toString() + ", not " + qualifiedName);
    }
}

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void hasSetOfHttpMethodReturnType(ExecutableElement element, IsValid valid) {
    TypeMirror returnType = element.getReturnType();
    String returnTypeString = returnType.toString();
    if (!returnTypeString.equals("java.util.Set<org.springframework.http.HttpMethod>")) {
        valid.invalidate();/*from w  w  w. j ava  2  s. c  om*/
        annotationHelper.printAnnotationError(element,
                "%s annotated methods can only return a Set of HttpMethod, not " + returnTypeString);
    } else {
        DeclaredType declaredType = (DeclaredType) returnType;
        List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments();
        if (typeArguments.size() != 1) {
            valid.invalidate();
            annotationHelper.printAnnotationError(element,
                    "%s annotated methods can only return a parameterized Set (with HttpMethod)");
        } else {
            TypeMirror typeArgument = typeArguments.get(0);
            if (!typeArgument.toString().equals("org.springframework.http.HttpMethod")) {
                valid.invalidate();
                annotationHelper.printAnnotationError(element,
                        "%s annotated methods can only return a parameterized Set of HttpMethod, not "
                                + typeArgument.toString());
            }
        }
    }
}

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void zeroOrOneSpecificParameter(ExecutableElement executableElement,
        List<String> parameterTypeQualifiedNames, IsValid valid) {

    zeroOrOneParameter(executableElement, valid);

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

    if (parameters.size() == 1) {
        VariableElement parameter = parameters.get(0);
        TypeMirror parameterType = parameter.asType();
        if (!parameterTypeQualifiedNames.contains(parameterType.toString())) {
            valid.invalidate();// w w  w  . j  av a 2s. co  m
            annotationHelper.printAnnotationError(executableElement,
                    "%s can only be used on a method with no parameter or a parameter of type "
                            + parameterTypeQualifiedNames + ", not " + parameterType);
        }
    }
}

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void unannotatedMethodReturnsRestTemplate(TypeElement typeElement, IsValid valid) {
    List<? extends Element> enclosedElements = typeElement.getEnclosedElements();
    boolean foundGetRestTemplateMethod = false;
    boolean foundSetRestTemplateMethod = false;
    boolean foundSetRootUrlMethod = false;
    for (Element enclosedElement : enclosedElements) {
        if (enclosedElement.getKind() != ElementKind.METHOD) {
            valid.invalidate();/*  ww w  .j  a va2s.  c o m*/
            annotationHelper.printError(enclosedElement, "Only methods are allowed in a "
                    + TargetAnnotationHelper.annotationName(Rest.class) + " annotated interface");
        } else {

            boolean hasRestAnnotation = false;
            for (Class<? extends Annotation> annotationClass : REST_ANNOTATION_CLASSES) {
                if (enclosedElement.getAnnotation(annotationClass) != null) {
                    hasRestAnnotation = true;
                    break;
                }
            }

            if (!hasRestAnnotation) {
                ExecutableElement executableElement = (ExecutableElement) enclosedElement;
                TypeMirror returnType = executableElement.getReturnType();
                if (returnType.toString().equals(CanonicalNameConstants.REST_TEMPLATE)) {
                    if (executableElement.getParameters().size() > 0) {
                        valid.invalidate();
                        annotationHelper.printError(enclosedElement,
                                "The method returning a RestTemplate should not declare any parameter in a "
                                        + TargetAnnotationHelper.annotationName(Rest.class)
                                        + " annotated interface");
                    } else {
                        if (foundGetRestTemplateMethod) {
                            valid.invalidate();
                            annotationHelper.printError(enclosedElement,
                                    "Only one method should declare returning a RestTemplate in a "
                                            + TargetAnnotationHelper.annotationName(Rest.class)
                                            + " annotated interface");
                        } else {
                            foundGetRestTemplateMethod = true;
                        }
                    }
                } else if (returnType.getKind() == TypeKind.VOID) {
                    List<? extends VariableElement> parameters = executableElement.getParameters();
                    if (parameters.size() == 1) {
                        VariableElement firstParameter = parameters.get(0);
                        if (firstParameter.asType().toString().equals(CanonicalNameConstants.REST_TEMPLATE)) {
                            if (!foundSetRestTemplateMethod) {
                                foundSetRestTemplateMethod = true;
                            } else {
                                valid.invalidate();
                                annotationHelper.printError(enclosedElement,
                                        "You can only have oneRestTemplate setter method on a "
                                                + TargetAnnotationHelper.annotationName(Rest.class)
                                                + " annotated interface");

                            }
                        } else if (executableElement.getSimpleName().toString().equals(METHOD_NAME_SET_ROOT_URL)
                                && !foundSetRootUrlMethod) {
                            foundSetRootUrlMethod = true;
                        } else {
                            valid.invalidate();
                            annotationHelper.printError(enclosedElement,
                                    "The method to set a RestTemplate should have only one RestTemplate parameter on a "
                                            + TargetAnnotationHelper.annotationName(Rest.class)
                                            + " annotated interface");

                        }
                    } else {
                        valid.invalidate();
                        annotationHelper.printError(enclosedElement,
                                "The method to set a RestTemplate should have only one RestTemplate parameter on a "
                                        + TargetAnnotationHelper.annotationName(Rest.class)
                                        + " annotated interface");
                    }
                } else {
                    valid.invalidate();
                    annotationHelper.printError(enclosedElement, "All methods should be annotated in a "
                            + TargetAnnotationHelper.annotationName(Rest.class)
                            + " annotated interface, except the ones that returns or set a RestTemplate");
                }
            }
        }
    }
}

From source file:org.kie.workbench.common.stunner.core.processors.MainProcessor.java

private boolean processDefinitionSets(final Set<? extends TypeElement> set, final Element e,
        final RoundEnvironment roundEnv) throws Exception {
    final Messager messager = processingEnv.getMessager();
    final boolean isClass = e.getKind() == ElementKind.CLASS;
    if (isClass) {
        TypeElement classElement = (TypeElement) e;
        PackageElement packageElement = (PackageElement) classElement.getEnclosingElement();
        messager.printMessage(Diagnostic.Kind.NOTE,
                "Discovered definition set class [" + classElement.getSimpleName() + "]");
        final String packageName = packageElement.getQualifiedName().toString();
        final String className = classElement.getSimpleName().toString();
        processingContext.setDefinitionSet(packageName, className);
        String defSetClassName = packageName + "." + className;
        // Description fields.
        processFieldName(classElement, defSetClassName, ANNOTATION_DESCRIPTION,
                processingContext.getDefSetAnnotations().getDescriptionFieldNames(), true);
        // Definitions identifiers.
        DefinitionSet definitionSetAnn = e.getAnnotation(DefinitionSet.class);
        List<? extends TypeMirror> mirrors = null;
        try {//from  ww  w .j ava2s .com
            Class<?>[] defsClasses = definitionSetAnn.definitions();
        } catch (MirroredTypesException mte) {
            mirrors = mte.getTypeMirrors();
        }
        if (null == mirrors) {
            throw new RuntimeException("No graph class class specifyed for the @DefinitionSet.");
        }
        Set<String> defIds = new LinkedHashSet<>();
        for (TypeMirror mirror : mirrors) {
            if (mirror.getKind().equals(TypeKind.DECLARED)) {
                final TypeElement t = (TypeElement) ((DeclaredType) mirror).asElement();
                processingContext.getDefinitionElements().add(t);
            }
            String fqcn = mirror.toString();
            defIds.add(fqcn);
        }
        processingContext.getDefSetAnnotations().getDefinitionIds().addAll(defIds);
        // Builder class.
        processDefinitionSetModelBuilder(e, defSetClassName,
                processingContext.getDefSetAnnotations().getBuilderFieldNames());
        // Graph factory type.
        TypeMirror mirror = null;
        try {
            Class<?> graphClass = definitionSetAnn.graphFactory();
        } catch (MirroredTypeException mte) {
            mirror = mte.getTypeMirror();
        }
        if (null == mirror) {
            throw new RuntimeException("No graph factory class specifyed for the @DefinitionSet.");
        }
        String fqcn = mirror.toString();
        processingContext.getDefSetAnnotations().getGraphFactoryTypes().put(defSetClassName, fqcn);
        // Definition Set's qualifier.
        try {
            Class<?> qualifierClass = definitionSetAnn.qualifier();
        } catch (MirroredTypeException mte) {
            mirror = mte.getTypeMirror();
        }
        if (null == mirror) {
            throw new RuntimeException("No qualifier class specifyed for the @DefinitionSet.");
        }
        processingContext.getDefSetAnnotations().getQualifiers().put(defSetClassName, mirror.toString());
    }
    return true;
}

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void returnTypeIsVoidOrBoolean(ExecutableElement executableElement, IsValid valid) {
    TypeMirror returnType = executableElement.getReturnType();

    TypeKind returnKind = returnType.getKind();

    if (returnKind != TypeKind.BOOLEAN && returnKind != TypeKind.VOID
            && !returnType.toString().equals("java.lang.Boolean")) {
        valid.invalidate();//  w w  w.  j  a  va 2  s  . c  o m
        annotationHelper.printAnnotationError(executableElement,
                "%s can only be used on a method with a boolean or a void return type");
    }
}

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void androidService(AndroidSystemServices androidSystemServices, Element element, IsValid valid) {
    TypeMirror serviceType = element.asType();
    if (!androidSystemServices.contains(serviceType)) {
        valid.invalidate();//  w w  w.j  a  v  a2 s.c om
        annotationHelper.printAnnotationError(element, "Unknown service type: " + serviceType.toString());
    }
}

From source file:com.googlecode.androidannotations.helper.ValidatorHelper.java

public void isSharedPreference(Element element, AnnotationElements validatedElements, IsValid valid) {

    TypeMirror type = element.asType();

    /*/*from  w  ww  .j ava  2 s.  c om*/
     * The type is not available yet because it has just been generated
     */
    if (type instanceof ErrorType) {
        String elementTypeName = type.toString();

        boolean sharedPrefValidatedInRound = false;
        if (elementTypeName.endsWith(GENERATION_SUFFIX)) {
            String prefTypeName = elementTypeName.substring(0,
                    elementTypeName.length() - GENERATION_SUFFIX.length());

            Set<? extends Element> sharedPrefElements = validatedElements
                    .getRootAnnotatedElements(SharedPref.class.getName());

            for (Element sharedPrefElement : sharedPrefElements) {
                TypeElement sharedPrefTypeElement = (TypeElement) sharedPrefElement;

                String sharedPrefQualifiedName = sharedPrefTypeElement.getQualifiedName().toString();

                if (sharedPrefQualifiedName.endsWith(prefTypeName)) {
                    sharedPrefValidatedInRound = true;
                    break;
                }
            }
        }

        if (!sharedPrefValidatedInRound) {
            valid.invalidate();
        }

    } else {
        extendsType(element, SharedPreferencesHelper.class.getName(), valid);
    }

}