private List<VariableElement> getKeyEventEnclosedFieldElements() { TypeElement keyEventElement = getElementUtils().getTypeElement(CanonicalNameConstants.KEY_EVENT); return ElementFilter.fieldsIn(keyEventElement.getEnclosedElements()); }
void detectParcelableCreator() { for (VariableElement v : ElementFilter.fieldsIn(element.getEnclosedElements())) { if (v.getSimpleName().contentEquals(Proto.PARCELABLE_CREATOR_FIELD)) { hasCreatorDefined = true; break; } } }
private Stream<CompilationMessage> validateFieldModifiers( Element recordElement ) { return fieldsIn( recordElement.getEnclosedElements() ).stream().filter( element -> { Set<Modifier> modifiers = element.getModifiers(); return !modifiers.contains( PUBLIC ) && !modifiers.contains( STATIC ); } ).map( element -> new RecordTypeError( element, "Record definition error: field %s#%s must be public", recordElement.getSimpleName(), element.getSimpleName() ) ); }
private Stream<CompilationMessage> validateFieldType( Element recordElement ) { return fieldsIn( recordElement.getEnclosedElements() ).stream() .filter( element -> !element.getModifiers().contains( STATIC ) ) .filter( element -> !fieldTypeVisitor.visit( element.asType() ) ) .map( element -> new RecordTypeError( element, "Record definition error: type of field %s#%s is not supported", recordElement.getSimpleName(), element.getSimpleName() ) ); }
private Long findSerialVersionUID() { for (VariableElement field : ElementFilter.fieldsIn(element.getEnclosedElements())) { if (field.getSimpleName().contentEquals(SERIAL_VERSION_FIELD_NAME) && field.asType().getKind() == TypeKind.LONG) { return (Long) field.getConstantValue(); } } return null; }
private static void updateEmbeddableAccessType(TypeElement element, Context context, AccessType defaultAccessType) { List<? extends Element> fieldsOfClass = ElementFilter.fieldsIn( element.getEnclosedElements() ); for ( Element field : fieldsOfClass ) { updateEmbeddableAccessTypeForMember( context, defaultAccessType, field ); } List<? extends Element> methodOfClass = ElementFilter.methodsIn( element.getEnclosedElements() ); for ( Element method : methodOfClass ) { updateEmbeddableAccessTypeForMember( context, defaultAccessType, method ); } }
public RInnerClass(TypeElement rInnerTypeElement) { if (rInnerTypeElement != null) { rInnerQualifiedName = rInnerTypeElement.getQualifiedName().toString(); List<? extends Element> idEnclosedElements = rInnerTypeElement.getEnclosedElements(); List<VariableElement> idFields = ElementFilter.fieldsIn(idEnclosedElements); for (VariableElement idField : idFields) { TypeKind fieldType = idField.asType().getKind(); if (fieldType.isPrimitive() && fieldType.equals(TypeKind.INT)) { String idQualifiedName = rInnerQualifiedName + "." + idField.getSimpleName(); idQualifiedNames.add(idQualifiedName); Integer idFieldId = (Integer) idField.getConstantValue(); if (idFieldId != null) { idQualifiedNamesByIdValues.put(idFieldId, idQualifiedName); } } } } else { rInnerQualifiedName = ""; } }
private void collectTypedefs(TypeElement type, Map<String, TypeMirror> collected) { for (VariableElement field : ElementFilter.fieldsIn(elements.getAllMembers(type))) { if (field.getAnnotation(Generator.Typedef.class) != null) { collected.put(field.getSimpleName().toString(), field.asType()); } } }
public void parseDartModelAnnotatedFields( Map<TypeElement, NavigationModelBindingTarget> targetClassMap) { for (VariableElement element : ElementFilter.fieldsIn(roundEnv.getElementsAnnotatedWith(DartModel.class))) { try { parseNavigationModelField(element, targetClassMap); } catch (Exception e) { StringWriter stackTrace = new StringWriter(); e.printStackTrace(new PrintWriter(stackTrace)); loggingUtil.error( element, "Unable to generate extra binder when parsing @DartModel.\n\n%s", stackTrace.toString()); } } }
variableElements = ElementFilter.fieldsIn(typeElement.getEnclosedElements()); executableElements = ElementFilter.methodsIn(typeElement.getEnclosedElements());
private void processFromProperties(TypeElement type, Set<TypeElement> types) { List<? extends Element> children = type.getEnclosedElements(); VisitorConfig config = conf.getConfig(type, children); // fields if (config.visitFieldProperties()) { for (VariableElement field : ElementFilter.fieldsIn(children)) { TypeElement typeElement = typeExtractor.visit(field.asType()); if (typeElement != null) { types.add(typeElement); } } } // getters if (config.visitMethodProperties()) { for (ExecutableElement method : ElementFilter.methodsIn(children)) { String name = method.getSimpleName().toString(); if ((name.startsWith("get") || name.startsWith("is")) && method.getParameters().isEmpty()) { TypeElement typeElement = typeExtractor.visit(method.getReturnType()); if (typeElement != null) { types.add(typeElement); } } } } }
protected final void init() { getContext().logMessage( Diagnostic.Kind.OTHER, "Initializing type " + getQualifiedName() + "." ); TypeUtils.determineAccessTypeForHierarchy( element, context ); entityAccessTypeInfo = context.getAccessTypeInfo( getQualifiedName() ); List<? extends Element> fieldsOfClass = ElementFilter.fieldsIn( element.getEnclosedElements() ); addPersistentMembers( fieldsOfClass, AccessType.FIELD ); List<? extends Element> methodsOfClass = ElementFilter.methodsIn( element.getEnclosedElements() ); List<Element> gettersAndSettersOfClass = new ArrayList<>(); for (Element rawMethodOfClass: methodsOfClass) { if ( isGetterOrSetter( rawMethodOfClass)) { gettersAndSettersOfClass.add(rawMethodOfClass); } } addPersistentMembers( gettersAndSettersOfClass, AccessType.PROPERTY ); initialized = true; }
continue; for ( Element subElement : ElementFilter.fieldsIn( entity.getTypeElement().getEnclosedElements() ) ) { TypeMirror mirror = subElement.asType(); if ( !TypeKind.DECLARED.equals( mirror.getKind() ) ) {
for (Element element : ElementFilter.fieldsIn(elements.getAllMembers(e))) { if (element.getModifiers().contains(Modifier.PUBLIC) && !element.getModifiers().contains(Modifier.FINAL)) { final Set<TypeMirror> types = fields.computeIfAbsent(element.getSimpleName().toString(), (key -> new HashSet<>()));
private void collectAccessors(TypeElement type, Map<String, Accessor> accesors) { List<? extends Element> allMembers = elements.getAllMembers(type); for (VariableElement field : ElementFilter.fieldsIn(allMembers)) { if (isAccessible(field)) { Accessor accessor = new Accessor(field); accesors.put(accessor.name, accessor); } } // toString, hashCode from Object for (ExecutableElement method : ElementFilter.methodsIn(allMembers)) { TypeElement definingType = (TypeElement) method.getEnclosingElement(); if (definingType.getQualifiedName().contentEquals(Object.class.getCanonicalName()) || isSimpleAccessor(method) && isAccessible(method)) { Accessor accessor = new Accessor(method); accesors.put(accessor.name, accessor); } } // For other accessors we use shared utility AccessorProvider provider = SourceOrdering.getAllAccessorsProvider(elements, types, type); for (ExecutableElement method : provider.get()) { // this should be already checked, but we check for completeness if (isSimpleAccessor(method) && isAccessible(method)) { Accessor accessor = new Accessor(method); accesors.put(accessor.name, accessor); } } }
for (VariableElement field : ElementFilter.fieldsIn(elements)) { String name = field.getSimpleName().toString(); if (configuration.isBlockedField(field)) {
} else { Set<VariableElement> elements = ElementFilter.fieldsIn(element().getEnclosedElements()) .stream() .filter(element -> !element.getModifiers().contains(Modifier.PRIVATE) &&
private void checkForMutableFields(Protoclass protoclass, TypeElement element) { Elements elementUtils = protoclass.environment().processing().getElementUtils(); for (VariableElement field : ElementFilter.fieldsIn( elementUtils.getAllMembers(CachingElements.getDelegate(element)))) { if (!field.getModifiers().contains(Modifier.FINAL)) { Reporter report = protoclass.report(); boolean ownField = CachingElements.equals(element, field.getEnclosingElement()); if (ownField) { report.withElement(field) .warning(About.INCOMPAT, "Avoid introduction of fields (except constants) in abstract value types"); } else { report.warning(About.INCOMPAT, "Abstract value type inherits mutable fields"); } } } }
private void createFactoriesForClassesWithInjectAnnotatedFields(RoundEnvironment roundEnv) { for (VariableElement fieldElement : ElementFilter.fieldsIn(roundEnv.getElementsAnnotatedWith(Inject.class))) { processClassContainingInjectAnnotatedMember(fieldElement.getEnclosingElement(), mapTypeElementToConstructorInjectionTarget); } }
protected void processInjectAnnotatedFields(RoundEnvironment roundEnv) { for (VariableElement element : ElementFilter.fieldsIn(roundEnv.getElementsAnnotatedWith(Inject.class))) { if (!isExcludedByFilters((TypeElement) element.getEnclosingElement())) { processInjectAnnotatedField(element, mapTypeElementToFieldInjectorTargetList); } } }