Example usage for javax.lang.model.element ElementKind METHOD

Introduction

In this page you can find the example usage for javax.lang.model.element ElementKind METHOD.

Prototype

ElementKind METHOD

To view the source code for javax.lang.model.element ElementKind METHOD.

Click Source Link

Document

A method.

Usage

From source file:org.jdto.tools.ModelUtils.java

public static ExecutableElement findGetterOnType(TypeElement element, String name) {

    for (Element enclosedElement : element.getEnclosedElements()) {
        if (enclosedElement.getKind() != ElementKind.METHOD) {
            continue;
        }/*  www  .j  a va  2 s  . com*/

        String elementName = enclosedElement.getSimpleName().toString();

        if (elementName.startsWith("get")) {

            elementName = StringUtils.uncapitalize(elementName.substring(3));

            if (name.equals(elementName)) {
                return (ExecutableElement) enclosedElement;
            }
        }

        if (elementName.startsWith("is")) {

            elementName = StringUtils.uncapitalize(elementName.substring(2));

            if (name.equals(elementName)) {
                return (ExecutableElement) enclosedElement;
            }
        }

    }

    return null;
}

---

From source file:org.jdto.tools.ModelUtils.java

public static ExecutableElement findSetterOnType(TypeElement element, String name) {
    for (Element enclosedElement : element.getEnclosedElements()) {
        if (enclosedElement.getKind() != ElementKind.METHOD) {
            continue;
        }/*w ww . ja  v  a2 s .co  m*/

        String elementName = enclosedElement.getSimpleName().toString();

        if (elementName.startsWith("set")) {

            elementName = StringUtils.uncapitalize(elementName.substring(3));

            if (name.equals(elementName)) {
                return (ExecutableElement) enclosedElement;
            }
        }

    }

    return null;
}

---

From source file:com.ym.easyipc.processor.AnnotationProcessor.java

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    jobs = new HashMap<TypeElement, List<ExecutableElement>>();
    try {//from  ww  w.j  a  v  a 2s . co  m
        for (Element elem : roundEnv.getElementsAnnotatedWith(EasyIPCMethod.class)) {
            if (elem.getKind() != ElementKind.METHOD)
                throw new Exception("only methods can be marked by EasyIPCMethod");
            ExecutableElement methodElem = (ExecutableElement) elem;
            TypeElement classElem = (TypeElement) methodElem.getEnclosingElement();

            if (jobs.get(classElem) == null) {
                jobs.put(classElem, new ArrayList<ExecutableElement>());
            }
            jobs.get(classElem).add(methodElem);
        }

        boolean hasListenerJobs = false;
        for (Element elem : roundEnv.getElementsAnnotatedWith(EasyIPCListener.class)) {
            hasListenerJobs = true;
            new ListenerGenerator(processingEnv, roundEnv, (TypeElement) elem).generateClass();
        }

        if (hasListenerJobs || !jobs.isEmpty()) {
            new Generator(processingEnv, roundEnv, jobs).generate();
            return true;
        }

    } catch (Exception e) {
        processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
                "failed to generate EasyIPC classes:\n " + ExceptionUtils.getFullStackTrace(e));

    }
    return false;
}

---

From source file:org.jdto.tools.AnnotationConfigVerifier.java

private boolean elementIsRelevant(Element enclElement) {

    if (enclElement.getKind() != ElementKind.METHOD) {
        return false;
    }//from w  w w.  ja  v a2s .c  o  m

    String strRep = enclElement.getSimpleName().toString();

    if (StringUtils.startsWith(strRep, "get") || StringUtils.startsWith(strRep, "is")) {
        return true;
    }

    return false;
}

---

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  ww  w  .j  av a  2  s. 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);
    }
}

---

From source file:com.github.alexfalappa.nbspringboot.navigator.MappedElementExtractor.java

@Override
public List visitClass(final ClassTree node, final Void p) {
    final List<MappedElement> mappedElements = new ArrayList<>();
    if (canceled || node == null) {
        return mappedElements;
    }//from w  w  w.  j a  v a 2s.c o m
    final Element clazz = trees.getElement(new TreePath(rootPath, node));
    if (clazz == null || (clazz.getAnnotation(Controller.class) == null
            && clazz.getAnnotation(RestController.class) == null)) {
        return mappedElements;
    }
    final RequestMapping parentRequestMapping = clazz.getAnnotation(RequestMapping.class);
    final Map<String, List<RequestMethod>> parentUrls = extractTypeLevelMappings(parentRequestMapping);
    for (Element enclosedElement : clazz.getEnclosedElements()) {
        if (enclosedElement.getKind() != ElementKind.METHOD) {
            continue;
        }
        final Map<String, List<RequestMethod>> elementUrls = new TreeMap<>();
        final RequestMapping requestMapping = enclosedElement.getAnnotation(RequestMapping.class);
        if (requestMapping != null) {
            extractMethodLevelMappings(elementUrls, concatValues(requestMapping.value(), requestMapping.path()),
                    requestMapping.method());
        }
        final DeleteMapping deleteMapping = enclosedElement.getAnnotation(DeleteMapping.class);
        if (deleteMapping != null) {
            extractMethodLevelMappings(elementUrls, concatValues(deleteMapping.value(), deleteMapping.path()),
                    new RequestMethod[] { RequestMethod.DELETE });
        }
        final GetMapping getMapping = enclosedElement.getAnnotation(GetMapping.class);
        if (getMapping != null) {
            extractMethodLevelMappings(elementUrls, concatValues(getMapping.value(), getMapping.path()),
                    new RequestMethod[] { RequestMethod.GET });
        }
        final PatchMapping patchMapping = enclosedElement.getAnnotation(PatchMapping.class);
        if (patchMapping != null) {
            extractMethodLevelMappings(elementUrls, concatValues(patchMapping.value(), patchMapping.path()),
                    new RequestMethod[] { RequestMethod.PATCH });
        }
        final PostMapping postMapping = enclosedElement.getAnnotation(PostMapping.class);
        if (postMapping != null) {
            extractMethodLevelMappings(elementUrls, concatValues(postMapping.value(), postMapping.path()),
                    new RequestMethod[] { RequestMethod.POST });
        }
        final PutMapping putMapping = enclosedElement.getAnnotation(PutMapping.class);
        if (putMapping != null) {
            extractMethodLevelMappings(elementUrls, concatValues(putMapping.value(), putMapping.path()),
                    new RequestMethod[] { RequestMethod.PUT });
        }

        for (Map.Entry<String, List<RequestMethod>> methodLevelMapping : elementUrls.entrySet()) {
            for (Map.Entry<String, List<RequestMethod>> typeLevelMapping : parentUrls.entrySet()) {
                final String url = pathMatcher.combine(typeLevelMapping.getKey(), methodLevelMapping.getKey());

                final List<RequestMethod> effectiveMethods = new ArrayList<>();
                if (methodLevelMapping.getValue().isEmpty()) {
                    effectiveMethods.add(null);
                }
                effectiveMethods.addAll(methodLevelMapping.getValue());
                if (!typeLevelMapping.getValue().isEmpty()) {
                    effectiveMethods.retainAll(typeLevelMapping.getValue());
                }

                for (RequestMethod effectiveMethod : effectiveMethods) {
                    mappedElements
                            .add(new MappedElement(this.fileObject, enclosedElement, url, effectiveMethod));
                }
            }
        }
    }
    return mappedElements;
}

---

From source file:therian.buildweaver.StandardOperatorsProcessor.java

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    try {/*from   www.j av a 2 s .  co m*/
        final FileObject resource = processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT,
                StringUtils.substringBeforeLast(TARGET_CLASSNAME, ".").replace('.', '/'),
                StringUtils.substringAfterLast(TARGET_CLASSNAME, ".") + ".class");

        if (resource.getLastModified() > 0L) {
            processingEnv.getMessager().printMessage(Kind.NOTE,
                    String.format("%s already generated", TARGET_CLASSNAME));
            return false;
        }
    } catch (IOException e1) {
        // expected, swallow
    }
    try {
        ClassUtils.getClass(TARGET_CLASSNAME);
        processingEnv.getMessager().printMessage(Kind.ERROR,
                String.format("%s exists on classpath", TARGET_CLASSNAME));
        return false;
    } catch (ClassNotFoundException e) {
        // expected, swallow
    }

    if (roundEnv.processingOver()) {
        write();
        return true;
    }
    for (TypeElement ann : annotations) {
        final Set<? extends Element> standardOperatorElements = roundEnv.getElementsAnnotatedWith(ann);
        originatingElements.addAll(standardOperatorElements);

        for (Element element : standardOperatorElements) {
            Validate.validState(isValidStandardOperator(element), "%s is not a valid @StandardOperator",
                    appendTo(new StringBuilder(), element).toString());

            if (element.getKind() == ElementKind.CLASS) {
                operators.add(appendTo(new StringBuilder("new "), element).append("()").toString());
            }
            if (element.getKind() == ElementKind.METHOD) {
                operators.add(appendTo(new StringBuilder(), element).append("()").toString());
            }
            if (element.getKind() == ElementKind.FIELD) {
                operators.add(appendTo(new StringBuilder(), element).toString());
            }
        }
    }
    return true;
}

---

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

public static boolean isPublicMemberMethod(final Element pElement) {
    if (pElement != null && pElement.getKind() == ElementKind.METHOD) {
        final Set<Modifier> modifiers = pElement.getModifiers();
        return modifiers.contains(Modifier.PUBLIC) && !modifiers.contains(Modifier.STATIC);
    }/*  www.  j  a  va2s  . c  om*/

    return false;
}

---

From source file:com.dspot.declex.override.holder.FragmentActionHolder.java

public static void addFragmentArg(ActionInfo actionInfo, Element element, AndroidAnnotationsEnvironment env) {

    APTCodeModelHelper codeModelHelper = new DeclexAPTCodeModelHelper(env);

    final String clsName = element.getEnclosingElement().asType().toString();
    final int index = clsName.lastIndexOf('.');
    final String pkg = clsName.substring(0, index);
    final String fragmentName = clsName.substring(index + 1);
    final String actionName = pkg + "." + fragmentName + "ActionHolder";

    final String elementName = element.getSimpleName().toString();
    if (element.getKind().isField()) {
        final AbstractJClass clazz = codeModelHelper.elementTypeToJClass(element);
        actionInfo.addMethod(elementName, actionName, Arrays.asList(new ActionMethodParam(elementName, clazz)));

    } else if (element.getKind() == ElementKind.METHOD) {

        List<? extends VariableElement> elementParams = ((ExecutableElement) element).getParameters();
        List<ActionMethodParam> params = new ArrayList<>(elementParams.size());

        for (VariableElement param : elementParams) {
            final String paramName = param.getSimpleName().toString();
            final AbstractJClass paramClass = codeModelHelper.elementTypeToJClass(param);
            params.add(new ActionMethodParam(paramName, paramClass));
        }/*from   www . j  a  v  a  2  s.c  om*/

        actionInfo.addMethod(elementName, actionName, params);
    }
}

---

From source file:therian.buildweaver.StandardOperatorsProcessor.java

/**
 * Must be a public static concrete class with a default constructor, public static zero-arg method, or public
 * static final field.//w w  w. j av  a2s . c  o  m
 *
 * @param e
 * @return boolean
 */
private static boolean isValidStandardOperator(final Element e) {
    if (e.getKind() == ElementKind.FIELD) {
        return e.getModifiers().containsAll(EnumSet.of(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL));
    }
    if (e.getKind() == ElementKind.METHOD) {
        return e.getModifiers().containsAll(EnumSet.of(Modifier.PUBLIC, Modifier.STATIC))
                && ((ExecutableElement) e).getParameters().isEmpty();
    }
    if (e.getKind() == ElementKind.CLASS) {
        if (e.getModifiers().contains(Modifier.ABSTRACT) || findDefaultConstructor((TypeElement) e) == null) {
            return false;
        }
        Element current = e;
        while (current.getKind() == ElementKind.CLASS) {
            final TypeElement t = (TypeElement) current;
            if (t.getNestingKind() == NestingKind.TOP_LEVEL) {
                return true;
            }
            if (t.getNestingKind() == NestingKind.MEMBER && t.getModifiers().contains(Modifier.STATIC)) {
                current = t.getEnclosingElement();
                continue;
            }
            break;
        }
    }
    return false;
}

---

• «
• 1
• 2
• 3
• »