Example usage for javax.lang.model.element ExecutableElement getReturnType

List of usage examples for javax.lang.model.element ExecutableElement getReturnType

  1. HOME
  2. Java
  3. javax
  4. javax.lang.model.element.*
  5. ExecutableElement
  6. getReturnType

Introduction

In this page you can find the example usage for javax.lang.model.element ExecutableElement getReturnType.

Prototype

TypeMirror getReturnType();

Source Link

Document

Returns the return type of this executable.

Usage

From source file:de.hasait.genesis.base.util.GenesisUtils.java

public static TypeMirror determinePropertyTypeFromAccessor(final Element pElement) {
    if (isGetter(pElement)) {
        final ExecutableElement element = (ExecutableElement) pElement;
        return element.getReturnType();
    }/*from  w  ww. j  a v a  2 s.co m*/

    if (isSetter(pElement)) {
        final ExecutableElement element = (ExecutableElement) pElement;
        return element.getParameters().get(0).asType();
    }

    return null;
}

From source file:de.hasait.genesis.base.util.GenesisUtils.java

public static boolean isGetter(final Element pElement, final String pPrefix) {
    GenesisUtils.assertNotNull(pPrefix);

    if (isPublicMemberMethod(pElement)) {
        final ExecutableElement element = (ExecutableElement) pElement;
        final String simpleName = element.getSimpleName().toString();
        return simpleName.startsWith(pPrefix) && simpleName.length() > pPrefix.length() //
                && element.getReturnType() != null && element.getParameters().isEmpty() //
        ;/*ww  w.  j a  va  2 s  .  c o m*/
    }

    return false;
}

From source file:org.leandreck.endpoints.processor.model.MethodNodeFactory.java

private TypeNode defineReturnType(final ExecutableElement methodElement, final DeclaredType containingType) {
    final TypeMirror returnMirror = methodElement.getReturnType();
    return typeNodeFactory.createTypeNode(returnMirror, containingType);
}

From source file:com.github.pellaton.springconfigvalidation.SpringConfigurationValidationProcessor.java

private void processForReturnType(ExecutableElement methodElement) {
    if (methodElement.getReturnType().getKind() == TypeKind.VOID) {
        printMessage(SpringConfigurationMessage.BEAN_METHOD_RETURNS_VOID, methodElement);
    }/*w  w  w  .j  a  v  a 2 s  . c o m*/
}

From source file:com.googlecode.androidannotations.processing.rest.RestProcessor.java

@Override
public void process(Element element, JCodeModel codeModel, EBeansHolder activitiesHolder) throws Exception {

    RestImplementationHolder holder = restImplementationHolder.create(element);

    TypeElement typeElement = (TypeElement) element;

    holder.urlPrefix = typeElement.getAnnotation(Rest.class).value();

    String interfaceName = typeElement.getQualifiedName().toString();

    String implementationName = interfaceName + ModelConstants.GENERATION_SUFFIX;

    // holder.restImplementationClass = codeModel._class(JMod.PUBLIC |
    // JMod.ABSTRACT, implementationName, ClassType.CLASS);
    holder.restImplementationClass = codeModel._class(JMod.PUBLIC, implementationName, ClassType.CLASS);
    JClass interfaceClass = holder.refClass(interfaceName);
    holder.restImplementationClass._implements(interfaceClass);

    // RestTemplate field
    JClass restTemplateClass = holder.refClass(SPRING_REST_TEMPLATE_QUALIFIED_NAME);
    holder.restTemplateField = holder.restImplementationClass.field(JMod.PRIVATE, restTemplateClass,
            "restTemplate");

    // Default constructor
    JMethod defaultConstructor = holder.restImplementationClass.constructor(JMod.PUBLIC);
    defaultConstructor.body().assign(holder.restTemplateField, JExpr._new(restTemplateClass));

    // RestTemplate constructor
    JMethod restTemplateConstructor = holder.restImplementationClass.constructor(JMod.PUBLIC);
    JVar restTemplateParam = restTemplateConstructor.param(restTemplateClass, "restTemplate");
    restTemplateConstructor.body().assign(JExpr._this().ref(holder.restTemplateField), restTemplateParam);

    // RequestFactory constructor
    JMethod requestFactoryConstructor = holder.restImplementationClass.constructor(JMod.PUBLIC);
    JClass requestFactoryClass = holder.refClass("org.springframework.http.client.ClientHttpRequestFactory");
    JVar requestFactoryParam = requestFactoryConstructor.param(requestFactoryClass, "requestFactory");
    requestFactoryConstructor.body().assign(holder.restTemplateField,
            JExpr._new(restTemplateClass).arg(requestFactoryParam));

    // Implement getRestTemplate method
    List<? extends Element> enclosedElements = typeElement.getEnclosedElements();
    List<ExecutableElement> methods = ElementFilter.methodsIn(enclosedElements);
    for (ExecutableElement method : methods) {
        if (method.getParameters().size() == 0
                && method.getReturnType().toString().equals(SPRING_REST_TEMPLATE_QUALIFIED_NAME)) {
            String methodName = method.getSimpleName().toString();
            JMethod getRestTemplateMethod = holder.restImplementationClass.method(JMod.PUBLIC,
                    restTemplateClass, methodName);
            getRestTemplateMethod.annotate(Override.class);
            getRestTemplateMethod.body()._return(holder.restTemplateField);
            break; // Only one implementation
        }//ww  w.j  a  v a2s. c o m
    }

    for (ExecutableElement method : methods) {
        List<? extends VariableElement> parameters = method.getParameters();
        if (parameters.size() == 1 && method.getReturnType().getKind() == TypeKind.VOID) {
            VariableElement firstParameter = parameters.get(0);
            if (firstParameter.asType().toString().equals(SPRING_REST_TEMPLATE_QUALIFIED_NAME)) {
                String methodName = method.getSimpleName().toString();
                JMethod setRestTemplateMethod = holder.restImplementationClass.method(JMod.PUBLIC,
                        codeModel.VOID, methodName);
                setRestTemplateMethod.annotate(Override.class);

                JVar restTemplateSetterParam = setRestTemplateMethod.param(restTemplateClass,
                        firstParameter.getSimpleName().toString());

                setRestTemplateMethod.body().assign(_this().ref(holder.restTemplateField),
                        restTemplateSetterParam);
                break; // Only one implementation
            }
        }
    }

}

From source file:io.wcm.tooling.netbeans.sightly.completion.classLookup.MemberLookupResolver.java

private Set<MemberLookupResult> getMethodsFromJavaSource(String clazzname, String variable) {
    Set<MemberLookupResult> ret = new LinkedHashSet<>();
    ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() {
        @Override//from   w w w.  j a  v a  2 s .  c  om
        public boolean accept(Element e, TypeMirror type) {
            // we accept only public stuff
            if (!e.getModifiers().contains(Modifier.PUBLIC)) {
                return false;
            }
            if (e.getKind() == ElementKind.METHOD) {
                ExecutableElement method = (ExecutableElement) e;
                if (method.getReturnType().getKind() != TypeKind.VOID) {
                    return GETTER_PATTERN.matcher(e.getSimpleName().toString()).matches();
                }
            }
            return e.getKind() == ElementKind.FIELD;
        }
    };

    Set<Element> elems = getMembersFromJavaSource(clazzname, acceptor);
    for (Element e : elems) {
        if (e.getKind() == ElementKind.METHOD) {
            ExecutableElement method = (ExecutableElement) e;
            MemberLookupResult result = new MemberLookupResult(variable, e.getSimpleName().toString(),
                    method.getReturnType().toString());
            ret.add(result);
        } else if (e.getKind() == ElementKind.FIELD) {
            MemberLookupResult result = new MemberLookupResult(variable, e.getSimpleName().toString(),
                    e.asType().toString());
            ret.add(result);
        }
    }
    return ret;
}

From source file:dagger.android.processor.AndroidMapKeyValidator.java

private void validateMethod(Class<? extends Annotation> annotation, ExecutableElement method) {
    if (!getAnnotatedAnnotations(method, Qualifier.class).isEmpty()) {
        return;//from   w w w  .  j  ava2  s . c  o  m
    }

    TypeMirror returnType = method.getReturnType();
    if (!types.isAssignable(types.erasure(returnType), factoryElement().asType())) {
        // if returnType is not related to AndroidInjector.Factory, ignore the method
        return;
    }

    DeclaredType intendedReturnType = injectorFactoryOf(
            types.getWildcardType(androidTypeForMapKey(annotation), null));
    if (!MoreTypes.equivalence().equivalent(returnType, intendedReturnType)) {
        messager.printMessage(Kind.ERROR, String.format("@%s methods should bind %s, not %s. See %s",
                annotation.getCanonicalName(), intendedReturnType, returnType, LINK_TO_DOCS), method);
    }

    // @Binds methods should only have one parameter, but we can't guarantee the order of Processors
    // in javac, so do a basic check for valid form
    if (isAnnotationPresent(method, Binds.class) && method.getParameters().size() == 1) {
        validateMapKeyMatchesBindsParameter(annotation, method);
    }
}

From source file:cop.raml.utils.ImportScanner.java

@Override
public Void visitExecutable(ExecutableElement element, DirectoryStream.Filter<String> filter) {
    if (element.getReturnType().getKind() == TypeKind.DECLARED)
        addAcceptedType(element.getReturnType().toString(), filter);
    return super.visitExecutable(element, filter);
}

From source file:com.github.pellaton.springconfigvalidation.SpringConfigurationValidationProcessor.java

private void processForBFPP(ExecutableElement methodElement) {
    boolean implementsBFPP = this.typeUtils.isAssignable(methodElement.getReturnType(),
            this.bfppTypeElement.asType());
    boolean isStaticMethod = isStaticMethod(methodElement);
    if (isStaticMethod) {
        if (!implementsBFPP) {
            printMessage(SpringConfigurationMessage.STATIC_BEAN_METHOD, methodElement);
        }//w  w  w  .  ja  v  a  2s  . co  m
    } else {
        if (implementsBFPP) {
            printMessage(SpringConfigurationMessage.BFPP_BEAN_METHOD_NOT_STATIC, methodElement);
        }
    }
}

From source file:org.ez18n.apt.processor.LabelBundleProcessor.java

private void processLabels(TypeElement resourcesType, List<LabelTemplateMethod> methods) {
    for (Element element : resourcesType.getEnclosedElements()) {
        if (element.getKind() != ElementKind.METHOD) {
            continue;
        }//from  w  w  w . jav a 2s.co  m
        final ExecutableElement method = (ExecutableElement) element;
        Message labelAnnotation = element.getAnnotation(Message.class);
        final TemplateParam returnType = new TemplateParam(method.getReturnType().toString());
        final boolean deprecated = method.getAnnotation(Deprecated.class) != null;
        final LabelTemplateMethod labelMethod;
        try {
            labelMethod = new LabelTemplateMethod(method.getSimpleName().toString(), deprecated, returnType,
                    labelAnnotation.value(), labelAnnotation.mobile());
        } catch (Throwable t) {
            processingEnv.getMessager().printMessage(Kind.WARNING, t.getMessage(), resourcesType);
            continue;
        }

        for (VariableElement variable : method.getParameters()) {
            final String paramName = variable.getSimpleName().toString();
            final String paramType = variable.asType().toString();

            List<TemplateAnnotation> annotations = new ArrayList<TemplateAnnotation>();
            for (AnnotationMirror annotationMirrors : variable.getAnnotationMirrors()) {
                annotations.add(new TemplateAnnotation(annotationMirrors.getAnnotationType().toString()));
            }

            labelMethod.getParams().add(new TemplateParam(paramType, paramName, annotations));
        }
        methods.add(labelMethod);
    }
}