Example usage for javax.lang.model.element Modifier ABSTRACT

List of usage examples for javax.lang.model.element Modifier ABSTRACT

Introduction

In this page you can find the example usage for javax.lang.model.element Modifier ABSTRACT.

Prototype

Modifier ABSTRACT

To view the source code for javax.lang.model.element Modifier ABSTRACT.

Click Source Link

Document

The modifier abstract

Usage

From source file:Main.java

public static boolean isAbstract(Element d) {
    Collection<Modifier> mods = d.getModifiers();
    return mods.contains(Modifier.ABSTRACT);
}

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  a  v  a2 s.  c  om*/
    aptUtils.validateFalse(modifiers.contains(Modifier.FINAL), "Bean type '%s' should not be final", name);
}

From source file:org.mule.devkit.validation.RestValidator.java

@Override
public void validate(DevKitTypeElement typeElement, GeneratorContext context) throws ValidationException {

    for (ExecutableElement method : typeElement.getMethodsAnnotatedWith(RestCall.class)) {

        if (!method.getModifiers().contains(Modifier.ABSTRACT)) {
            throw new ValidationException(method, "@RestCall can only be applied to abstract methods");
        }//  ww w  .  jav  a 2  s . co  m

        if (method.getThrownTypes().size() != 1) {
            throw new ValidationException(method, "@RestCall abstract method must throw IOException");
        }

        RestExceptionOn restExceptionOn = method.getAnnotation(RestExceptionOn.class);
        if (restExceptionOn != null) {
            if (restExceptionOn.statusCodeIs().length != 0 && restExceptionOn.statusCodeIsNot().length != 0) {
                throw new ValidationException(method,
                        "@RestExceptionOn can only be used with statusCodeIs or statusCodeIsNot. Not both.");
            }
            if (restExceptionOn.statusCodeIs().length == 0 && restExceptionOn.statusCodeIsNot().length == 0) {
                throw new ValidationException(method,
                        "@RestExceptionOn must have either statusCodeIs or statusCodeIsNot.");
            }
        }

        int nonAnnotatedParameterCount = 0;
        for (VariableElement parameter : method.getParameters()) {
            if (parameter.getAnnotation(RestUriParam.class) == null
                    && parameter.getAnnotation(RestHeaderParam.class) == null
                    && parameter.getAnnotation(RestQueryParam.class) == null) {
                nonAnnotatedParameterCount++;
            }
        }

        if (nonAnnotatedParameterCount > 1) {
            throw new ValidationException(method,
                    "Only one parameter can be used as payload, everything else must be annotated with @RestUriParam, @RestQueryParam or @RestHeaderParam.");
        }
    }

    for (VariableElement field : typeElement.getFieldsAnnotatedWith(RestUriParam.class)) {
        boolean getterFound = false;
        for (ExecutableElement method : typeElement.getMethods()) {
            if (method.getSimpleName().toString()
                    .equals("get" + StringUtils.capitalize(field.getSimpleName().toString()))) {
                getterFound = true;
                break;
            }
        }
        if (!getterFound) {
            throw new ValidationException(field,
                    "Cannot find a getter method for " + field.getSimpleName().toString()
                            + " but its being marked as URI parameter of a REST call.");
        }
    }

    if (typeElement.getFieldsAnnotatedWith(RestHttpClient.class).size() > 1) {
        throw new ValidationException(typeElement,
                "There can only be one field annotated with @RestHttpClient.");
    }

    if (typeElement.getFieldsAnnotatedWith(RestHttpClient.class).size() > 0) {
        if (!typeElement.getFieldsAnnotatedWith(RestHttpClient.class).get(0).asType().toString()
                .equals(HttpClient.class.getName())) {
            throw new ValidationException(typeElement.getFieldsAnnotatedWith(RestHttpClient.class).get(0),
                    "A field annotated with @RestHttpClient must be of type " + HttpClient.class.getName());
        }
    }

    for (VariableElement field : typeElement.getFieldsAnnotatedWith(RestHttpClient.class)) {
        boolean getterFound = false;
        for (ExecutableElement method : typeElement.getMethods()) {
            if (method.getSimpleName().toString()
                    .equals("get" + StringUtils.capitalize(field.getSimpleName().toString()))) {
                getterFound = true;
                break;
            }
        }
        if (!getterFound) {
            throw new ValidationException(field, "Cannot find a getter method for "
                    + field.getSimpleName().toString() + " but its being marked with @RestHttpClient.");
        }
    }

}

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);
    }//w w w . j  a v  a2 s .c  om
    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:com.shieldsbetter.sbomg.ModelClass.java

public TypeSpec buildTypeSpec() {
    TypeSpec.Builder result = TypeSpec.classBuilder(myName).addModifiers(Modifier.PUBLIC);

    if (myStaticFlag) {
        result.addModifiers(Modifier.STATIC);
    }//from   w ww. j  a  v  a 2 s  .c  om

    TypeName thisTypeName = ClassName.get("", myName);

    for (Map.Entry<String, AbstractMethodSet> auxListenerDef : myAuxiliaryListeners.entrySet()) {
        TypeSpec.Builder auxListener = TypeSpec.interfaceBuilder(auxListenerDef.getKey())
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC);

        AbstractMethodSet methodDefs = auxListenerDef.getValue();
        for (String methodName : methodDefs.getNames()) {
            MethodSpec.Builder method = MethodSpec.methodBuilder(methodName).addModifiers(Modifier.ABSTRACT,
                    Modifier.PUBLIC);

            method.addParameter(thisTypeName, "source");

            for (Pair<String, TypeName> parameter : methodDefs.getParameters(methodName)) {
                method.addParameter(parameter.getRight(), parameter.getLeft());
            }

            auxListener.addMethod(method.build());
        }

        result.addType(auxListener.build());
    }

    TypeSpec.Builder listener = TypeSpec.interfaceBuilder("Listener").addModifiers(Modifier.PUBLIC,
            Modifier.STATIC);

    for (String methodName : myRootListener.getNames()) {
        MethodSpec.Builder method = MethodSpec.methodBuilder("on" + methodName).addModifiers(Modifier.ABSTRACT,
                Modifier.PUBLIC);

        method.addParameter(thisTypeName, "source");

        for (Pair<String, TypeName> parameter : myRootListener.getParameters(methodName)) {
            method.addParameter(parameter.getRight(), parameter.getLeft());
        }

        listener.addMethod(method.build());
    }
    result.addType(listener.build());

    TypeSpec.Builder event = TypeSpec.interfaceBuilder("Event").addModifiers(Modifier.PUBLIC, Modifier.STATIC)
            .addMethod(MethodSpec.methodBuilder("on").addModifiers(Modifier.ABSTRACT, Modifier.PUBLIC)
                    .addParameter(ClassName.get("", "Listener"), "l").build());
    result.addType(event.build());

    TypeSpec.Builder eventListener = TypeSpec.interfaceBuilder("EventListener")
            .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
            .addMethod(MethodSpec.methodBuilder("on").addModifiers(Modifier.ABSTRACT, Modifier.PUBLIC)
                    .addParameter(ClassName.get("", "Event"), "e").build());
    result.addType(eventListener.build());

    TypeSpec.Builder subscription = TypeSpec.interfaceBuilder("Subscription")
            .addModifiers(Modifier.PUBLIC, Modifier.STATIC).addMethod(MethodSpec.methodBuilder("unsubscribe")
                    .addModifiers(Modifier.ABSTRACT, Modifier.PUBLIC).build());
    result.addType(subscription.build());

    CodeBlock.Builder addListenerEventListenerCode = CodeBlock.builder();

    if (myRootListener.getMethodCount() > 0) {
        result.addField(FieldSpec
                .builder(
                        ParameterizedTypeName.get(ClassName.get("java.util", "List"),
                                ClassName.get("", "EventListener")),
                        "myListeners", Modifier.PRIVATE, Modifier.FINAL)
                .initializer("new $T<>()", ClassName.get("java.util", "LinkedList")).build());

        addListenerEventListenerCode.addStatement("myListeners.add(el)")
                .beginControlFlow("return new Subscription()")
                .beginControlFlow("@Override public void unsubscribe()").addStatement("myListeners.remove(el)")
                .endControlFlow().endControlFlow("");
    } else {
        addListenerEventListenerCode.beginControlFlow("return new Subscription()")
                .beginControlFlow("@Override public void unsubscribe()").endControlFlow().endControlFlow("");
    }

    result.addMethod(MethodSpec.methodBuilder("addListener").addModifiers(Modifier.PUBLIC)
            .returns(ClassName.get("", "Subscription"))
            .addParameter(ClassName.get("", "Listener"), "l", Modifier.FINAL)
            .addCode(CodeBlock.builder().beginControlFlow("EventListener el = new EventListener()")
                    .beginControlFlow("@Override public void on(Event e)").addStatement("e.on(l)")
                    .endControlFlow().endControlFlow("").addStatement("return addListener(el)").build())
            .build());

    result.addMethod(MethodSpec.methodBuilder("addListener").addModifiers(Modifier.PUBLIC)
            .returns(ClassName.get("", "Subscription"))
            .addParameter(ClassName.get("", "EventListener"), "el", Modifier.FINAL)
            .addCode(addListenerEventListenerCode.build()).build());

    result.addMethod(MethodSpec.methodBuilder("build").addModifiers(Modifier.PUBLIC).returns(TypeName.VOID)
            .addParameter(ClassName.get("", "Listener"), "l", Modifier.FINAL).addCode(myBuildCode.build())
            .build());

    for (FieldSpec f : myFields) {
        result.addField(f);
    }

    MethodSpec.Builder constructor = MethodSpec.constructorBuilder().addModifiers(Modifier.PUBLIC);
    for (Pair<String, TypeName> param : myInitializationParams) {
        String paramName = param.getLeft();
        constructor.addParameter(param.getRight(), paramName);
    }
    constructor.addCode(myAdditionalInitializationCode.build());
    result.addMethod(constructor.build());

    result.addMethods(myRootMethods);

    for (ModelClass c : mySubModels) {
        result.addType(c.buildTypeSpec());
    }

    for (TypeSpec type : myRootTypes) {
        result.addType(type);
    }

    for (TypeName type : myImplementsList) {
        result.addSuperinterface(type);
    }

    return result.build();
}

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   ww  w. ja va  2s. 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;
}

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

private static List<String> definePublicGetter(final TypeElement typeElement, final TypeMirror typeMirror,
        final Types typeUtils) {

    final List<String> publicGetters = ElementFilter.methodsIn(typeElement.getEnclosedElements()).stream()
            .filter(g -> g.getSimpleName().toString().startsWith("get")
                    || g.getSimpleName().toString().startsWith("is"))
            .filter(g -> g.getModifiers().contains(Modifier.PUBLIC))
            .filter(g -> !g.getModifiers().contains(Modifier.ABSTRACT))//FIXME filter remaining modifiers
            .map(g -> g.getSimpleName().toString()).collect(toList());

    if (isLombokAnnotatedType(typeMirror, typeUtils)) {
        ElementFilter.fieldsIn(typeElement.getEnclosedElements()).stream()
                .filter(g -> !g.getModifiers().contains(Modifier.STATIC)).map(g -> g.getSimpleName().toString())
                .forEach(publicGetters::add);
    }//  w  ww .j  a  va  2 s . co m

    return publicGetters;
}

From source file:com.vimeo.stag.processor.utils.TypeUtils.java

/**
 * Determines whether or not the Element is a abstract type.
 *
 * @param element the element to check./*from  www .ja v  a  2  s .  c  o m*/
 * @return true if the element is abstract and
 * contains no generic type arguments, false otherwise.
 */
public static boolean isAbstract(@Nullable Element element) {
    return element != null && element.getModifiers().contains(Modifier.ABSTRACT);
}

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