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

List of usage examples for javax.lang.model.element ElementKind FIELD

  1. HOME
  2. Java
  3. javax
  4. javax.lang.model.element.*
  5. ElementKind
  6. FIELD

Introduction

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

Prototype

ElementKind FIELD

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

Click Source Link

Document

A field not described by a more specific kind (like ENUM_CONSTANT ).

Usage

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

public static Element findFieldOnType(TypeElement element, String name) {

    for (Element enclosedElement : element.getEnclosedElements()) {

        if (enclosedElement.getKind() == ElementKind.FIELD
                && name.equals(enclosedElement.getSimpleName().toString())) {
            return enclosedElement;
        }/*from  ww  w.j  a v  a  2 s  .c  o m*/

    }

    return null;
}

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

private List<Constant> collectFields() {
    List<Constant> fields = new ArrayList<>();

    for (Element el : this.typeElement.getEnclosedElements()) {
        if (el.getKind() == ElementKind.FIELD) {

            VariableElement varEl = (VariableElement) el;
            if (!isTransient(varEl) && !isStatic(varEl)) {
                String value = getValue(varEl);
                fields.add(new Constant(el.getSimpleName().toString(), value));
            }//from  w ww.j a  v  a  2s .  co  m

        }
    }

    Collections.sort(fields);
    return fields;
}

From source file:me.oriley.shiv.ShivProcessor.java

private void collectBindings(@NonNull RoundEnvironment env, @NonNull Map<TypeElement, BindingManager> bindings,
        @NonNull Class<? extends Annotation> annotation) throws ShivException {
    for (Element e : env.getElementsAnnotatedWith(annotation)) {
        if (e.getKind() != ElementKind.FIELD) {
            throw new ShivException(
                    e.getSimpleName() + " is annotated with @" + annotation.getName() + " but is not a field");
        }/*from w  w  w. j av  a 2s.c  om*/

        TypeMirror fieldType = e.asType();
        if (isPrivate(e)) {
            throw new ShivException("Field must not be private: " + e.getSimpleName());
        } else if (isStatic(e)) {
            throw new ShivException("Field must not be static: " + e.getSimpleName());
        }

        final TypeElement type = findEnclosingElement(e);
        // class should exist
        if (type == null) {
            throw new ShivException("Could not find a class for " + e.getSimpleName());
        }
        // and it should be public
        if (isPrivate(type)) {
            throw new ShivException("Class is private: " + type);
        }
        // as well as all parent classes
        TypeElement parentType = findEnclosingElement(type);
        while (parentType != null) {
            if (isPrivate(parentType)) {
                throw new ShivException("Parent class is private: " + parentType);
            }
            parentType = findEnclosingElement(parentType);
        }

        if (annotation == BindView.class) {
            if (!isSubtypeOfType(type, Activity.class) && !isSubtypeOfType(type, Fragment.class)
                    && !isSubtypeOfType(type, android.support.v4.app.Fragment.class)
                    && !isSubtypeOfType(type, ViewGroup.class)) {
                throw new ShivException("Invalid view binding class: " + type.getSimpleName());
            } else if (!isSubtypeOfType(fieldType, View.class)) {
                throw new ShivException("Field must inherit from View type: " + e.getSimpleName());
            }
        } else if (annotation == BindExtra.class) {
            if (!isSubtypeOfType(type, Activity.class) && !isSubtypeOfType(type, Fragment.class)
                    && !isSubtypeOfType(type, android.support.v4.app.Fragment.class)) {
                throw new ShivException("Invalid extra binding class: " + type.getSimpleName());
            } else if (!isValidBundleEntry(fieldType)) {
                throw new ShivException("Extra field not suitable for bundle: " + e.getSimpleName());
            }
        } else if (annotation == BindPreference.class) {
            if (isSubtypeOfType(type, PreferenceFragment.class)
                    || isSubtypeOfType(type, PreferenceActivity.class)) {
                if (!isSubtypeOfType(fieldType, Preference.class)) {
                    throw new ShivException("Preferences in " + type.getQualifiedName() + " must inherit from "
                            + Preference.class + ": " + e.getSimpleName());
                }
            } else if (isSubtypeOfType(type, PreferenceFragmentCompat.class)) {
                if (!isSubtypeOfType(fieldType, android.support.v7.preference.Preference.class)) {
                    throw new ShivException("Preferences in " + PreferenceFragmentCompat.class
                            + " must inherit from " + android.support.v7.preference.Preference.class + ": "
                            + e.getSimpleName());
                }
            } else {
                throw new ShivException("Invalid preference binding class: " + type.getSimpleName());
            }
        } else if (annotation == BindInstance.class) {
            if (!isSubtypeOfType(type, Activity.class) && !isSubtypeOfType(type, Fragment.class)
                    && !isSubtypeOfType(type, android.support.v4.app.Fragment.class)) {
                throw new ShivException("Invalid instance binding class: " + type.getSimpleName());
            } else if (!isValidBundleEntry(fieldType)) {
                throw new ShivException("Instance field not suitable for bundle: " + e.getSimpleName());
            }
        } else if (annotation == BindNonConfigurationInstance.class) {
            if (!isSubtypeOfType(type, Activity.class)) {
                throw new ShivException(
                        "Invalid non-configuration instance binding class: " + type.getSimpleName());
            }
        } else if (annotation == BindService.class) {
            if (!isSubtypeOfType(type, Activity.class) && !isSubtypeOfType(type, Fragment.class)
                    && !isSubtypeOfType(type, android.support.v4.app.Fragment.class)
                    && !isSubtypeOfType(type, View.class)) {
                throw new ShivException("Invalid service binding class: " + type.getSimpleName());
            }
        } else {
            throw new ShivException("Unrecognised annotation: " + annotation);
        }

        BindingManager manager = bindings.get(type);
        if (manager == null) {
            manager = new BindingManager(this, type);
            bindings.put(type, manager);
        }

        manager.addBinding(annotation, e);
    }
}

From source file:therian.buildweaver.StandardOperatorsProcessor.java

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

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

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

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

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

From source file:therian.buildweaver.StandardOperatorsProcessor.java

/**
 * Must be a public static concrete class with a default constructor, public static zero-arg method, or public
 * static final field./*  w  ww  .  jav 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:cop.raml.utils.example.JsonExample.java

/**
 * Retrieves example for given {@code obj} which is not simple element, e.g. class with variables and method.
 * To build example of this object, read recursively all it's variables (each of them could be not simple element as well), build example and put
 * it into a map. Only not {@code null} example a placed into the map.
 * Additionally we consider {@link JsonIgnoreProperties} and {@link JsonIgnore} annotations.
 *
 * @param obj     not {@code null} complex element
 * @param visited not {@code null} visited object (use it to avoid cycle references)
 * @return {@code null} or not empty map of element name tp element example structure
 *//*from   ww  w  . jav  a2  s.com*/
private Map<String, Object> getTypeExample(@NotNull TypeElement obj, @NotNull Set<String> visited) {
    String name = obj.toString();

    if (visited.contains(name))
        return null;

    visited.add(name);

    try {
        Set<String> ignored = getIgnoredFields(obj);
        Map<String, Object> map = new LinkedHashMap<>();
        String elementName;
        Object res;

        for (Element element : obj.getEnclosedElements()) {
            if (element.getKind() != ElementKind.FIELD)
                continue;
            if (ElementUtils.isStatic(element))
                continue;
            if (ignored.contains(elementName = element.getSimpleName().toString()))
                continue;
            if ((res = getElementExample(element, visited)) != null)
                map.put(elementName, res);
        }

        return map;
    } finally {
        visited.remove(name);
    }
}

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

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

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

From source file:org.lambdamatic.mongodb.apt.template.MetadataTemplateContext.java

/**
 * Full constructor// w  w  w  . j  a  va 2s  .  co m
 * 
 * @param domainElement the {@link TypeElement} to work on.
 * @param templateFieldBuildFunction the {@link Function} used to generate a single
 *        {@link TemplateField} from a given relevant {@link VariableElement} in the given
 *        {@link TypeElement}.
 * @param templateMethodsBuildFunction the {@link Function} used to generate zero or more
 *        {@link TemplateMethods} from a given relevant {@link VariableElement} in the given
 *        {@link TypeElement}.
 * 
 */
private MetadataTemplateContext(final TypeElement domainElement,
        final BaseAnnotationProcessor annotationProcessor,
        final BiFunction<VariableElement, ProcessingEnvironment, TemplateField> templateFieldBuildFunction,
        final Function<DeclaredType, String> simpleClassNameBuilder, final String templateFileName) {
    super((DeclaredType) domainElement.asType(), annotationProcessor);
    this.domainTypeFields = domainElement.getEnclosedElements().stream()
            .filter(e -> e.getKind() == ElementKind.FIELD)
            .filter(e -> e.getAnnotation(TransientField.class) == null).map(e -> (VariableElement) e)
            .collect(Collectors.toList());
    this.templateFields = this.domainTypeFields.stream().map(f -> {
        return templateFieldBuildFunction.apply(f, annotationProcessor.getProcessingEnvironment());
    }).collect(Collectors.toList());
    this.simpleClassName = simpleClassNameBuilder.apply(this.domainType);
    this.fullyQualifiedClassName = getPackageName() + '.' + this.simpleClassName;
    this.templateFileName = templateFileName;
    this.annotations = Stream.of(domainElement.getAnnotationsByType(EmbeddedDocument.class))
            .map(a -> TemplateAnnotation.Builder.type(EmbeddedDocument.class).build())
            .collect(Collectors.toList());
}

From source file:com.dspot.declex.server.ServerModelHandler.java

@Override
public void process(Element element, EComponentHolder holder) {
    if (element.getKind().isField())
        return;/*from   w w  w  .j ava  2 s  .c o m*/
    if (element instanceof ExecutableElement)
        return;

    response = "";
    responseParams.clear();
    client = "";

    final UseModelHolder useModelHolder = holder.getPluginHolder(new UseModelHolder(holder));

    ExecutableElement serverModelLoaded = useModelHolder.getAfterLoadMethod();
    if (serverModelLoaded != null && serverModelLoaded.getAnnotation(ServerModel.class) == null) {
        serverModelLoaded = null;
    }

    ExecutableElement serverModelPut = useModelHolder.getAfterPutMethod();
    if (serverModelPut != null && serverModelPut.getAnnotation(ServerModel.class) == null) {
        serverModelPut = null;
    }

    List<? extends Element> elems = element.getEnclosedElements();
    for (Element elem : elems) {
        if (elem.getAnnotation(ServerModel.class) == null)
            continue;

        if (elem.getKind() == ElementKind.FIELD) {
            if (elem.asType().toString().equals("okhttp3.OkHttpClient")) {
                client = elem.getSimpleName().toString();
            }
        }

        if (elem.getKind() == ElementKind.METHOD) {
            ExecutableElement executableElement = (ExecutableElement) elem;

            if (elem.getModifiers().contains(Modifier.STATIC)) {
                List<? extends VariableElement> params = executableElement.getParameters();
                response = elem.getSimpleName().toString();

                for (VariableElement param : params) {
                    responseParams.add(param.getSimpleName().toString());
                }
            }

        }
    }

    super.process(element, holder);

    ServerModel serverModel = element.getAnnotation(ServerModel.class);
    if (!serverModel.offline()) {
        boolean loadExecuted = false;
        boolean putExecuted = false;

        if (!serverModel.get().trim().equals("")) {
            processRequest(new GetRequest(serverModel), true, element, useModelHolder);
            loadExecuted = true;
        }

        for (ServerRequest request : serverModel.load()) {
            processRequest(request, true, element, useModelHolder);
            loadExecuted = true;
        }

        if (!serverModel.post().trim().equals("")) {
            processRequest(new PostRequest(serverModel), false, element, useModelHolder);
            putExecuted = true;
        }

        for (ServerRequest request : serverModel.put()) {
            processRequest(request, false, element, useModelHolder);
            putExecuted = true;
        }

        placeReturnForMethods(serverModel, holder.getGeneratedClass());

        if (loadExecuted) {
            insertInGetModel(serverModelLoaded, element, useModelHolder);

            insertInSelectedGetModel(serverModelLoaded, element, useModelHolder);

            insertInGetModelList(serverModelLoaded, element, useModelHolder);

            insertInSelectedGetModelList(serverModelLoaded, element, useModelHolder);
        }

        if (putExecuted) {
            insertInPutModel(serverModelPut, element, useModelHolder);
        }
    }

}

From source file:org.kie.workbench.common.forms.adf.processors.FormDefinitionsProcessor.java

protected Collection<FieldInfo> extractFieldInfos(TypeElement typeElement, VariableElementValidator validator) {
    Map<String, FieldInfo> allFields = new HashMap<>();
    typeElement.getEnclosedElements().forEach(element -> {
        if (element.getKind().equals(ElementKind.FIELD)) {
            VariableElement fieldElement = (VariableElement) element;

            if (validator != null && !validator.isValid(fieldElement)) {
                return;
            }//from   w  w  w . j  a  va2  s.c  o  m

            FieldInfo fieldInfo = getInfoFromMap(fieldElement.getSimpleName().toString(), allFields);

            if (fieldInfo == null) {
                fieldInfo = new FieldInfo();
                allFields.put(fieldElement.getSimpleName().toString(), fieldInfo);
            }
            fieldInfo.fieldElement = fieldElement;
        } else if (element.getKind().equals(ElementKind.METHOD)) {
            ExecutableElement method = (ExecutableElement) element;

            String methodName = method.getSimpleName().toString();

            if (isGetter(method)) {
                String fieldName = extractFieldName(methodName, 3);
                FieldInfo info = getInfoFromMap(fieldName, allFields);
                info.getter = methodName;
            } else if (isBooleanGetter(method)) {
                String fieldName = extractFieldName(methodName, 2);
                FieldInfo info = getInfoFromMap(fieldName, allFields);
                info.getter = methodName;
            } else if (isSetter(method)) {
                String fieldName = extractFieldName(methodName, 3);
                FieldInfo info = getInfoFromMap(fieldName, allFields);
                info.setter = methodName;
            }
        }
    });

    return allFields.values().stream().filter(fieldInfo -> fieldInfo.fieldElement != null)
            .collect(Collectors.toCollection(() -> new ArrayList<>()));
}