Refine search
private boolean isAbstractClass(Element annotatedElement) { if (annotatedElement instanceof TypeElement) { TypeElement typeElement = (TypeElement) annotatedElement; return typeElement.getKind() == ElementKind.CLASS && typeElement.getModifiers().contains(Modifier.ABSTRACT); } else { return false; } }
public boolean actualIsPublic() { return actualType.getModifiers().contains(Modifier.PUBLIC); }
public static boolean isPublic(TypeElement element) { return element.getModifiers().contains(PUBLIC); }
public static boolean isAbstract(TypeElement element) { return element.getModifiers().contains(ABSTRACT); }
private boolean isVisible(String myPackage, TypeElement typeElement) { Set<Modifier> modifiers = typeElement.getModifiers(); boolean visible; if (modifiers.contains(Modifier.PUBLIC)) { visible = true; } else if (modifiers.contains(Modifier.PRIVATE) || modifiers.contains(Modifier.PROTECTED)) { visible = false; } else { String subscriberPackage = getPackageElement(typeElement).getQualifiedName().toString(); if (myPackage == null) { visible = subscriberPackage.length() == 0; } else { visible = myPackage.equals(subscriberPackage); } } return visible; }
public static boolean isPublic(TypeElement element) { return element.getModifiers().contains(PUBLIC); }
public static boolean isAbstract(TypeElement element) { return element.getModifiers().contains(ABSTRACT); }
/** * Returns true if generated code can invoke {@code constructor}. That is, if * the constructor is non-private and its enclosing class is either a * top-level class or a static nested class. */ public static boolean isCallableConstructor(ExecutableElement constructor) { if (constructor.getModifiers().contains(Modifier.PRIVATE)) { return false; } TypeElement type = (TypeElement) constructor.getEnclosingElement(); return type.getEnclosingElement().getKind() == ElementKind.PACKAGE || type.getModifiers().contains(Modifier.STATIC); }
@Override public Void visitType(TypeElement e, Void aVoid) { if(!e.getModifiers().contains(Modifier.ABSTRACT)) { Element sc = asElement(e.getSuperclass()); if (sc!=null && ((TypeElement)sc).getQualifiedName().contentEquals("hudson.Plugin")) { try { write(e); } catch (IOException x) { processingEnv.getMessager().printMessage(Kind.ERROR, Functions.printThrowable(x), e); } } } return super.visitType(e, aVoid); }
static Builder newBuilder(TypeElement enclosingElement) { TypeMirror typeMirror = enclosingElement.asType(); boolean isView = isSubtypeOfType(typeMirror, VIEW_TYPE); boolean isActivity = isSubtypeOfType(typeMirror, ACTIVITY_TYPE); boolean isDialog = isSubtypeOfType(typeMirror, DIALOG_TYPE); TypeName targetType = TypeName.get(typeMirror); if (targetType instanceof ParameterizedTypeName) { targetType = ((ParameterizedTypeName) targetType).rawType; } String packageName = getPackage(enclosingElement).getQualifiedName().toString(); String className = enclosingElement.getQualifiedName().toString().substring( packageName.length() + 1).replace('.', '$'); ClassName bindingClassName = ClassName.get(packageName, className + "_ViewBinding"); boolean isFinal = enclosingElement.getModifiers().contains(Modifier.FINAL); return new Builder(targetType, bindingClassName, isFinal, isView, isActivity, isDialog); }
private boolean isInaccessibleViaGeneratedCode(Class<? extends Annotation> annotationClass, String targetThing, Element element) { boolean hasError = false; TypeElement enclosingElement = (TypeElement) element.getEnclosingElement(); // Verify field or method modifiers. Set<Modifier> modifiers = element.getModifiers(); if (modifiers.contains(PRIVATE) || modifiers.contains(STATIC)) { error(element, "@%s %s must not be private or static. (%s.%s)", annotationClass.getSimpleName(), targetThing, enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } // Verify containing type. if (enclosingElement.getKind() != CLASS) { error(enclosingElement, "@%s %s may only be contained in classes. (%s.%s)", annotationClass.getSimpleName(), targetThing, enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } // Verify containing class visibility is not private. if (enclosingElement.getModifiers().contains(PRIVATE)) { error(enclosingElement, "@%s %s may not be contained in private classes. (%s.%s)", annotationClass.getSimpleName(), targetThing, enclosingElement.getQualifiedName(), element.getSimpleName()); hasError = true; } return hasError; }
private Type createType(TypeElement typeElement, TypeCategory category, List<? extends TypeMirror> typeArgs, boolean deep) { String name = typeElement.getQualifiedName().toString(); String simpleName = typeElement.getSimpleName().toString(); String packageName = env.getElementUtils().getPackageOf(typeElement).getQualifiedName().toString(); Type[] params = new Type[typeArgs.size()]; for (int i = 0; i < params.length; i++) { params[i] = getType(typeArgs.get(i), deep); } return new SimpleType(category, name, packageName, simpleName, false, typeElement.getModifiers().contains(Modifier.FINAL), params); }
void validateExtension(TypeElement typeElement) { if (!typeElement.getModifiers().contains(Modifier.PUBLIC)) { throw new IllegalArgumentException( "RequestOptionsExtensions must be public, including: " + getName(typeElement)); } for (Element element : typeElement.getEnclosedElements()) { if (element.getKind() == ElementKind.CONSTRUCTOR) { validateExtensionConstructor(element); } else if (element.getKind() == ElementKind.METHOD) { ExecutableElement executableElement = (ExecutableElement) element; if (executableElement.getAnnotation(GlideOption.class) != null) { validateGlideOption(executableElement); } else if (executableElement.getAnnotation(GlideType.class) != null) { validateGlideType(executableElement); } } } }
@Override public boolean isUnimplementable() { boolean extendable = annotationOf(Entity.class).map(Entity::extendable).orElse(true); return !extendable || (element().getKind().isClass() && element().getModifiers().contains(Modifier.FINAL)); }
if ((modifiers.contains(PRIVATE) && !skipPrivateFieldCheck) || modifiers.contains(STATIC)) { errorLogger.logError( "%s annotations must not be on private or static fields. (class: %s, field: %s)", if (!enclosingElement.getModifiers().contains(STATIC)) { errorLogger.logError( "Nested classes with %s annotations must be static. (class: %s, field: %s)", if (enclosingElement.getModifiers().contains(PRIVATE)) { errorLogger.logError( "%s annotations may not be contained in private classes. (class: %s, field: %s)",
private boolean verifyServiceProviderSignature(TypeElement clazz, Class<? extends Annotation> annotation) { AnnotationMirror ann = findAnnotationMirror(clazz, annotation); if (!clazz.getModifiers().contains(Modifier.PUBLIC)) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must be public", clazz, ann); return false; } if (clazz.getModifiers().contains(Modifier.ABSTRACT)) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must not be abstract", clazz, ann); return false; } if (clazz.getEnclosingElement().getKind() != ElementKind.PACKAGE && !clazz.getModifiers().contains(Modifier.STATIC)) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must be static", clazz, ann); return false; } { boolean hasDefaultCtor = false; for (ExecutableElement constructor : ElementFilter.constructorsIn(clazz.getEnclosedElements())) { if (constructor.getModifiers().contains(Modifier.PUBLIC) && constructor.getParameters().isEmpty()) { hasDefaultCtor = true; break; } } if (!hasDefaultCtor) { processingEnv.getMessager().printMessage(Kind.ERROR, clazz + " must have a public no-argument constructor", clazz, ann); return false; } } return true; }
public void componentRegistered(Element element, AndroidManifest androidManifest, boolean printWarning, ElementValidation valid) { TypeElement typeElement = (TypeElement) element; if (typeElement.getModifiers().contains(Modifier.ABSTRACT)) { return; } if (androidManifest.isLibraryProject()) { return; } String componentQualifiedName = typeElement.getQualifiedName().toString(); String generatedComponentQualifiedName = componentQualifiedName + classSuffix(); List<String> componentQualifiedNames = androidManifest.getComponentQualifiedNames(); if (!componentQualifiedNames.contains(generatedComponentQualifiedName)) { String simpleName = typeElement.getSimpleName().toString(); String generatedSimpleName = simpleName + classSuffix(); if (componentQualifiedNames.contains(componentQualifiedName)) { valid.addError("The AndroidManifest.xml file contains the original component, and not the AndroidAnnotations generated component. Please register " + generatedSimpleName + " instead of " + simpleName); } else { if (printWarning) { valid.addWarning("The component " + generatedSimpleName + " is not registered in the AndroidManifest.xml file."); } } } }
public void applicationRegistered(Element element, AndroidManifest manifest, ElementValidation valid) { if (manifest.isLibraryProject()) { return; } String applicationClassName = manifest.getApplicationClassName(); if (applicationClassName != null) { TypeElement typeElement = (TypeElement) element; String componentQualifiedName = typeElement.getQualifiedName().toString(); String generatedComponentQualifiedName = componentQualifiedName + classSuffix(); if (!typeElement.getModifiers().contains(Modifier.ABSTRACT) && !applicationClassName.equals(generatedComponentQualifiedName)) { if (applicationClassName.equals(componentQualifiedName)) { valid.addError("The AndroidManifest.xml file contains the original component, and not the AndroidAnnotations generated component." + " Please register " + generatedComponentQualifiedName + " instead of " + componentQualifiedName); } else { valid.addWarning("The component " + generatedComponentQualifiedName + " is not registered in the AndroidManifest.xml file."); } } } else { valid.addError("No application class registered in the AndroidManifest.xml"); } }
boolean isAbstract = type.getModifiers().contains(ABSTRACT); List<Element> staticFields = new ArrayList<Element>(); ExecutableElement constructor = null; if (member.getModifiers().contains(STATIC)) { staticFields.add(member); } else {
TypeElement typeElement = (TypeElement)element; Set<Modifier> modifiers = typeElement.getModifiers(); Validate.isTrue(modifiers.contains(Modifier.PUBLIC), "The modifier public is missing on %s.", typeElement.getQualifiedName());