Example usage for javax.lang.model.element TypeElement getModifiers

List of usage examples for javax.lang.model.element TypeElement getModifiers

Introduction

In this page you can find the example usage for javax.lang.model.element TypeElement getModifiers.

Prototype

Set<Modifier> getModifiers();

Source Link

Document

Returns the modifiers of this element, excluding annotations.

Usage

From source file:info.archinnov.achilles.internals.parser.validator.BeanValidator.java

public static void validateIsAConcreteNonFinalClass(AptUtils aptUtils, TypeElement typeElement) {
    final Name name = typeElement.getQualifiedName();
    aptUtils.validateTrue(typeElement.getKind() == ElementKind.CLASS, "Bean type '%s' should be a class", name);
    final Set<Modifier> modifiers = typeElement.getModifiers();
    aptUtils.validateFalse(modifiers.contains(Modifier.ABSTRACT), "Bean type '%s' should not be abstract",
            name);/*from  ww w .  j av a2s.  co  m*/
    aptUtils.validateFalse(modifiers.contains(Modifier.FINAL), "Bean type '%s' should not be final", name);
}

From source file:com.github.pellaton.jazoon2012.JazoonProcessor.java

private void processClass(TypeElement typeElement, List<ExecutableElement> constructorsIn) {
    if (typeElement.getModifiers().contains(Modifier.FINAL)) {
        this.messager.printMessage(Kind.ERROR, "@Configuration classes must not be final.", typeElement);
    }/*w w  w.  j a va2  s  .  com*/
}

From source file:fr.xebia.extras.selma.codegen.CustomMapperWrapper.java

void emitCustomMappersFields(JavaWriter writer, boolean assign) throws IOException {
    for (TypeElement customMapperField : customMapperFields) {
        final String field = String.format(CUSTOM_MAPPER_FIELD_TPL,
                customMapperField.getSimpleName().toString());
        if (assign) {
            if (customMapperField.getKind() != ElementKind.INTERFACE
                    && !(customMapperField.getKind() == ElementKind.CLASS
                            && customMapperField.getModifiers().contains(ABSTRACT))) {
                TypeConstructorWrapper constructorWrapper = new TypeConstructorWrapper(context,
                        customMapperField);
                // assign the customMapper field to a newly created instance passing to it the declared source params
                writer.emitStatement("this.%s = new %s(%s)", field,
                        customMapperField.getQualifiedName().toString(),
                        constructorWrapper.hasMatchingSourcesConstructor ? context.newParams() : "");
            }//from w w  w .j av  a2  s .co m
        } else {
            writer.emitEmptyLine();
            writer.emitJavadoc("This field is used for custom Mapping");
            if (ioC == IoC.SPRING) {
                writer.emitAnnotation("org.springframework.beans.factory.annotation.Autowired");
            }
            writer.emitField(customMapperField.asType().toString(),
                    String.format(CUSTOM_MAPPER_FIELD_TPL, customMapperField.getSimpleName().toString()),
                    EnumSet.of(PRIVATE));

            writer.emitEmptyLine();
            writer.emitJavadoc("Custom Mapper setter for " + field);

            EnumSet<Modifier> modifiers = EnumSet.of(PUBLIC, FINAL);
            if (ioC == IoC.CDI) {
                modifiers = EnumSet.of(PUBLIC);
            }
            writer.beginMethod("void", "setCustomMapper" + customMapperField.getSimpleName(), modifiers,
                    customMapperField.asType().toString(), "mapper");
            writer.emitStatement("this.%s = mapper", field);
            writer.endMethod();
            writer.emitEmptyLine();
        }
    }
}

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

public void componentRegistered(Element element, AndroidManifest androidManifest, boolean printWarning,
        IsValid valid) {//w  w w .  j  a  v a 2 s.c om
    TypeElement typeElement = (TypeElement) element;

    if (typeElement.getModifiers().contains(Modifier.ABSTRACT)) {
        return;
    }

    if (androidManifest.isLibraryProject()) {
        return;
    }

    String componentQualifiedName = typeElement.getQualifiedName().toString();
    String generatedComponentQualifiedName = componentQualifiedName + ModelConstants.GENERATION_SUFFIX;

    List<String> componentQualifiedNames = androidManifest.getComponentQualifiedNames();
    if (!componentQualifiedNames.contains(generatedComponentQualifiedName)) {
        String simpleName = typeElement.getSimpleName().toString();
        String generatedSimpleName = simpleName + ModelConstants.GENERATION_SUFFIX;
        if (componentQualifiedNames.contains(componentQualifiedName)) {
            valid.invalidate();
            annotationHelper.printAnnotationError(element,
                    "The AndroidManifest.xml file contains the original component, and not the AndroidAnnotations generated component. Please register "
                            + generatedSimpleName + " instead of " + simpleName);
        } else {
            if (printWarning) {
                annotationHelper.printAnnotationWarning(element, "The component " + generatedSimpleName
                        + " is not registered in the AndroidManifest.xml file.");
            }
        }
    }

}

From source file:org.androidannotations.helper.ValidatorHelper.java

public void applicationRegistered(Element element, AndroidManifest manifest, IsValid valid) {

    if (manifest.isLibraryProject()) {
        return;/*from w  w  w . j a v  a 2s .co  m*/
    }

    String applicationClassName = manifest.getApplicationClassName();
    if (applicationClassName != null) {

        TypeElement typeElement = (TypeElement) element;

        String componentQualifiedName = typeElement.getQualifiedName().toString();
        String generatedComponentQualifiedName = componentQualifiedName + ModelConstants.GENERATION_SUFFIX;

        if (!typeElement.getModifiers().contains(Modifier.ABSTRACT)
                && !applicationClassName.equals(generatedComponentQualifiedName)) {
            if (applicationClassName.equals(componentQualifiedName)) {
                valid.invalidate();
                annotationHelper.printAnnotationError(element,
                        "The AndroidManifest.xml file contains the original component, and not the AndroidAnnotations generated component. Please register "
                                + generatedComponentQualifiedName + " instead of " + componentQualifiedName);
            } else {
                annotationHelper.printAnnotationWarning(element,
                        "The component " + generatedComponentQualifiedName
                                + " is not registered in the AndroidManifest.xml file.");
            }
        }
    } else {
        valid.invalidate();
        annotationHelper.printAnnotationError(element,
                "No application class registered in the AndroidManifest.xml");
    }

}

From source file:org.debux.webmotion.netbeans.completion.WebMotionCompletion.java

@Override
public CompletionTask createTask(int queryType, JTextComponent component) {
    if (queryType != CompletionProvider.COMPLETION_QUERY_TYPE) {
        return null;
    }/*from w w  w . ja  va 2  s .  c o m*/

    return new AsyncCompletionTask(new AsyncCompletionQuery() {
        @Override
        protected void query(CompletionResultSet completionResultSet, Document document, int caretOffset) {

            String filter = null;
            int startOffset = caretOffset - 1;
            int column = 0;

            try {
                // Get filter
                StyledDocument doc = (StyledDocument) document;
                int lineStartOffset = Utils.getRowFirstNonWhite(doc, caretOffset);
                char[] line = doc.getText(lineStartOffset, caretOffset - lineStartOffset).toCharArray();
                int whiteOffset = Utils.indexOfWhite(line);
                filter = new String(line, whiteOffset + 1, line.length - whiteOffset - 1);
                if (whiteOffset > 0) {
                    startOffset = lineStartOffset + whiteOffset + 1;
                } else {
                    startOffset = lineStartOffset;
                }

                // Get position
                Element lineElement = doc.getParagraphElement(caretOffset);
                String lineValue = doc.getText(lineElement.getStartOffset(),
                        caretOffset - lineElement.getStartOffset());

                Pattern pattern = Pattern.compile("\\s+");
                Matcher matcher = pattern.matcher(lineValue);
                while (matcher.find()) {
                    column++;
                }

            } catch (BadLocationException ex) {
                Exceptions.printStackTrace(ex);
            }

            // Get section
            Section section = LexerUtils.getSection(document, caretOffset);

            // Get the package in configuration
            String packageBase = Utils.getPackageValue("package.base", null);
            String packageTarget = null;
            String filterSuperClass = null;
            String separator = "/";
            boolean onlyFolder = false;
            String onlyMimeType = null;

            String[] keywords = {};
            if (section != null) {

                if (section == Section.CONFIG) {
                    keywords = KEYWORDS_CONFIG;

                } else if (section == Section.ERRORS && column % 2 == 0) {
                    keywords = KEYWORDS_ERROR;
                    packageTarget = "";
                    filterSuperClass = "java.lang.Exception";

                } else if (section == Section.ERRORS && column % 2 == 1) {
                    keywords = KEYWORDS_ERROR_ACTION;

                    if (filter.startsWith("view:")) {
                        packageTarget = Utils.getPackageValue("package.views", null);

                    } else if (filter.startsWith("action:") || !filter.contains(":")) {
                        packageTarget = Utils.getPackageValue("package.errors", packageBase);
                        filterSuperClass = "org.debux.webmotion.server.WebMotionController";
                    }

                } else if (section == Section.EXTENSIONS && column % 2 == 0) {
                    keywords = KEYWORDS_EXTENSION;

                } else if (section == Section.EXTENSIONS && column % 2 == 1) {
                    packageTarget = "";
                    onlyMimeType = WebMotionLanguage.MIME_TYPE;

                } else if (section == Section.FILTERS && column % 3 == 0) {
                    keywords = KEYWORDS_METHODS;

                } else if (section == Section.FILTERS && column % 3 == 1) {
                    keywords = KEYWORDS_FILTER;

                } else if (section == Section.FILTERS && column % 3 == 2) {
                    keywords = KEYWORDS_FILTER_ACTION;
                    packageTarget = Utils.getPackageValue("package.filters", packageBase);
                    filterSuperClass = "org.debux.webmotion.server.WebMotionFilter";

                } else if (section == Section.ACTIONS && column % 3 == 0) {
                    keywords = KEYWORDS_METHODS;

                } else if (section == Section.ACTIONS && column % 3 == 1) {
                    keywords = KEYWORDS_ACTION;

                } else if (section == Section.ACTIONS && column % 3 == 2) {
                    keywords = KEYWORDS_ACTION_ACTION;

                    if (filter.startsWith("view:")) {
                        packageTarget = Utils.getPackageValue("package.views", null);

                    } else if (filter.startsWith("action:") || !filter.contains(":")) {
                        packageTarget = Utils.getPackageValue("package.actions", packageBase);
                        filterSuperClass = "org.debux.webmotion.server.WebMotionController";
                    }

                } else if (section == Section.PROPERTIES) {
                    keywords = KEYWORDS_SECTIONS;
                }

            } else {
                keywords = KEYWORDS_SECTIONS;
            }

            // Keywords
            if (keywords == KEYWORDS_METHODS && filter.contains(",")) {
                keywords = KEYWORDS_METHOD;
                startOffset += StringUtils.substringBeforeLast(filter, ",").length();
                filter = StringUtils.substringAfterLast(filter, ",");

            } else if (keywords == KEYWORDS_ERROR && filter.contains("code:")) {
                keywords = KEYWORDS_ERROR_CODE;
                startOffset += "code:".length();
                filter = filter.substring("code:".length());
                packageTarget = null;

            } else if (filter.startsWith("javac.debug=") || filter.startsWith("server.async=")
                    || filter.startsWith("server.static.autodetect=")) {
                keywords = KEYWORDS_CONFIG_BOOLEAN;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("server.error.page=")) {
                keywords = KEYWORDS_CONFIG_ERROR;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("server.controller.scope=")) {
                keywords = KEYWORDS_CONFIG_SCOPE;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("package.base=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=").replaceAll("\\.", "/");

                packageTarget = "";
                filterSuperClass = null;
                separator = ".";
                onlyFolder = true;

            } else if (filter.startsWith("package.views=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=").replaceAll("\\.", "/");

                packageTarget = "";
                filterSuperClass = null;
                separator = "/";
                onlyFolder = true;

            } else if (filter.startsWith("server.listener.class=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = "";
                filterSuperClass = "org.debux.webmotion.server.WebMotionServerListener";

            } else if (filter.startsWith("server.main.handler.class=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = "";
                filterSuperClass = "org.debux.webmotion.server.WebMotionHandler";

            } else if (filter.startsWith("default.render=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = "";
                filterSuperClass = "org.debux.webmotion.server.render.Render";

            } else if (filter.startsWith("package.actions=") || filter.startsWith("package.filters=")
                    || filter.startsWith("package.errors=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = Utils.getPackageValue("package.base", null);
                filterSuperClass = null;
                separator = ".";
                onlyFolder = true;

            } else if (filter.startsWith("server.encoding=")) {
                keywords = KEYWORDS_CONFIG_ENCODING;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("server.secret=")) {
                keywords = new String[] { RandomStringUtils.random(31, true, true) };
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("javac.debug") || filter.startsWith("server.async")
                    || filter.startsWith("server.static.autodetect") || filter.startsWith("server.error.page")
                    || filter.startsWith("server.controller.scope") || filter.startsWith("package.base")
                    || filter.startsWith("package.views") || filter.startsWith("server.listener.class")
                    || filter.startsWith("server.main.handler.class") || filter.startsWith("package.actions")
                    || filter.startsWith("package.filters") || filter.startsWith("package.errors")
                    || filter.startsWith("server.encoding") || filter.startsWith("server.secret")) {

                keywords = KEYWORDS_CONFIG_EQUAL;
                startOffset += StringUtils.substringBefore(filter, "=").length();
                filter = "";
            }

            for (String keyword : keywords) {
                if (keyword.startsWith(filter)) {
                    completionResultSet.addItem(new WebMotionCompletionItem(keyword, startOffset, caretOffset));
                }
            }

            if (packageTarget != null) {

                // File
                if (filterSuperClass == null) {
                    String path = packageTarget.replaceAll("\\.", "/");
                    String filterFile = filter;
                    int startOffsetFile = startOffset;
                    Set<String> names = new HashSet<String>();

                    if (filter.startsWith("view:")) {
                        filterFile = filter.replaceFirst("view:", "");
                        startOffsetFile += "view:".length();
                    }

                    if (filterFile.contains("/")) {
                        String current = StringUtils.substringBeforeLast(filterFile, "/");
                        path += current;
                        startOffsetFile += current.length() + 1;
                        filterFile = StringUtils.substringAfterLast(filterFile, "/");

                    } else if (packageTarget.isEmpty() && separator.equals("/")) {
                        String fileName = "WEB-INF";
                        names.add(fileName);
                        if (fileName.startsWith(filterFile)) {
                            if (!fileName.equals(filterFile)) {
                                completionResultSet.addItem(
                                        new WebMotionCompletionItem(fileName, startOffsetFile, caretOffset));
                            } else {
                                completionResultSet.addItem(new WebMotionCompletionItem(separator,
                                        startOffsetFile + fileName.length(), caretOffset));
                            }
                        }
                    }

                    GlobalPathRegistry registry = GlobalPathRegistry.getDefault();
                    List<ClassPath> paths = new ArrayList<ClassPath>();
                    paths.addAll(registry.getPaths(ClassPath.BOOT));
                    paths.addAll(registry.getPaths(ClassPath.COMPILE));
                    paths.addAll(registry.getPaths(ClassPath.SOURCE));

                    for (ClassPath classPath : paths) {
                        FileObject resource = classPath.findResource(path);

                        if (resource != null) {
                            FileObject[] children = resource.getChildren();
                            for (FileObject child : children) {
                                String fileName = child.getNameExt();

                                if ((!onlyFolder || onlyFolder && child.isFolder())
                                        && (onlyMimeType == null || child.isFolder()
                                                || onlyMimeType != null
                                                        && child.getMIMEType().equals(onlyMimeType))
                                        && fileName.startsWith(filterFile) && !fileName.startsWith(".")) {

                                    if (!names.contains(fileName)) {
                                        if (!fileName.equals(filterFile)) {
                                            completionResultSet.addItem(new WebMotionCompletionItem(fileName,
                                                    startOffsetFile, caretOffset));
                                        } else {
                                            completionResultSet.addItem(new WebMotionCompletionItem(separator,
                                                    startOffsetFile + fileName.length(), caretOffset));
                                        }
                                        names.add(fileName);
                                    }
                                }
                            }
                        }
                    }
                    completionResultSet.finish();

                } else {

                    // Class
                    if (filter.contains(":") && !filter.startsWith("code:")) {
                        startOffset += StringUtils.substringBefore(filter, ":").length() + 1;
                        filter = StringUtils.substringAfter(filter, ":");
                    }

                    int startOffsetClass = startOffset;
                    if (filter.contains(".")) {
                        startOffsetClass += StringUtils.substringBeforeLast(filter, ".").length() + 1;
                    }

                    String fullName = packageTarget + filter;
                    String rootPackage = "";
                    String filerPackage = fullName;
                    if (fullName.contains(".")) {
                        rootPackage = StringUtils.substringBeforeLast(fullName, ".");
                        filerPackage = StringUtils.substringAfterLast(fullName, ".");
                    }

                    String folderPackage = rootPackage.replaceAll("\\.", "/");

                    FileObject fo = Utils.getFO(document);
                    ClassPath bootCp = ClassPath.getClassPath(fo, ClassPath.BOOT);
                    ClassPath compileCp = ClassPath.getClassPath(fo, ClassPath.COMPILE);
                    ClassPath sourcePath = ClassPath.getClassPath(fo, ClassPath.SOURCE);
                    ClasspathInfo info = ClasspathInfo.create(bootCp, compileCp, sourcePath);
                    JavaSource src = JavaSource.create(info);

                    final String filterSuperJavaClass = filterSuperClass;
                    final CompletionResultSet completionResultSetClass = completionResultSet;
                    final int startOffsetJavaClass = startOffsetClass;
                    final int caretOffsetClass = caretOffset;

                    // Package names
                    List<FileObject> folders = new ArrayList<FileObject>();
                    folders.addAll(bootCp.findAllResources(folderPackage));
                    folders.addAll(compileCp.findAllResources(folderPackage));
                    folders.addAll(sourcePath.findAllResources(folderPackage));

                    final String rootPackageFilter = rootPackage;
                    final String filterPackageFilter = filerPackage;
                    final Set<String> names = new HashSet<String>();
                    for (final FileObject folder : folders) {

                        try {
                            src.runUserActionTask(new CancellableTask<CompilationController>() {
                                @Override
                                public void cancel() {
                                }

                                @Override
                                public void run(CompilationController cu) throws Exception {
                                    Types types = cu.getTypes();
                                    Elements elements = cu.getElements();

                                    TypeElement superElement = elements.getTypeElement(filterSuperJavaClass);
                                    TypeMirror superType = null;
                                    if (superElement != null) {
                                        superType = superElement.asType();
                                    }

                                    FileObject[] children = folder.getChildren();
                                    for (FileObject child : children) {
                                        String name = child.getName();
                                        if (!name.startsWith(".") && name.startsWith(filterPackageFilter)) {

                                            if (!names.contains(name)) {
                                                names.add(name);

                                                TypeElement element;
                                                if (rootPackageFilter.isEmpty()) {
                                                    element = elements.getTypeElement(name);
                                                } else {
                                                    element = elements
                                                            .getTypeElement(rootPackageFilter + "." + name);
                                                }

                                                if (name.equals(filterPackageFilter)) {

                                                    if (element == null
                                                            || element.getKind() != ElementKind.CLASS
                                                            || element.getKind() == ElementKind.CLASS
                                                                    && (filterSuperJavaClass.equals(
                                                                            "org.debux.webmotion.server.WebMotionFilter")
                                                                            || filterSuperJavaClass.equals(
                                                                                    "org.debux.webmotion.server.WebMotionController"))) {

                                                        WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                                ".", startOffsetJavaClass + name.length(),
                                                                caretOffsetClass);
                                                        completionResultSetClass.addItem(item);
                                                    }

                                                } else if (child.isFolder()) {
                                                    WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                            name, startOffsetJavaClass, caretOffsetClass);
                                                    completionResultSetClass.addItem(item);

                                                } else if (element != null) {
                                                    Set<Modifier> modifiers = element.getModifiers();
                                                    ElementKind kind = element.getKind();
                                                    TypeMirror resolveType = element.asType();

                                                    if (kind == ElementKind.CLASS
                                                            && modifiers.contains(Modifier.PUBLIC)
                                                            && !modifiers.contains(Modifier.ABSTRACT)
                                                            && superType != null
                                                            && types.isSubtype(resolveType, superType)) {

                                                        WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                                name, cu, element, startOffsetJavaClass,
                                                                caretOffsetClass);
                                                        completionResultSetClass.addItem(item);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }, false);

                        } catch (IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }
                    }

                    // Method
                    if (filter.contains(".") && (filterSuperJavaClass
                            .equals("org.debux.webmotion.server.WebMotionFilter")
                            || filterSuperJavaClass.equals("org.debux.webmotion.server.WebMotionController"))) {

                        final String className = StringUtils.substringBeforeLast(filter, ".");
                        final String fullClassName = packageTarget + className;
                        final String filterMethod = StringUtils.substringAfterLast(filter, ".");

                        final CompletionResultSet completionResultSetJavaSource = completionResultSet;
                        final int startOffsetJavaSource = startOffset + className.length() + 1;
                        final int caretOffesetJavaSource = caretOffset;

                        try {
                            src.runUserActionTask(new CancellableTask<CompilationController>() {

                                @Override
                                public void cancel() {
                                }

                                @Override
                                public void run(CompilationController cu) throws Exception {
                                    cu.toPhase(JavaSource.Phase.PARSED);

                                    Elements elements = cu.getElements();
                                    TypeElement classElement = elements.getTypeElement(fullClassName);
                                    if (classElement != null) {

                                        List<? extends javax.lang.model.element.Element> members = elements
                                                .getAllMembers(classElement);
                                        for (javax.lang.model.element.Element member : members) {
                                            if (member.getKind() == ElementKind.METHOD) {

                                                Set<Modifier> modifiers = member.getModifiers();
                                                String methodName = member.getSimpleName().toString();
                                                String className = member.getEnclosingElement().getSimpleName()
                                                        .toString();

                                                if (!"Object".equals(className)
                                                        && !"WebMotionController".equals(className)
                                                        && !"WebMotionFilter".equals(className)
                                                        && modifiers.contains(Modifier.PUBLIC)
                                                        && !modifiers.contains(Modifier.STATIC)
                                                        && methodName.startsWith(filterMethod)) {

                                                    WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                            methodName, cu, member, startOffsetJavaSource,
                                                            caretOffesetJavaSource);
                                                    completionResultSetJavaSource.addItem(item);
                                                }
                                            }
                                        }
                                    }

                                    completionResultSetJavaSource.finish();
                                }
                            }, false);
                        } catch (IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }
                    } else {
                        completionResultSet.finish();
                    }
                }

            } else {
                completionResultSet.finish();
            }
        }
    }, component);
}

From source file:org.debux.webmotion.netbeans.hints.ActionRule.java

@Override
public void run(RuleContext context, final List<Hint> hints) {
    WebMotionParserResult parserResult = (WebMotionParserResult) context.parserResult;

    Source source = parserResult.getSnapshot().getSource();
    final Document document = source.getDocument(false);
    final FileObject fileObject = source.getFileObject();

    FileObject fo = Utils.getFO(document);
    ClassPath bootCp = ClassPath.getClassPath(fo, ClassPath.BOOT);
    ClassPath compileCp = ClassPath.getClassPath(fo, ClassPath.COMPILE);
    ClassPath sourcePath = ClassPath.getClassPath(fo, ClassPath.SOURCE);
    ClasspathInfo info = ClasspathInfo.create(bootCp, compileCp, sourcePath);
    final JavaSource src = JavaSource.create(info);

    try {//from   w ww .  ja  va  2s  . c o  m
        src.runUserActionTask(new CancellableTask<CompilationController>() {
            @Override
            public void cancel() {
            }

            @Override
            public void run(CompilationController cu) throws Exception {
                String packageBase = Utils.getPackageValue("package.base", null);

                List<OffsetRange> tokens = LexerUtils.getTokens(document, "FILTER_ACTION");
                String packageTarget = Utils.getPackageValue("package.filters", packageBase);
                String superClass = "org.debux.webmotion.server.WebMotionFilter";

                runAction(cu, tokens, packageTarget, superClass);

                tokens = LexerUtils.getTokens(document, "ERROR_ACTION_JAVA");
                packageTarget = Utils.getPackageValue("package.errors", packageBase);
                superClass = "org.debux.webmotion.server.WebMotionController";

                runAction(cu, tokens, packageTarget, superClass);

                tokens = LexerUtils.getTokens(document, "ACTION_ACTION_IDENTIFIER",
                        "ACTION_ACTION_JAVA_IDENTIFIER", "ACTION_ACTION_JAVA_QUALIFIED_IDENTIFIER",
                        "ACTION_ACTION_JAVA_VARIABLE");
                packageTarget = Utils.getPackageValue("package.actions", packageBase);
                superClass = "org.debux.webmotion.server.WebMotionController";

                runAction(cu, tokens, packageTarget, superClass);
            }

            protected void runAction(CompilationController cu, List<OffsetRange> tokens, String packageTarget,
                    String superClass) {
                Elements elements = cu.getElements();
                Types types = cu.getTypes();
                for (OffsetRange range : tokens) {
                    try {
                        String value = LexerUtils.getText(document, range);
                        String className = StringUtils.substringBeforeLast(value, ".");
                        String methodName = StringUtils.substringAfterLast(value, ".");

                        if (Utils.isNotVariable(className)) {
                            TypeElement classElement = elements.getTypeElement(packageTarget + className);
                            if (classElement != null) {

                                // Check class
                                TypeElement controllerElement = elements.getTypeElement(superClass);
                                if (controllerElement != null) {
                                    TypeMirror controllerType = controllerElement.asType();

                                    Set<Modifier> modifiers = classElement.getModifiers();
                                    ElementKind kind = classElement.getKind();
                                    TypeMirror resolveType = classElement.asType();

                                    if (kind == ElementKind.CLASS) {
                                        if (!modifiers.contains(Modifier.PUBLIC)) {
                                            hints.add(new Hint(ActionRule.this, "The class is not public",
                                                    fileObject, range,
                                                    WebMotionHintsProvider.asList(
                                                            new PublicModifierClassFix(src, classElement)),
                                                    100));
                                        }
                                        if (modifiers.contains(Modifier.ABSTRACT)) {
                                            hints.add(new Hint(ActionRule.this, "The class is abstract",
                                                    fileObject, range,
                                                    WebMotionHintsProvider.asList(
                                                            new AbstractModifierClassFix(src, classElement)),
                                                    100));
                                        }
                                        if (!types.isSubtype(resolveType, controllerType)) {
                                            hints.add(new Hint(ActionRule.this,
                                                    "Requires super class " + superClass, fileObject, range,
                                                    WebMotionHintsProvider.asList(
                                                            new ExtendsClassFix(src, classElement, superClass)),
                                                    100));
                                        }
                                    }
                                }

                                // Check method
                                if (Utils.isNotVariable(methodName)) {
                                    List<? extends Element> members = elements.getAllMembers(classElement);
                                    Element method = null;
                                    for (Element member : members) {
                                        ElementKind kind = member.getKind();
                                        String name = member.getSimpleName().toString();
                                        if (kind == ElementKind.METHOD && name.equals(methodName)) {
                                            method = member;
                                            break;
                                        }
                                    }

                                    if (method != null) {
                                        Set<Modifier> modifiers = method.getModifiers();
                                        String currentClass = method.getEnclosingElement().getSimpleName()
                                                .toString();

                                        if ("Object".equals(currentClass)
                                                || "WebMotionController".equals(currentClass)
                                                || "WebMotionFilter".equals(currentClass)) {
                                            hints.add(new Hint(ActionRule.this, "Invalid method", fileObject,
                                                    range, WebMotionHintsProvider.NO_FIXES, 100));
                                        }
                                        if (!modifiers.contains(Modifier.PUBLIC)) {
                                            hints.add(
                                                    new Hint(ActionRule.this, "The method is not public",
                                                            fileObject, range,
                                                            WebMotionHintsProvider
                                                                    .asList(new PublicModifierMethodFix(src,
                                                                            classElement, methodName)),
                                                            100));
                                        }
                                        if (modifiers.contains(Modifier.STATIC)) {
                                            hints.add(
                                                    new Hint(ActionRule.this, "The method is static",
                                                            fileObject, range,
                                                            WebMotionHintsProvider
                                                                    .asList(new StaticModifierMethodFix(src,
                                                                            classElement, methodName)),
                                                            100));
                                        }

                                    } else {
                                        hints.add(new Hint(ActionRule.this, "Invalid method", fileObject, range,
                                                WebMotionHintsProvider.asList(
                                                        new MethodClassFix(src, classElement, methodName)),
                                                100));
                                    }
                                }

                            } else {
                                hints.add(new Hint(ActionRule.this, "Invalid class", fileObject, range,
                                        WebMotionHintsProvider.asList(
                                                new CreateClassFix(src, packageTarget, superClass, className)),
                                        100));
                            }
                        }
                    } catch (BadLocationException ex) {
                        Exceptions.printStackTrace(ex);
                    }
                }
            }
        }, false);
    } catch (IOException ex) {
        Exceptions.printStackTrace(ex);
    }
}

From source file:org.netbeans.jpa.modeler.spec.extend.JavaClass.java

@Override
public void load(EntityMappings entityMappings, TypeElement element, boolean fieldAccess) {
    this.setId(NBModelerUtil.getAutoGeneratedStringId());

    this.clazz = element.getSimpleName().toString();
    if (element.getModifiers().contains(Modifier.ABSTRACT)) {
        this.setAbstract(true);
    }/*from   www . ja v  a 2s .com*/
    for (TypeMirror mirror : element.getInterfaces()) {
        if (Serializable.class.getName().equals(mirror.toString())) {
            continue;
        }
        this.addInterface(mirror.toString());
    }
    this.setAnnotation(JavaSourceParserUtil.getNonEEAnnotation(element));
}

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.//from w w w . ja  v  a 2 s .c  om
 *
 * @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;
}

From source file:uniol.apt.compiler.AbstractServiceProcessor.java

private boolean isValidClass(Element ele) {
    if (ele.getKind() != ElementKind.CLASS) {
        error(ele, "Non-Class %s annotated with %s.", ele.getSimpleName().toString(),
                this.annotationClass.getCanonicalName());
    }//from ww w.  j a  v a 2  s .  c o m

    TypeElement classEle = (TypeElement) ele;

    if (!classEle.getModifiers().contains(Modifier.PUBLIC)) {
        error(classEle, "Class %s is not public.", classEle.getQualifiedName().toString());
        return false;
    }

    if (classEle.getModifiers().contains(Modifier.ABSTRACT)) {
        error(classEle, "Class %s is abstract.", classEle.getQualifiedName().toString());
        return false;
    }

    TypeMirror expected = this.types.erasure(this.elements.getTypeElement(this.interfaceName).asType());
    boolean found = false;
    for (TypeMirror actual : classEle.getInterfaces()) {
        if (this.types.isAssignable(actual, expected)) {
            found = true;
            break;
        }
    }
    if (!found) {
        error(classEle, "Class %s doesn't implement interface %s.", classEle.getQualifiedName().toString(),
                this.interfaceName);
        return false;
    }

    if (!allowGenerics && !classEle.getTypeParameters().isEmpty()) {
        error(classEle, "Class %s is generic.", classEle.getQualifiedName().toString());
        return false;
    }

    for (Element enclosed : classEle.getEnclosedElements()) {
        if (enclosed.getKind() == ElementKind.CONSTRUCTOR) {
            ExecutableElement constructorEle = (ExecutableElement) enclosed;
            if (constructorEle.getParameters().size() == 0
                    && constructorEle.getModifiers().contains(Modifier.PUBLIC)) {
                return true;
            }
        }
    }

    error(classEle, String.format("Class %s needs an public no-arg constructor",
            classEle.getQualifiedName().toString()));
    return false;
}