@Override public List<? extends TypeMirror> getInterfaces() { return delegate.getInterfaces(); }
public void doesNotExtendInvalidInterfaces(TypeElement element, ElementValidation valid) { if (element.getInterfaces().size() > 0) { boolean isValid = true; for (TypeMirror iface : element.getInterfaces()) { if (!VALID_REST_INTERFACES.contains(iface.toString())) { isValid = false; break; } } if (!isValid) { valid.addError("%s interfaces can only extend the following interfaces: " + VALID_REST_INTERFACES); } } }
/** * 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; }
public static ImmutableList<TagModel> extractTagsFromSpecClass(Types types, TypeElement element) { final List<? extends TypeMirror> interfaces = element.getInterfaces(); final List<TagModel> tags; if (interfaces != null) { tags = interfaces .stream() .map(t -> ((DeclaredType) t).asElement()) .map(t -> newTagModel(t, types)) .collect(Collectors.toList()); } else { tags = Collections.emptyList(); } return ImmutableList.copyOf(tags); }
return true; for (TypeMirror interfaceType : typeElement.getInterfaces()) { if (isSubtypeOfType(interfaceType, otherType)) { return true;
@Override default List<? extends TypeMirror> getInterfaces() { return getDelegate().getInterfaces(); }
/** * This method returns either an empty String or {@code "(Parcelable)"} if the extra type is * Parcelable. We need this explicit conversion in cases where the extra type is both Parcelable * and Serializable. In that case we will prefer Parcelable. Not that the extra type has to * directly implement Parcelable, not via a super class. * * @param extraType the type that might be parcelable. * @return either an empty String or {@code "(Parcelable)"} if the extra type is Parcelable */ private String doCreateParcelableCastIfExtraIsParcelable(TypeMirror extraType) { String castToParcelableIfNecessary = ""; if (extraType instanceof DeclaredType) { boolean isParcelable = false; final TypeElement typeElement = (TypeElement) ((DeclaredType) extraType).asElement(); for (TypeMirror interfaceType : typeElement.getInterfaces()) { if ("android.os.Parcelable".equals(interfaceType.toString())) { isParcelable = true; } } if (isParcelable) { castToParcelableIfNecessary = "(android.os.Parcelable)"; } } return castToParcelableIfNecessary; }
private void addSuperInterfaceMethods(List<? extends TypeMirror> superInterfaces, TypeSpec.Builder classBuilder) { if (superInterfaces != null && !superInterfaces.isEmpty()) { for (TypeMirror tm : superInterfaces) { try { if (tm.getKind().equals(TypeKind.DECLARED)) { TypeElement de = (TypeElement) ((DeclaredType) tm).asElement(); addMethods(de, classBuilder); addSuperInterfaceMethods(de.getInterfaces(), classBuilder); } } catch (Exception e) { processingEnv.getMessager().printMessage(Diagnostic.Kind.WARNING, "MotanAsyncProcessor process superinterface " + tm.toString() + " fail. exception:" + e.getMessage()); e.printStackTrace(); } } } }
TypeMirror findInterface(TypeElement shadowPickerType, Class<?> interfaceClass) { TypeMirror shadowPickerMirror = elements .getTypeElement(interfaceClass.getName()) .asType(); for (TypeMirror typeMirror : shadowPickerType.getInterfaces()) { if (types.erasure(typeMirror).equals(types.erasure(shadowPickerMirror))) { return typeMirror; } } return null; }
return true; for (TypeMirror interfaceType : typeElement.getInterfaces()) { if (isSubtypeOfType(interfaceType, otherType)) { return true;
public boolean process(final Set<? extends TypeElement> annotations, final RoundEnvironment roundEnv) { if (resetResults) { processingResults = new HashMap<>(); } for (Element element : roundEnv.getElementsAnnotatedWith(Wid.class)) { if (element instanceof TypeElement) { TypeElement typeElement = (TypeElement) element; processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, MessageFormat.format("Wid Processor : processing class {0}.", typeElement.asType().toString())); processingResults.put(typeElement.asType().toString(), new ArrayList<>()); if (typeElement.getInterfaces() != null && typeElement.getInterfaces().size() > 0) { for (TypeMirror mirror : typeElement.getInterfaces()) { if (mirror.getAnnotation(Wid.class) != null) { processingResults.get(typeElement.asType().toString()).add(mirror.getAnnotation(Wid.class)); } } } processingResults.get(typeElement.asType().toString()).add(typeElement.getAnnotation(Wid.class)); } } return postProcessWorkItemDefinition(); }
private static boolean find(String interfaceName, TypeElement typeElement, Set<Element> visited) { if (visited.contains(typeElement)) { return false; } visited.add(typeElement); //logger.finest("trying to find " + interfaceName + " in " + typeElement); if (typeElement.getQualifiedName().contentEquals(interfaceName)) { return true; } for (TypeMirror implemented : typeElement.getInterfaces()) { if (find(interfaceName, (TypeElement) ((DeclaredType) implemented).asElement())) { return true; } } while (typeElement.getSuperclass().getKind() != TypeKind.NONE) { typeElement = (TypeElement) ((DeclaredType) typeElement.getSuperclass()).asElement(); if (find(interfaceName, typeElement)) { return true; } } return false; }
private void writeAsyncClass(Element elem) throws ClassNotFoundException, IOException, Exception { if (elem.getKind().isInterface()) { TypeElement interfaceClazz = (TypeElement) elem; String className = interfaceClazz.getSimpleName().toString(); TypeSpec.Builder classBuilder = TypeSpec.interfaceBuilder(className + ASYNC).addModifiers(Modifier.PUBLIC) .addSuperinterface(TypeName.get(elem.asType())); // add class generic type classBuilder.addTypeVariables(getTypeNames(interfaceClazz.getTypeParameters())); // add direct method addMethods(interfaceClazz, classBuilder); // add method form superinterface addSuperInterfaceMethods(interfaceClazz.getInterfaces(), classBuilder); // write class JavaFile javaFile = JavaFile.builder(processingEnv.getElementUtils().getPackageOf(interfaceClazz).getQualifiedName().toString(), classBuilder.build()).build(); javaFile.writeTo(new File(System.getProperty("basedir"), TARGET_DIR)); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "MotanAsyncProcessor not process, because " + elem.toString() + " not a interface."); } }
private static boolean implementsInterface(Types types, TypeElement element, String interfaceName) { // check name or interfaces if (namesEqual(element, interfaceName)) { return true; } TypeMirror type = element.asType(); while (type != null && type.getKind() != TypeKind.NONE) { TypeElement currentElement = (TypeElement) types.asElement(type); if (currentElement == null) { break; } List<? extends TypeMirror> interfaces = element.getInterfaces(); for (TypeMirror interfaceType : interfaces) { interfaceType = types.erasure(interfaceType); TypeElement typeElement = (TypeElement) types.asElement(interfaceType); if (typeElement != null && implementsInterface(types, typeElement, interfaceName)) { return true; } } type = currentElement.getSuperclass(); } return false; }
@Override public Boolean visitDeclared(DeclaredType declaredType, Element element) { if ( ElementKind.ENUM.equals( element.getKind() ) ) { return Boolean.TRUE; } if ( ElementKind.CLASS.equals( element.getKind() ) || ElementKind.INTERFACE.equals( element.getKind() ) ) { TypeElement typeElement = ( (TypeElement) element ); String typeName = typeElement.getQualifiedName().toString(); if ( Constants.BASIC_TYPES.contains( typeName ) ) { return Boolean.TRUE; } if ( TypeUtils.containsAnnotation( element, Constants.EMBEDDABLE ) ) { return Boolean.TRUE; } for ( TypeMirror mirror : typeElement.getInterfaces() ) { TypeElement interfaceElement = (TypeElement) context.getTypeUtils().asElement( mirror ); if ( "java.io.Serializable".equals( interfaceElement.getQualifiedName().toString() ) ) { return Boolean.TRUE; } } } return Boolean.FALSE; } }
}); final List<? extends TypeMirror> mirrors = typeElement.getInterfaces(); final List<TypeSpec> superinterfaces = mirrors != null && !mirrors.isEmpty()
private Map<String, TypeElement> findAnnotation(RoundEnvironment roundEnv) { Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(Converter.class); Map<String, TypeElement> converterMap = new HashMap<>(); for (Element element : set) { if (element instanceof TypeElement) { TypeElement typeElement = (TypeElement)element; Set<Modifier> modifiers = typeElement.getModifiers(); Validate.isTrue(modifiers.contains(Modifier.PUBLIC), "The modifier public is missing on %s.", typeElement.getQualifiedName()); List<? extends TypeMirror> interfaces = typeElement.getInterfaces(); if (CollectionUtils.isEmpty(interfaces)) { mLog.w( String.format("The annotation Converter must be used in a subclass of [BodyConverter] on %s.", typeElement.getQualifiedName())); continue; } for (TypeMirror typeMirror : interfaces) { if (mConverter.equals(TypeName.get(typeMirror))) { converterMap.put(getGroup(typeElement), typeElement); break; } else { mLog.w(String.format( "The annotation Converter must be used in a subclass of [BodyConverter] on %s.", typeElement.getQualifiedName())); } } } } return converterMap; }
private Map<String, TypeElement> findAnnotation(RoundEnvironment roundEnv) { Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(Resolver.class); Map<String, TypeElement> resolverMap = new HashMap<>(); for (Element element : set) { if (element instanceof TypeElement) { TypeElement typeElement = (TypeElement)element; Set<Modifier> modifiers = typeElement.getModifiers(); Validate.isTrue(modifiers.contains(Modifier.PUBLIC), "The modifier public is missing on %s.", typeElement.getQualifiedName()); List<? extends TypeMirror> interfaces = typeElement.getInterfaces(); if (CollectionUtils.isEmpty(interfaces)) { mLog.w(String.format( "The annotation Resolver must be used in a subclass of [ExceptionResolver] on %s.", typeElement.getQualifiedName())); continue; } for (TypeMirror typeMirror : interfaces) { if (mResolver.equals(TypeName.get(typeMirror))) { resolverMap.put(getGroup(typeElement), typeElement); break; } else { mLog.w(String.format( "The annotation Resolver must be used in a subclass of [ExceptionResolver] on %s.", typeElement.getQualifiedName())); } } } } return resolverMap; }
private void collectInterfacesMirrors(TypeMirror typeMirror, TypevarContext context) { if (typeMirror.getKind() != TypeKind.DECLARED) { return; } DeclaredType declaredType = toDeclaredType(typeMirror); TypeElement e = toTypeElement(declaredType); if (e.getKind().isInterface()) { implementedInterfaces.add(e); String stringified = stringify(declaredType, context); TypevarContext nestedContext = new TypevarContext(e, stringified); implementedInterfaceNames.add(stringified); for (TypeMirror m : e.getInterfaces()) { collectInterfacesMirrors(m, nestedContext); } } }
private void collectHierarchyMirrors(TypeMirror typeMirror, String stringRepresentation) { if (typeMirror.getKind() != TypeKind.DECLARED || typeMirror.toString().equals(Object.class.getName())) { return; } DeclaredType declaredType = toDeclaredType(typeMirror); TypeElement e = toTypeElement(declaredType); TypevarContext context = new TypevarContext(e, stringRepresentation); collectInterfacesMirrors(declaredType, context); TypeMirror superclassMirror = e.getSuperclass(); if (superclassMirror.getKind() != TypeKind.NONE) { DeclaredType superclass = toDeclaredType(superclassMirror); String stringified = stringify(superclass, context); if (!stringified.equals(Object.class.getName())) { extendedClasses.add(toTypeElement(superclass)); extendedClassNames.add(stringified); collectHierarchyMirrors(superclass, stringified); } } for (TypeMirror m : e.getInterfaces()) { collectUnresolvedInterface(m, context); collectInterfacesMirrors(m, context); } }