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

Introduction

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

Prototype

Modifier STATIC

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

Click Source Link

Document

The modifier static

Usage

From source file:Main.java

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

---

From source file:com.github.jdot.type.Property.java

/**
 * Returns new BeanProperty instance if the specified element is a JavaBean accessor method, otherwise null.
 * //from   w w w  . j a  va2  s .  c o m
 * @param element
 * @return
 */
public static Property build(Type owner, ExecutableElement element) {
    Property beanProperty = null;
    String name = null;
    boolean propertyFound = true;
    boolean writeable = false;
    String type = null;

    // Check modifiers
    boolean publicFound = false;
    boolean staticFound = false;
    for (Modifier modifier : element.getModifiers()) {
        if (Modifier.PUBLIC.equals(modifier)) {
            publicFound = true;
        }
        if (Modifier.STATIC.equals(modifier)) {
            staticFound = true;
        }
    }
    if (!publicFound || staticFound) {
        propertyFound = false;
    }

    // Check method name
    if (propertyFound) {
        String methodName = element.getSimpleName().toString();
        if (methodName.startsWith("set") && Character.isUpperCase(methodName.charAt(3))) {
            name = StringUtils.uncapitalize(methodName.substring(3));
            writeable = true;
        } else if (methodName.startsWith("get") && Character.isUpperCase(methodName.charAt(3))) {
            name = StringUtils.uncapitalize(methodName.substring(3));
        } else if (methodName.startsWith("is") && Character.isUpperCase(methodName.charAt(2))) {
            name = StringUtils.uncapitalize(methodName.substring(2));
        } else {
            propertyFound = false;
        }
    }

    // Check arguments / return type
    if (propertyFound) {
        if (writeable) {
            if (element.getParameters().size() == 1
                    && TypeKind.VOID.equals(element.getReturnType().getKind())) {
                type = element.getParameters().get(0).asType().toString();
            } else {
                propertyFound = false;
            }
        } else {
            if (TypeKind.VOID.equals(element.getReturnType().getKind())) {
                propertyFound = false;
            } else {
                type = element.getReturnType().toString();
            }
        }
    }

    if (propertyFound) {
        beanProperty = new Property(owner, element, name, type, writeable);
    }
    return beanProperty;
}

---

From source file:ch.rasc.constgen.CodeGenerator.java

private static boolean isStatic(VariableElement el) {
    if (el.getModifiers().contains(Modifier.STATIC)) {
        return true;
    }/* www .java2 s.c  o  m*/
    return false;
}

---

From source file:me.oriley.shiv.holders.ViewBindingHolder.java

@Override
void addBindingsToClass(@NonNull TypeSpec.Builder typeSpecBuilder) throws ShivException {
    if (mElements.isEmpty()) {
        // Nothing to bind
        return;/*from   w w  w.  j a v  a  2 s .c  o m*/
    }

    // Type parameter
    ParameterSpec param = ParameterSpec
            .builder(TypeName.get(Object.class).annotated(AnnotationSpec.builder(NonNull.class).build()),
                    OBJECT, Modifier.FINAL)
            .build();

    ParameterSpec viewGroupParam = ParameterSpec
            .builder(ClassName.get(ViewGroup.class).annotated(AnnotationSpec.builder(NonNull.class).build()),
                    VIEW_GROUP, Modifier.FINAL)
            .build();

    // Add count to final field for early exit strategy
    typeSpecBuilder.addField(
            FieldSpec.builder(int.class, VIEW_COUNT, Modifier.FINAL, Modifier.STATIC, Modifier.PRIVATE)
                    .initializer("$L", mElements.size()).build());

    // Create bindViews method
    MethodSpec publicBindMethod = MethodSpec.methodBuilder(BIND_VIEWS).addModifiers(Modifier.PUBLIC)
            .addAnnotation(Override.class).addParameter(param).addCode(generatePublicBindViewsMethod()).build();

    // Create bindViews method
    MethodSpec iterativeBindMethod = MethodSpec.methodBuilder(BIND_VIEWS).addModifiers(Modifier.PRIVATE)
            .addParameter(param).addParameter(viewGroupParam).returns(int.class)
            .addCode(generateProtectedBindViewsMethod()).build();

    // Create unbindViews method
    MethodSpec unbindMethod = MethodSpec.methodBuilder(UNBIND_VIEWS).addModifiers(Modifier.PUBLIC)
            .addAnnotation(Override.class).addParameter(param).addCode(generateUnbindViewsMethod()).build();

    typeSpecBuilder.addMethod(publicBindMethod).addMethod(iterativeBindMethod).addMethod(unbindMethod);
}

---

From source file:ch.rasc.constgen.CodeGenerator.java

public void generate(Appendable appendable) throws IOException {
    Builder classBuilder = TypeSpec.classBuilder(this.className);
    classBuilder.addModifiers(Modifier.PUBLIC, Modifier.FINAL);

    for (Constant constant : collectFields()) {
        FieldSpec fieldSpec = FieldSpec.builder(String.class, constant.getName())
                .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC)
                .initializer("$S", constant.getValue()).build();

        classBuilder.addField(fieldSpec);
    }// w  ww .  j  ava  2  s. c om

    JavaFile javaFile = JavaFile.builder(this.packageName, classBuilder.build()).build();
    javaFile.writeTo(appendable);
}

---

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 ww w.  ja va2s .  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:info.archinnov.achilles.internals.codegen.meta.UDTMetaCodeGen.java

private FieldSpec build_INSTANCE_Field(TypeName classType) {
    return FieldSpec.builder(classType, "INSTANCE", Modifier.FINAL, Modifier.PUBLIC, Modifier.STATIC)
            .initializer("new $T()", classType).build();
}

---

From source file:org.jraf.android.prefs.compiler.PrefsProcessor.java

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    for (TypeElement te : annotations) {
        for (Element element : roundEnv.getElementsAnnotatedWith(te)) {
            TypeElement classElement = (TypeElement) element;
            PackageElement packageElement = (PackageElement) classElement.getEnclosingElement();

            String classComment = processingEnv.getElementUtils().getDocComment(classElement);

            List<Pref> prefList = new ArrayList<Pref>();
            // Iterate over the fields of the class
            for (VariableElement variableElement : ElementFilter.fieldsIn(classElement.getEnclosedElements())) {
                if (variableElement.getModifiers().contains(Modifier.STATIC)) {
                    // Ignore constants
                    continue;
                }/*from   w w  w  .j a v a  2  s  . c  o m*/

                TypeMirror fieldType = variableElement.asType();
                boolean isAllowedType = PrefType.isAllowedType(fieldType);
                if (!isAllowedType) {
                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
                            fieldType + " is not allowed here, only these types are allowed: "
                                    + PrefType.getAllowedTypes(),
                            variableElement);
                    // Problem detected: halt
                    return true;
                }

                String fieldName = variableElement.getSimpleName().toString();
                org.jraf.android.prefs.Name fieldNameAnnot = variableElement
                        .getAnnotation(org.jraf.android.prefs.Name.class);
                String prefName = getPrefName(fieldName, fieldNameAnnot);

                String prefDefaultValue = getDefaultValue(variableElement, fieldType);
                if (prefDefaultValue == null) {
                    // Problem detected: halt
                    return true;
                }

                String fieldComment = processingEnv.getElementUtils().getDocComment(variableElement);
                Pref pref = new Pref(fieldName, prefName, PrefType.from(fieldType), prefDefaultValue,
                        fieldComment);
                prefList.add(pref);
            }

            Map<String, Object> args = new HashMap<String, Object>();

            // File name (optional - also use 'value' for this)
            org.jraf.android.prefs.Prefs prefsAnnot = classElement
                    .getAnnotation(org.jraf.android.prefs.Prefs.class);
            String fileName = prefsAnnot.value();
            if (fileName.isEmpty()) {
                fileName = prefsAnnot.fileName();
            }
            if (!fileName.isEmpty())
                args.put("fileName", fileName);

            // File mode (must only appear if fileName is defined)
            int fileMode = prefsAnnot.fileMode();
            if (fileMode != -1) {
                if (fileName.isEmpty()) {
                    // File mode set, but not file name (which makes no sense)
                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
                            "fileMode must only be set if fileName (or value) is also set", classElement);
                    // Problem detected: halt
                    return true;
                }
                args.put("fileMode", fileMode);
            }

            // Disable @Nullable generation
            args.put("disableNullable", prefsAnnot.disableNullable());

            JavaFileObject javaFileObject = null;
            try {
                // SharedPreferencesWrapper
                javaFileObject = processingEnv.getFiler()
                        .createSourceFile(classElement.getQualifiedName() + SUFFIX_PREF_WRAPPER);
                Template template = getFreemarkerConfiguration().getTemplate("prefwrapper.ftl");
                args.put("package", packageElement.getQualifiedName());
                args.put("comment", classComment);
                args.put("prefWrapperClassName", classElement.getSimpleName() + SUFFIX_PREF_WRAPPER);
                args.put("editorWrapperClassName", classElement.getSimpleName() + SUFFIX_EDITOR_WRAPPER);
                args.put("prefList", prefList);
                Writer writer = javaFileObject.openWriter();
                template.process(args, writer);
                IOUtils.closeQuietly(writer);

                // EditorWrapper
                javaFileObject = processingEnv.getFiler()
                        .createSourceFile(classElement.getQualifiedName() + "EditorWrapper");
                template = getFreemarkerConfiguration().getTemplate("editorwrapper.ftl");
                writer = javaFileObject.openWriter();
                template.process(args, writer);
                IOUtils.closeQuietly(writer);

            } catch (Exception e) {
                processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
                        "En error occurred while generating Prefs code " + e.getClass() + e.getMessage(),
                        element);
                e.printStackTrace();
                // Problem detected: halt
                return true;
            }
        }
    }
    return true;
}

---

From source file:com.rgeldmacher.leash.LeashAnnotationProcessor.java

private Map<TypeElement, Set<Element>> getFieldsByType(Set<? extends Element> elements) {
    Map<TypeElement, Set<Element>> fieldsByType = new HashMap<>(100);
    for (Element element : elements) {
        if (!typeIsActivityOrFragment(element.getEnclosingElement())) {
            error(element, "The @Retain annotation can only be applied to fields of an Activity or Fragment");
        } else if (element.getModifiers().contains(Modifier.FINAL)
                || element.getModifiers().contains(Modifier.STATIC)
                || element.getModifiers().contains(Modifier.PROTECTED)
                || element.getModifiers().contains(Modifier.PRIVATE)) {
            error(element, "Field must not be private, protected, static or final");
            continue;
        }//  w  w  w  .j a va2  s  . c o  m

        Set<Element> fields = fieldsByType.get(element.getEnclosingElement());
        if (fields == null) {
            fields = new LinkedHashSet<>(10);
            fieldsByType.put((TypeElement) element.getEnclosingElement(), fields);
        }

        fields.add(element);
    }

    return fieldsByType;
}

---

From source file:io.realm.processor.RealmProxyMediatorGenerator.java

private void emitFields(JavaWriter writer) throws IOException {
    writer.emitField("List<Class<? extends RealmObject>>", "MODEL_CLASSES",
            EnumSet.of(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL));
    writer.beginInitializer(true);//from   w  w  w.  j av a2s  .  c om
    writer.emitStatement(
            "List<Class<? extends RealmObject>> modelClasses = new ArrayList<Class<? extends RealmObject>>()");
    for (String clazz : simpleModelClasses) {
        writer.emitStatement("modelClasses.add(%s.class)", clazz);
    }
    writer.emitStatement("MODEL_CLASSES = Collections.unmodifiableList(modelClasses)");
    writer.endInitializer();
    writer.emitEmptyLine();
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• »