private PackageElement getPackageElement(TypeElement subscriberClass) { Element candidate = subscriberClass.getEnclosingElement(); while (!(candidate instanceof PackageElement)) { candidate = candidate.getEnclosingElement(); } return (PackageElement) candidate; }
public boolean isInnerClass() { return classElement.getEnclosingElement().getKind() == ElementKind.CLASS; }
static String getClassFQName(TypeElement elem) { StringBuilder name = new StringBuilder(); while (isClassy(elem.getEnclosingElement().getKind())) { name.insert(0, "$" + elem.getSimpleName()); elem = (TypeElement) elem.getEnclosingElement(); } name.insert(0, elem.getQualifiedName()); return name.toString(); }
/** * 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); }
private DocumentedPackage getDocumentedPackage(TypeElement type) { Element pkgElement = type.getEnclosingElement(); return getDocumentedPackage(pkgElement.toString()); }
@Override default Element getEnclosingElement() { return getDelegate().getEnclosingElement(); } }
private static String extractPackageName(TypeElement typeElement) { Element enclosing = typeElement.getEnclosingElement(); while (enclosing != null) { if (enclosing instanceof PackageElement) { PackageElement pkg = (PackageElement) enclosing; if (pkg.isUnnamed()) { return ""; } String fqcn = pkg.getQualifiedName().toString(); return fqcn; } enclosing = enclosing.getEnclosingElement(); } return ""; }
public String generatedClassQualifiedNameFromQualifiedName(String qualifiedName) { TypeElement type = typeElementFromQualifiedName(qualifiedName); if (type.getNestingKind() == NestingKind.MEMBER) { String parentGeneratedClass = generatedClassQualifiedNameFromQualifiedName(type.getEnclosingElement().asType().toString()); return parentGeneratedClass + "." + type.getSimpleName().toString() + classSuffix(); } else { return qualifiedName + classSuffix(); } }
/** Returns the class name for {@code element}. */ public static ClassName get(TypeElement element) { checkNotNull(element, "element == null"); String simpleName = element.getSimpleName().toString(); return element.getEnclosingElement().accept(new SimpleElementVisitor8<ClassName, Void>() { @Override public ClassName visitPackage(PackageElement packageElement, Void p) { return new ClassName(packageElement.getQualifiedName().toString(), null, simpleName); } @Override public ClassName visitType(TypeElement enclosingClass, Void p) { return ClassName.get(enclosingClass).nestedClass(simpleName); } @Override public ClassName visitUnknown(Element unknown, Void p) { return get("", simpleName); } @Override public ClassName defaultAction(Element enclosingElement, Void p) { throw new IllegalArgumentException("Unexpected type nesting: " + element); } }, null); }
public String getBuilderName() { String builderName = getSimpleName() + "Builder"; if(isInnerClass()) { return classElement.getEnclosingElement().getSimpleName() + "$$" + builderName; } else { return builderName; } }
/** * Returns the primary class simple name prefix for an element * who represents a MessageBundle or MessageLogger interface. * * @param element the element * * @return the translation file name prefix * * @throws IllegalArgumentException if element is null or the element is not an interface */ private static String getPrimaryClassNamePrefix(final TypeElement element) { if (element == null) { throw new IllegalArgumentException("The element parameter cannot be null"); } if (!element.getKind().isInterface()) { throw new IllegalArgumentException("The element parameter is not an interface"); } String translationFileName = element.getSimpleName().toString(); //Check if it's an inner interface Element enclosingElt = element.getEnclosingElement(); while (enclosingElt != null && enclosingElt instanceof TypeElement) { translationFileName = String.format("%s$%s", enclosingElt.getSimpleName().toString(), translationFileName); enclosingElt = enclosingElt.getEnclosingElement(); } return translationFileName; }
private ResourceValue parseResourceSymbol(VariableElement symbol) { TypeElement resourceClass = (TypeElement) symbol.getEnclosingElement(); // eg com.airbnb.epoxy.R String rClass = ((TypeElement) resourceClass.getEnclosingElement()).getQualifiedName().toString(); // eg com.airbnb.epoxy.R.layout String resourceClassName = resourceClass.getQualifiedName().toString(); // Make sure this is the right resource type if (!(rClass + "." + resourceType).equals(resourceClassName)) { errorLogger .logError("%s annotation requires a %s resource but received %s. (Element: %s)", annotationClass.getSimpleName(), resourceType, resourceClass, element.getSimpleName()); return null; } // eg button_layout, as in R.layout.button_layout String resourceName = symbol.getSimpleName().toString(); Object resourceValue = symbol.getConstantValue(); if (!(resourceValue instanceof Integer)) { errorLogger.logError("%s annotation requires an int value but received %s. (Element: %s)", annotationClass.getSimpleName(), symbol.getSimpleName(), element.getSimpleName()); return null; } ClassName rClassName = getClassName(resourceClassName, resourceType); saveResourceValuesForRClass(rClassName, resourceClass); return new ResourceValue(rClassName, resourceName, (int) resourceValue); }
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; }
visitor.visit(importMap.get(type).getEnclosingElement(), type); && !javaLang.equals(imp.getEnclosingElement())) { imports.add(imp.getQualifiedName().toString());
private void collectEnclosingElements(Object userObject, Stack<Object> enclosing, Set<Object> visited) { if (visited.contains(userObject)) { return; } visited.add(userObject); enclosing.add(userObject); if (userObject instanceof Method) { collectEnclosingElements(((Method) userObject).getDeclaringClass(), enclosing, visited); } else if (userObject instanceof ExecutableElement) { collectEnclosingElements(((ExecutableElement) userObject).getEnclosingElement(), enclosing, visited); } else if (userObject instanceof Class) { Class type = (Class) userObject; if (type.getEnclosingMethod() != null) { collectEnclosingElements(type.getEnclosingMethod(), enclosing, visited); } else if (type.getDeclaringClass() != null) { collectEnclosingElements(type.getDeclaringClass(), enclosing, visited); } } else if (userObject instanceof TypeElement) { Element enclosingElement = ((TypeElement) userObject).getEnclosingElement(); if (enclosingElement instanceof TypeElement || enclosingElement instanceof ExecutableElement) { collectEnclosingElements(enclosingElement, enclosing, visited); } } }
if (element.getEnclosingElement() == null || element.getEnclosingElement().getKind() != PACKAGE) { loggingUtil.error( element, "DartModel class %s must be a top level class.", element.getSimpleName());
private List<DeepLinkAnnotatedElement> getElements() throws MalformedURLException { TypeElement element1 = mock(TypeElement.class); Name name1 = mock(Name.class); when(elements.getDocComment(element1)) .thenReturn("Sample doc \n @param empty \n @return nothing"); when(element1.getSimpleName()).thenReturn(name1); when(name1.toString()).thenReturn("DocClass"); TypeElement element2 = mock(TypeElement.class); TypeElement element2Enclosed = mock(TypeElement.class); Name name2 = mock(Name.class); Name name2Enclosed = mock(Name.class); when(element2.getSimpleName()).thenReturn(name2); when(name2.toString()).thenReturn("DocMethod"); when(element2.getEnclosingElement()).thenReturn(element2Enclosed); when(element2Enclosed.getSimpleName()).thenReturn(name2Enclosed); when(name2Enclosed.toString()).thenReturn("DocClass"); DeepLinkAnnotatedElement deepLinkElement1 = new DeepLinkAnnotatedElement("airbnb://example.com/{foo}/bar", element1, DeepLinkEntry.Type.CLASS); DeepLinkAnnotatedElement deepLinkElement2 = new DeepLinkAnnotatedElement("airbnb://example.com/{foo}/bar", element2, DeepLinkEntry.Type.METHOD); return ImmutableList.of(deepLinkElement1, deepLinkElement2); } }
protected void setGeneratedClass() throws Exception { String annotatedComponentQualifiedName = annotatedElement.getQualifiedName().toString(); annotatedClass = getCodeModel().directClass(annotatedElement.asType().toString()); if (annotatedElement.getNestingKind().isNested()) { Element enclosingElement = annotatedElement.getEnclosingElement(); GeneratedClassHolder enclosingHolder = environment.getGeneratedClassHolder(enclosingElement); String generatedBeanSimpleName = annotatedElement.getSimpleName().toString() + classSuffix(); int modifier = PUBLIC | STATIC; if (environment.getOptionBooleanValue(OPTION_GENERATE_FINAL_CLASSES)) { modifier |= FINAL; } generatedClass = enclosingHolder.getGeneratedClass()._class(modifier, generatedBeanSimpleName, EClassType.CLASS); } else { String generatedClassQualifiedName = annotatedComponentQualifiedName + classSuffix(); int modifier = PUBLIC; if (environment.getOptionBooleanValue(OPTION_GENERATE_FINAL_CLASSES)) { modifier |= FINAL; } generatedClass = getCodeModel()._class(modifier, generatedClassQualifiedName, EClassType.CLASS); } codeModelHelper.generify(generatedClass, annotatedElement); setExtends(); codeModelHelper.copyNonAAAnnotations(generatedClass, annotatedElement.getAnnotationMirrors()); }
String generatedCodePackageName = appModule.getEnclosingElement().toString();
if (shadowType.getEnclosingElement().getKind() == ElementKind.CLASS && !shadowType.getModifiers().contains(Modifier.STATIC)) {