TypeMirror verticleType = processingEnv.getElementUtils().getTypeElement(Verticle.class.getName()).asType(); for (Element rootElt : roundEnv.getRootElements()) { Set<Modifier> modifiers = rootElt.getModifiers(); if (rootElt.getKind() == ElementKind.CLASS && !modifiers.contains(Modifier.ABSTRACT) && modifiers.contains(Modifier.PUBLIC) && processingEnv.getTypeUtils().isSubtype(rootElt.asType(), verticleType)) { TypeElement typeElt = (TypeElement) rootElt; for (Element enclosedElt : typeElt.getEnclosedElements()) { if (enclosedElt.getKind() == ElementKind.METHOD) { ExecutableElement methodElt = (ExecutableElement) enclosedElt; FileObject obj = processingEnv.getFiler().getResource(StandardLocation.SOURCE_PATH, "", typeElt.getQualifiedName().toString().replace('.', '/') + ".java"); File srcFolder = new File(obj.toUri()).getParentFile(); String filename = Case.SNAKE.format(Case.CAMEL.parse(typeElt.getSimpleName().toString())); continue; String folderPath = processingEnv.getElementUtils().getPackageOf(typeElt).getQualifiedName().toString().replace('.', '/'); File dstFolder = new File(new File(outputDir, lang.getExtension()), folderPath); if (dstFolder.exists() || dstFolder.mkdirs()) {
@Nullable private TypeElement validated(Element element) { Element enclosingElement = element.getEnclosingElement(); if (element.getKind() == ElementKind.ANNOTATION_TYPE && element.getModifiers().contains(Modifier.PUBLIC) && enclosingElement != null && (enclosingElement.getKind() != ElementKind.PACKAGE || !((PackageElement) enclosingElement).isUnnamed())) { return (TypeElement) element; } processing().getMessager().printMessage( Diagnostic.Kind.ERROR, "Element annotated with @Mirror.Annotation annotation should public annotation type in a package", element); return null; } }
private void collectPackage(TypeElement type, Map<String, TypeMirror> collected) { for (TypeElement samePackageType : ElementFilter.typesIn(elements.getPackageOf(type).getEnclosedElements())) { collectIfSimpleType(samePackageType.asType(), collected); } }
public static String getPackageName(Elements elements, TypeElement typeElement) throws NoPackageNameException { PackageElement pkg = elements.getPackageOf(typeElement); if (pkg.isUnnamed()) { throw new NoPackageNameException(typeElement); } return pkg.getQualifiedName().toString(); }
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 ""; }
private void writePackage(JavaWriter jw, TypeElement type) throws IOException { PackageElement pkg = processingEnv.getElementUtils().getPackageOf(type); if (!pkg.isUnnamed()) { jw.emitPackage(pkg.getQualifiedName().toString()); } else { jw.emitPackage(""); } }
@Override public void processTypeElement(final TypeElement annotation, final TypeElement element, final MessageInterface messageInterface) { if (generatedFilesPath != null) { if (element.getKind().isInterface()) { String packageName = processingEnv.getElementUtils().getPackageOf(element).getQualifiedName().toString(); String relativePath = packageName.replace('.', File.separatorChar); String fileName = getPrimaryClassNamePrefix(element) + GENERATED_FILE_EXTENSION; this.generateSkeletalTranslationFile(relativePath, fileName, messageInterface); } } // Always generate an Interface.i18n.properties file. generateDefaultTranslationFile(messageInterface); }
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."); } }
Set<Element> customAnnotations = new HashSet<>(); for (Element annotation : annotations) { if (annotation.getAnnotation(DEEP_LINK_SPEC_CLASS) != null) { customAnnotations.add(annotation); String[] prefix = customAnnotation.getAnnotation(DEEP_LINK_SPEC_CLASS).prefix(); if (Utils.hasEmptyOrNullString(prefix)) { error(customAnnotation, "Prefix property cannot have null or empty strings"); String qualifiedName = returnType.getQualifiedName().toString(); if (!qualifiedName.equals("android.content.Intent") && !qualifiedName.equals("androidx.core.app.TaskStackBuilder")) { String packageName = processingEnv.getElementUtils() .getPackageOf(deepLinkHandlerElement).getQualifiedName().toString(); try { generateDeepLinkDelegate(packageName, typeElements); roundEnv.getElementsAnnotatedWith(DeepLinkModule.class); for (Element deepLinkModuleElement : deepLinkModuleElements) { String packageName = processingEnv.getElementUtils() .getPackageOf(deepLinkModuleElement).getQualifiedName().toString(); try { generateDeepLinkLoader(packageName, deepLinkModuleElement.getSimpleName().toString(),
BaseModelAttributeInfo(Element attribute, Types typeUtils, Elements elements, ErrorLogger errorLogger) { this.typeUtils = typeUtils; this.setFieldName(attribute.getSimpleName().toString()); setTypeMirror(attribute.asType()); setJavaDocString(elements.getDocComment(attribute)); classElement = (TypeElement) attribute.getEnclosingElement(); setModelName(classElement.getSimpleName().toString()); setPackageName(elements.getPackageOf(classElement).getQualifiedName().toString()); this.setHasSuperSetter(hasSuperMethod(classElement, attribute)); this.setHasFinalModifier(attribute.getModifiers().contains(FINAL)); this.setPackagePrivate(isFieldPackagePrivate(attribute)); EpoxyAttribute annotation = attribute.getAnnotation(EpoxyAttribute.class); Set<Option> options = new HashSet<>(Arrays.asList(annotation.value())); validateAnnotationOptions(errorLogger, annotation, options); //noinspection deprecation setUseInHash(annotation.hash() && !options.contains(Option.DoNotHash)); setIgnoreRequireHashCode(options.contains(Option.IgnoreRequireHashCode)); setDoNotUseInToString(options.contains(Option.DoNotUseInToString)); setGenerateSetter(annotation.setter() && !options.contains(Option.NoSetter)); setGenerateGetter(!options.contains(Option.NoGetter)); setPrivate(attribute.getModifiers().contains(PRIVATE)); if (isPrivate()) { findGetterAndSetterForPrivateField(errorLogger); } buildAnnotationLists(attribute.getAnnotationMirrors()); }
private void processJsonObjectAnnotation(Element element, Map<String, JsonObjectHolder> jsonObjectMap, Elements elements, Types types) { TypeElement typeElement = (TypeElement)element; if (element.getModifiers().contains(PRIVATE)) { error(element, "%s: %s annotation can't be used on private classes.", typeElement.getQualifiedName(), JsonObject.class.getSimpleName()); String packageName = elements.getPackageOf(typeElement).getQualifiedName().toString(); String objectClassName = TypeUtils.getSimpleClassName(typeElement, packageName); String injectedSimpleClassName = objectClassName + Constants.MAPPER_CLASS_SUFFIX; boolean abstractClass = element.getModifiers().contains(ABSTRACT); List<? extends TypeParameterElement> parentTypeParameters = new ArrayList<>(); List<String> parentUsedTypeParameters = new ArrayList<>(); TypeName parentClassName = null; TypeMirror superclass = typeElement.getSuperclass(); if (superclass.getKind() != TypeKind.NONE) { TypeElement superclassElement = (TypeElement)types.asElement(superclass); if (superclassElement.getAnnotation(JsonObject.class) != null) { if (superclassElement.getTypeParameters() != null) { parentTypeParameters = superclassElement.getTypeParameters(); if (superclassElement.getAnnotation(JsonObject.class) != null) { String superclassPackageName = elements.getPackageOf(superclassElement).getQualifiedName().toString(); parentClassName = ClassName.get(superclassPackageName, TypeUtils.getSimpleClassName(superclassElement, superclassPackageName)); break; JsonObject annotation = element.getAnnotation(JsonObject.class);
Descriptor(final Element element, final Elements elements, final Types types) throws AutoMatterProcessorException { if (!element.getKind().isInterface()) { throw new AutoMatterProcessorException("@AutoMatter target must be an interface", element); } this.valueType = (DeclaredType) element.asType(); this.valueTypeElement = (TypeElement) element; this.valueTypeArguments = valueType.getTypeArguments(); this.valueTypeName = nestedName(valueTypeElement, elements); this.isGeneric = !valueTypeArguments.isEmpty(); this.packageName = elements.getPackageOf(element).getQualifiedName().toString(); this.builderName = element.getSimpleName().toString() + "Builder"; final String typeParameterization = isGeneric ? "<" + valueTypeArguments.stream().map(TypeMirror::toString).collect(joining(",")) + ">" : ""; this.concreteBuilderName = builderName + typeParameterization; this.fullyQualifiedBuilderName = fullyQualifedName(packageName, concreteBuilderName); this.fields = new ArrayList<>(); this.fieldTypes = new LinkedHashMap<>(); this.isPublic = element.getModifiers().contains(PUBLIC); this.toString = findToStringMethod(valueTypeElement); enumerateFields(types); }
NbBundle.Messages messages = e.getAnnotation(NbBundle.Messages.class); if (messages == null) { // bug in java.source, apparently; similar to #195983 continue; String pkg = packageEntry.getKey(); Set<Element> annotatedElements = packageEntry.getValue(); PackageElement pkgE = processingEnv.getElementUtils().getPackageElement(pkg); if (pkgE != null) { Set<Element> unscannedTopElements = new HashSet<Element>(); unscannedTopElements.add(pkgE); try { unscannedTopElements.addAll(pkgE.getEnclosedElements()); } catch (/*NullPointerException,BadClassFile*/RuntimeException x) { // #196556 processingEnv.getMessager().printMessage(Kind.WARNING, "#196556: reading " + pkg + " failed with " + x + " in " + x.getStackTrace()[0] + "; do a clean build!"); processingEnv.getMessager().printMessage(Kind.WARNING, "Could not check for other source files in " + pkg); String simplename = findCompilationUnitName(e); List<String> runningComments = new ArrayList<String>(); for (String keyValue : e.getAnnotation(NbBundle.Messages.class).value()) { if (keyValue.startsWith("#")) { runningComments.add(keyValue);
Encoding(TypeElement type) { this.typeEncoding = type; if (type.getKind() != ElementKind.CLASS || type.getNestingKind() != NestingKind.TOP_LEVEL) { reporter.withElement(type).error("Encoding type '%s' should be top-level class", type.getSimpleName()); this.$$package = processing().getElementUtils().getPackageOf(type).getQualifiedName().toString(); this.name = type.getSimpleName().toString();
TypeElement activityElement = (TypeElement) element.getEnclosingElement(); int id = element.getAnnotation($.class).value(); String fieldName = element.getSimpleName().toString(); String packageName = elementUtils.getPackageOf(activityElement).getQualifiedName().toString(); print("packageName="+packageName);//com.wangpos.s_mvp.ui.login String activityName = activityElement.getSimpleName().toString();
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); }
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(); }
} else if (o1 instanceof Element) { Element e1 = (Element)o1; if (e1.getKind().isField() || e1.getKind() == ElementKind.METHOD) { sb1.append('.').append(e1.getSimpleName()); e1 = e1.getEnclosingElement(); isStatic1 = true; if (e1.getKind().isClass() || e1.getKind().isInterface()) { sb1.insert(0, ((TypeElement)e1).getQualifiedName()); } else if (e1.getKind() == ElementKind.PACKAGE) { sb1.insert(0, ((PackageElement)e1).getQualifiedName()); if (e2.getKind().isClass() || e2.getKind().isInterface()) { sb2.insert(0, ((TypeElement)e2).getQualifiedName()); } else if (e2.getKind() == ElementKind.PACKAGE) { sb2.insert(0, ((PackageElement)e2).getQualifiedName());
/** * Returns a {@link QualifiedName} for {@code type}. */ public static QualifiedName of(TypeElement type) { switch (type.getNestingKind()) { case TOP_LEVEL: PackageElement pkg = (PackageElement) type.getEnclosingElement(); return QualifiedName.of(pkg.getQualifiedName().toString(), type.getSimpleName().toString()); case MEMBER: List<String> reversedNames = new ArrayList<String>(); reversedNames.add(type.getSimpleName().toString()); Element parent = type.getEnclosingElement(); while (parent.getKind() != ElementKind.PACKAGE) { reversedNames.add(parent.getSimpleName().toString()); parent = parent.getEnclosingElement(); } return new QualifiedName( ((PackageElement) parent).getQualifiedName().toString(), ImmutableList.copyOf(Lists.reverse(reversedNames))); default: throw new IllegalArgumentException("Cannot determine qualified name of " + type); } }
final Element e) if (e.getKind().equals(ElementKind.INTERFACE) || e.getKind().equals(ElementKind.CLASS)) PackageElement packageElement = elementUtils.getPackageOf(e); String packageName = packageElement.getQualifiedName().toString(); String className = e.getSimpleName().toString(); AnnotationMirror annotation = getAnnotation(e, annotationElement); processingEnv.getMessager() .printMessage(Diagnostic.Kind.NOTE, "looking for " + packageName + "." + className);