Refine search
private boolean methodIsAvailableIn(TypeElement element, String methodName) { for (Element method : ElementFilter.methodsIn(element.getEnclosedElements())) { if (method.getSimpleName().contentEquals(methodName)) { return true; } } return false; }
public static ExecutableElement getOnlyMethod(ProcessingEnvironment processingEnv, String className) { final TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(className); final List<ExecutableElement> elements = ElementFilter.methodsIn(typeElement.getEnclosedElements()); if (elements.size() == 1) { return elements.get(0); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Needs exactly one method", typeElement); throw new IllegalArgumentException(); } }
/** * Gets all of the methods of the class and includes the methods of any * implemented interfaces. * * @param typeElement * @return full list of methods. */ public List<ExecutableElement> getMethods(TypeElement typeElement) { List<? extends Element> enclosedElements = typeElement.getEnclosedElements(); List<ExecutableElement> methods = new ArrayList<>(ElementFilter.methodsIn(enclosedElements)); // Add methods of the interfaces. These will be valid as they have gone // through the validator. for (TypeMirror iface : typeElement.getInterfaces()) { DeclaredType dt = (DeclaredType) iface; methods.addAll(ElementFilter.methodsIn(dt.asElement().getEnclosedElements())); } return methods; }
private @Nullable ExecutableElement findMethod(TypeElement typeElement, String getter) { for (ExecutableElement m : ElementFilter.methodsIn(typeElement.getEnclosedElements())) { if (m.getSimpleName().contentEquals(getter)) { return m; } } return null; }
@Override public Optional<ExecutableElement> builderFactoryMethod() { return ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equals("builder")) .findFirst(); }
private static Collection<ExecutableElement> getMessageMethods(final TypeElement intf) { return ElementFilter.methodsIn(intf.getEnclosedElements()) .stream() .filter(method -> !method.isDefault() && !method.getModifiers().contains(Modifier.STATIC)) .collect(Collectors.toList()); } }
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 ); } }
private void validateShadowMethods(TypeElement sdkClassElem, TypeElement shadowClassElem, int classMinSdk, int classMaxSdk, boolean looseSignatures) { for (Element memberElement : ElementFilter.methodsIn(shadowClassElem.getEnclosedElements())) { ExecutableElement methodElement = (ExecutableElement) memberElement; // equals, hashCode, and toString are exempt, because of Robolectric's weird special behavior if (METHODS_ALLOWED_TO_BE_PUBLIC.contains(methodElement.getSimpleName().toString())) { continue; } verifySdkMethod(sdkClassElem, methodElement, classMinSdk, classMaxSdk, looseSignatures); String methodName = methodElement.getSimpleName().toString(); if (methodName.equals(CONSTRUCTOR_METHOD_NAME) || methodName.equals(STATIC_INITIALIZER_METHOD_NAME)) { Implementation implementation = memberElement.getAnnotation(Implementation.class); if (implementation == null) { messager.printMessage( Kind.ERROR, "Shadow methods must be annotated @Implementation", methodElement); } } } }
static boolean overridesMethod(Types types, TypeElement element, String methodName) { while (element != null) { if (ElementFilter.methodsIn(element.getEnclosedElements()).stream() .anyMatch(method -> method.getSimpleName().contentEquals(methodName))) { return true; } TypeMirror superType = element.getSuperclass(); if (superType.getKind() == TypeKind.NONE) { break; } else { element = (TypeElement) types.asElement(superType); } if (namesEqual(element, Object.class.getCanonicalName())) { break; } } return false; }
@Override public Optional<ExecutableElement> factoryMethod() { Optional<ExecutableElement> staticFactory = ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(element -> element.getModifiers().contains(Modifier.STATIC)) .filter(element -> element.getSimpleName().toString().equalsIgnoreCase("create")) .filter(element -> element.getParameters().size() > 0) .filter(element -> element.getReturnType().equals(element().asType())) .findAny(); Optional<ExecutableElement> constructor = ElementFilter.constructorsIn(element().getEnclosedElements()).stream() .filter(element -> element.getParameters().size() > 0) .findAny(); return staticFactory.isPresent() ? staticFactory : constructor; }
MirrorModel(TypeElement element) { this.element = element; ImmutableList.Builder<AttributeModel> builder = ImmutableList.builder(); for (ExecutableElement attribute : ElementFilter.methodsIn(element.getEnclosedElements())) { builder.add(new AttributeModel(attribute)); } this.attributes = builder.build(); this.name = element.getSimpleName().toString(); PackageElement packageElement; for (Element e = element;; e = e.getEnclosingElement()) { if (e.getKind() == ElementKind.PACKAGE) { packageElement = (PackageElement) e; break; } } this.$$package = packageElement.getQualifiedName().toString(); this.qualifiedName = element.getAnnotation(Mirror.Annotation.class).value(); }
private void handleAnnotationMethods() { for (ExecutableElement method : ElementFilter.methodsIn(baseAnnotation.getEnclosedElements())) { elements.add(MoreElements.isAnnotationPresent(method, StringRes.class) ? modelFactory.fromStringResourceAnnotationMethod(method) : modelFactory.fromAnnotationMethod(method)); } }
variableElements = ElementFilter.fieldsIn(typeElement.getEnclosedElements()); executableElements = ElementFilter.methodsIn(typeElement.getEnclosedElements());
private void checkForInvalidSetter(ElementValidator validator) { if (!element().getKind().isField()) { for (ExecutableElement element : ElementFilter.methodsIn(entity.element().getEnclosedElements())) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == 1) { String property = Names.removeMethodPrefixes(element.getSimpleName().toString()); if (property.toLowerCase(Locale.ROOT).equalsIgnoreCase(name())) { validator.error("Element \""+ fieldName() + "\" is read-only but has setter (Kotlin: change var to val)"); } } } } }
private void handleBaseBuilderMethods() { for (ExecutableElement method : ElementFilter.methodsIn(baseBuilder.getEnclosedElements())) { if (method.getAnnotation(PreBuild.class) != null) { elements.add(modelFactory.fromPreBuildDelegateMethod(method)); } else if (method.getAnnotation(Transform.class) != null) { final String transform = method.getAnnotation(Transform.class).methodName(); elements.stream().filter(field -> field.getName().equals(transform)).findAny() .ifPresent(element -> elements.set(elements.indexOf(element), modelFactory.fromTransformDelegateMethod(method, element))); } else if (method.getAnnotation(ConfigurationValue.class) != null) { elements.add(modelFactory.fromConfigDelegateMethod(method)); } else if (method.getAnnotation(BuilderMethod.class) != null) { elements.add(modelFactory.fromBuilderDelegateMethod(method)); } } }
private void setClosestRequiredAncestor( ExtraBindingTarget extraBindingTarget, TypeElement superIntentBuilder) { for (ExecutableElement method : methodsIn(superIntentBuilder.getEnclosedElements())) { if (method.getSimpleName().contentEquals(NEXT_STATE_METHOD)) { final TypeMirror returnTypeMirror = method.getReturnType(); if (compilerUtil.isAssignable(returnTypeMirror, "dart.henson.AllRequiredSetState")) { return; } final Element reqElement = ((DeclaredType) typeUtils.erasure(returnTypeMirror)).asElement(); final TypeElement intentBuilderTypeElement = (TypeElement) reqElement.getEnclosingElement(); extraBindingTarget.closestRequiredAncestorPackage = compilerUtil.getPackageName(intentBuilderTypeElement); final String intentBuilderClass = compilerUtil.getClassName( intentBuilderTypeElement, extraBindingTarget.closestRequiredAncestorPackage); extraBindingTarget.closestRequiredAncestorClass = intentBuilderClass.substring(0, intentBuilderClass.indexOf(BUNDLE_BUILDER_SUFFIX)); } } }
ElementFilter.methodsIn(element().getEnclosedElements()).stream() .filter(this::isMethodProcessable) .forEach(getter ->
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); } } } } }
ElementFilter.methodsIn(entity.element().getEnclosedElements())) { List<? extends VariableElement> parameters = element.getParameters(); if (parameters.size() == 1) {
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; }