List of usage examples for javax.lang.model.element TypeElement getEnclosedElements
@Override
List<? extends Element> getEnclosedElements();
From source file:com.predic8.membrane.annot.SpringConfigurationXSDGeneratingAnnotationProcessor.java
private void scan(Model m, MainInfo main, ElementInfo ii, TypeElement te) { TypeMirror superclass = te.getSuperclass(); if (superclass instanceof DeclaredType) scan(m, main, ii, (TypeElement) ((DeclaredType) superclass).asElement()); for (Element e2 : te.getEnclosedElements()) { MCAttribute a = e2.getAnnotation(MCAttribute.class); if (a != null) { AttributeInfo ai = new AttributeInfo(); ai.setAnnotation(a);/*from www . j a va2 s. co m*/ ai.setE((ExecutableElement) e2); ai.setRequired(isRequired(e2)); ii.getAis().add(ai); ii.setHasIdField(ii.isHasIdField() || ai.getXMLName().equals("id")); } MCOtherAttributes d = e2.getAnnotation(MCOtherAttributes.class); if (d != null) { OtherAttributesInfo oai = new OtherAttributesInfo(); oai.setOtherAttributesSetter((ExecutableElement) e2); ii.setOai(oai); } MCChildElement b = e2.getAnnotation(MCChildElement.class); if (b != null) { ChildElementInfo cei = new ChildElementInfo(); cei.setEi(ii); cei.setAnnotation(b); cei.setE((ExecutableElement) e2); TypeMirror setterArgType = cei.getE().getParameters().get(0).asType(); if (!(setterArgType instanceof DeclaredType)) throw new ProcessingException("Setter argument must be of an @MCElement-annotated type.", cei.getE().getParameters().get(0)); cei.setTypeDeclaration((TypeElement) ((DeclaredType) setterArgType).asElement()); cei.setPropertyName(AnnotUtils.dejavaify(e2.getSimpleName().toString().substring(3))); cei.setRequired(isRequired(e2)); ii.getCeis().add(cei); // unwrap "java.util.List<?>" and "java.util.Collection<?>" if (cei.getTypeDeclaration().getQualifiedName().toString().startsWith("java.util.List") || cei .getTypeDeclaration().getQualifiedName().toString().startsWith("java.util.Collection")) { cei.setTypeDeclaration( (TypeElement) ((DeclaredType) ((DeclaredType) setterArgType).getTypeArguments().get(0)) .asElement()); cei.setList(true); } ChildElementDeclarationInfo cedi; if (!main.getChildElementDeclarations().containsKey(cei.getTypeDeclaration())) { cedi = new ChildElementDeclarationInfo(); cedi.setTarget(cei.getTypeDeclaration()); cedi.setRaiseErrorWhenNoSpecimen(!cei.getAnnotation().allowForeign()); main.getChildElementDeclarations().put(cei.getTypeDeclaration(), cedi); } else { cedi = main.getChildElementDeclarations().get(cei.getTypeDeclaration()); cedi.setRaiseErrorWhenNoSpecimen( cedi.isRaiseErrorWhenNoSpecimen() || !cei.getAnnotation().allowForeign()); } cedi.addUsedBy(cei); } MCTextContent c = e2.getAnnotation(MCTextContent.class); if (c != null) { TextContentInfo tci = new TextContentInfo(); tci.setPropertyName(AnnotUtils.dejavaify(e2.getSimpleName().toString().substring(3))); ii.setTci(tci); } } HashSet<Integer> childOrders = new HashSet<Integer>(); for (ChildElementInfo cei : ii.getCeis()) { if (!childOrders.add(cei.getAnnotation().order())) throw new ProcessingException("@MCChildElement(order=...) must be unique.", cei.getE()); } Collections.sort(ii.getCeis()); }
From source file:cop.raml.utils.example.JsonExample.java
/** * Retrieves example for given {@code obj} which is not simple element, e.g. class with variables and method. * To build example of this object, read recursively all it's variables (each of them could be not simple element as well), build example and put * it into a map. Only not {@code null} example a placed into the map. * Additionally we consider {@link JsonIgnoreProperties} and {@link JsonIgnore} annotations. * * @param obj not {@code null} complex element * @param visited not {@code null} visited object (use it to avoid cycle references) * @return {@code null} or not empty map of element name tp element example structure */// w w w . j av a 2 s . c om private Map<String, Object> getTypeExample(@NotNull TypeElement obj, @NotNull Set<String> visited) { String name = obj.toString(); if (visited.contains(name)) return null; visited.add(name); try { Set<String> ignored = getIgnoredFields(obj); Map<String, Object> map = new LinkedHashMap<>(); String elementName; Object res; for (Element element : obj.getEnclosedElements()) { if (element.getKind() != ElementKind.FIELD) continue; if (ElementUtils.isStatic(element)) continue; if (ignored.contains(elementName = element.getSimpleName().toString())) continue; if ((res = getElementExample(element, visited)) != null) map.put(elementName, res); } return map; } finally { visited.remove(name); } }
From source file:org.jraf.android.prefs.compiler.PrefsProcessor.java
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { for (TypeElement te : annotations) { for (Element element : roundEnv.getElementsAnnotatedWith(te)) { TypeElement classElement = (TypeElement) element; PackageElement packageElement = (PackageElement) classElement.getEnclosingElement(); String classComment = processingEnv.getElementUtils().getDocComment(classElement); List<Pref> prefList = new ArrayList<Pref>(); // Iterate over the fields of the class for (VariableElement variableElement : ElementFilter.fieldsIn(classElement.getEnclosedElements())) { if (variableElement.getModifiers().contains(Modifier.STATIC)) { // Ignore constants continue; }// w ww . j a v a 2s. co m TypeMirror fieldType = variableElement.asType(); boolean isAllowedType = PrefType.isAllowedType(fieldType); if (!isAllowedType) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, fieldType + " is not allowed here, only these types are allowed: " + PrefType.getAllowedTypes(), variableElement); // Problem detected: halt return true; } String fieldName = variableElement.getSimpleName().toString(); org.jraf.android.prefs.Name fieldNameAnnot = variableElement .getAnnotation(org.jraf.android.prefs.Name.class); String prefName = getPrefName(fieldName, fieldNameAnnot); String prefDefaultValue = getDefaultValue(variableElement, fieldType); if (prefDefaultValue == null) { // Problem detected: halt return true; } String fieldComment = processingEnv.getElementUtils().getDocComment(variableElement); Pref pref = new Pref(fieldName, prefName, PrefType.from(fieldType), prefDefaultValue, fieldComment); prefList.add(pref); } Map<String, Object> args = new HashMap<String, Object>(); // File name (optional - also use 'value' for this) org.jraf.android.prefs.Prefs prefsAnnot = classElement .getAnnotation(org.jraf.android.prefs.Prefs.class); String fileName = prefsAnnot.value(); if (fileName.isEmpty()) { fileName = prefsAnnot.fileName(); } if (!fileName.isEmpty()) args.put("fileName", fileName); // File mode (must only appear if fileName is defined) int fileMode = prefsAnnot.fileMode(); if (fileMode != -1) { if (fileName.isEmpty()) { // File mode set, but not file name (which makes no sense) processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "fileMode must only be set if fileName (or value) is also set", classElement); // Problem detected: halt return true; } args.put("fileMode", fileMode); } // Disable @Nullable generation args.put("disableNullable", prefsAnnot.disableNullable()); JavaFileObject javaFileObject = null; try { // SharedPreferencesWrapper javaFileObject = processingEnv.getFiler() .createSourceFile(classElement.getQualifiedName() + SUFFIX_PREF_WRAPPER); Template template = getFreemarkerConfiguration().getTemplate("prefwrapper.ftl"); args.put("package", packageElement.getQualifiedName()); args.put("comment", classComment); args.put("prefWrapperClassName", classElement.getSimpleName() + SUFFIX_PREF_WRAPPER); args.put("editorWrapperClassName", classElement.getSimpleName() + SUFFIX_EDITOR_WRAPPER); args.put("prefList", prefList); Writer writer = javaFileObject.openWriter(); template.process(args, writer); IOUtils.closeQuietly(writer); // EditorWrapper javaFileObject = processingEnv.getFiler() .createSourceFile(classElement.getQualifiedName() + "EditorWrapper"); template = getFreemarkerConfiguration().getTemplate("editorwrapper.ftl"); writer = javaFileObject.openWriter(); template.process(args, writer); IOUtils.closeQuietly(writer); } catch (Exception e) { processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "En error occurred while generating Prefs code " + e.getClass() + e.getMessage(), element); e.printStackTrace(); // Problem detected: halt return true; } } } return true; }
From source file:org.mule.devkit.module.generation.PoolAdapterGenerator.java
private void generateStartMethod(TypeElement element, DefinedClass poolAdapter, FieldVariable lifecyleEnabledObjectPool, FieldVariable muleContext, FieldVariable poolingProfile) { DefinedClass objectFactory = context .getClassForRole(context.getNameUtils().generatePojoFactoryKey(element)); Method startMethod = poolAdapter.method(Modifier.PUBLIC, context.getCodeModel().VOID, "start"); startMethod._throws(MuleException.class); Variable objectFactoryField = startMethod.body().decl(objectFactory, "objectFactory", ExpressionFactory._new(objectFactory)); java.util.List<VariableElement> variables = ElementFilter.fieldsIn(element.getEnclosedElements()); for (VariableElement variable : variables) { Configurable configurable = variable.getAnnotation(Configurable.class); if (configurable == null) continue; startMethod.body()/*w w w. j ava 2 s . c o m*/ .add(objectFactoryField .invoke("set" + StringUtils.capitalize(variable.getSimpleName().toString())) .arg(ExpressionFactory._this().ref(variable.getSimpleName().toString()))); } Invocation defaultLifecycleEnabledObjectPool = ExpressionFactory ._new(ref(DefaultLifecycleEnabledObjectPool.class)); defaultLifecycleEnabledObjectPool.arg(objectFactoryField); defaultLifecycleEnabledObjectPool.arg(poolingProfile); defaultLifecycleEnabledObjectPool.arg(muleContext); startMethod.body().assign(lifecyleEnabledObjectPool, defaultLifecycleEnabledObjectPool); startMethod.body().add(lifecyleEnabledObjectPool.invoke("initialise")); startMethod.body().add(lifecyleEnabledObjectPool.invoke("start")); }
From source file:io.github.jeddict.jcode.util.JavaSourceHelper.java
public static long[] getPosition(JavaSource source, final String methodName) { final long[] position = { 0, 0 }; try {/* ww w . ja v a2 s . co m*/ source.runUserActionTask(new AbstractTask<CompilationController>() { public void run(CompilationController controller) throws IOException { controller.toPhase(Phase.RESOLVED); TypeElement classElement = getTopLevelClassElement(controller); if (classElement == null) { return; } CompilationUnitTree tree = controller.getCompilationUnit(); Trees trees = controller.getTrees(); Tree elementTree; Element element = null; if (methodName == null) { element = classElement; } else { List<ExecutableElement> methods = ElementFilter .methodsIn(classElement.getEnclosedElements()); for (ExecutableElement method : methods) { if (method.getSimpleName().toString().equals(methodName)) { element = method; break; } } } if (element != null) { elementTree = trees.getTree(element); long pos = trees.getSourcePositions().getStartPosition(tree, elementTree); position[0] = tree.getLineMap().getLineNumber(pos) - 1; position[1] = tree.getLineMap().getColumnNumber(pos) - 1; } } }, true); } catch (IOException ex) { Exceptions.printStackTrace(ex); } return position; }
From source file:org.kie.workbench.common.forms.adf.processors.FormDefinitionsProcessor.java
protected Collection<FieldInfo> extractFieldInfos(TypeElement typeElement, VariableElementValidator validator) { Map<String, FieldInfo> allFields = new HashMap<>(); typeElement.getEnclosedElements().forEach(element -> { if (element.getKind().equals(ElementKind.FIELD)) { VariableElement fieldElement = (VariableElement) element; if (validator != null && !validator.isValid(fieldElement)) { return; }/*from w ww . j a v a 2 s .c o m*/ FieldInfo fieldInfo = getInfoFromMap(fieldElement.getSimpleName().toString(), allFields); if (fieldInfo == null) { fieldInfo = new FieldInfo(); allFields.put(fieldElement.getSimpleName().toString(), fieldInfo); } fieldInfo.fieldElement = fieldElement; } else if (element.getKind().equals(ElementKind.METHOD)) { ExecutableElement method = (ExecutableElement) element; String methodName = method.getSimpleName().toString(); if (isGetter(method)) { String fieldName = extractFieldName(methodName, 3); FieldInfo info = getInfoFromMap(fieldName, allFields); info.getter = methodName; } else if (isBooleanGetter(method)) { String fieldName = extractFieldName(methodName, 2); FieldInfo info = getInfoFromMap(fieldName, allFields); info.getter = methodName; } else if (isSetter(method)) { String fieldName = extractFieldName(methodName, 3); FieldInfo info = getInfoFromMap(fieldName, allFields); info.setter = methodName; } } }); return allFields.values().stream().filter(fieldInfo -> fieldInfo.fieldElement != null) .collect(Collectors.toCollection(() -> new ArrayList<>())); }
From source file:org.leandreck.endpoints.processor.model.EndpointNodeFactory.java
private List<MethodNode> defineMethods(final TypeElement typeElement, final DeclaredType containingType) { final TypeMirror superclass = typeElement.getSuperclass(); final List<MethodNode> superclassMethods; if (DECLARED.equals(superclass.getKind()) && !"java.lang.Object".equals(superclass.toString())) { superclassMethods = defineMethods((TypeElement) ((DeclaredType) superclass).asElement(), containingType);/* ww w .j ava 2 s . c o m*/ } else { superclassMethods = new ArrayList<>(20); } //Implemented Interfaces: typeElement.getInterfaces().stream() .flatMap( it -> defineMethods((TypeElement) ((DeclaredType) it).asElement(), containingType).stream()) .forEach(superclassMethods::add); //Own enclosed Methods ElementFilter.methodsIn(typeElement.getEnclosedElements()).stream() .map(methodElement -> methodNodeFactory.createMethodNode(methodElement, containingType)) .filter(method -> !method.isIgnored()).forEach(superclassMethods::add); return superclassMethods; }
From source file:net.minecrell.quartz.mappings.processor.MappingsGeneratorProcessor.java
@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (roundEnv.processingOver()) { return false; }/*w ww. j a v a2 s.com*/ List<TypeElement> mappingClasses = new ArrayList<>(); for (Element element : roundEnv.getElementsAnnotatedWith(Mapping.class)) { if (element instanceof TypeElement) { mappingClasses.add((TypeElement) element); } } if (mappingClasses.isEmpty()) { return true; } try { FileObject file = this.processingEnv.getFiler().getResource(StandardLocation.CLASS_OUTPUT, "", "mappings.json"); Map<String, MappedClass> mappings; try (Reader reader = file.openReader(false)) { mappings = Mappings.read(reader); } catch (IOException ignored) { mappings = new HashMap<>(); } ClassMapper classMappings = createMapper(mappingClasses); // We need to remap the descriptors of the fields and methods, use ASM for convenience Remapper unmapper = classMappings.createUnmapper(); for (TypeElement mappingClass : mappingClasses) { String internalName = getInternalName(mappingClass); Mapping annotation = mappingClass.getAnnotation(Mapping.class); String mappedName = annotation.value(); if (mappedName.isEmpty()) { mappedName = internalName; } MappedClass mapping = new MappedClass(mappedName); Accessible accessible = mappingClass.getAnnotation(Accessible.class); if (accessible != null) { mapping.getAccess().put("", parseAccessible(accessible)); } for (Element element : mappingClass.getEnclosedElements()) { accessible = element.getAnnotation(Accessible.class); Constructor constructor = element.getAnnotation(Constructor.class); if (constructor != null) { if (accessible != null) { String constructorDesc = getDescriptor((ExecutableElement) element); mapping.getAccess().put("<init>" + constructorDesc, parseAccessible(accessible)); } continue; } annotation = element.getAnnotation(Mapping.class); if (annotation == null) { continue; } mappedName = annotation.value(); checkArgument(!mappedName.isEmpty(), "Mapping detection is not supported yet"); switch (element.getKind()) { case METHOD: ExecutableElement method = (ExecutableElement) element; String methodName = method.getSimpleName().toString(); String methodDesc = getDescriptor(method); mapping.getMethods().put(mappedName + unmapper.mapMethodDesc(methodDesc), methodName); if (accessible != null) { mapping.getAccess().put(methodName + methodDesc, parseAccessible(accessible)); } break; case FIELD: case ENUM_CONSTANT: VariableElement field = (VariableElement) element; String fieldName = field.getSimpleName().toString(); mapping.getFields().put(mappedName + ':' + unmapper.mapDesc(getDescriptor(field)), fieldName); if (accessible != null) { mapping.getAccess().put(fieldName, parseAccessible(accessible)); } break; default: } } mappings.put(internalName, mapping); } // Generate JSON output file = this.processingEnv.getFiler().createResource(StandardLocation.CLASS_OUTPUT, "", "mappings.json"); try (Writer writer = file.openWriter()) { Mappings.write(writer, mappings); } return true; } catch (IOException e) { this.processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, ExceptionUtils.getStackTrace(e)); throw new RuntimeException("Failed to create mappings.json", e); } }
From source file:org.mule.devkit.module.generation.BeanDefinitionParserGenerator.java
private Variable generateParseTransferObject(TypeMirror transferObjectType, Block block, Variable element, Variable parserContext) {//from w ww .jav a2 s .co m DeclaredType declaredType = (DeclaredType) transferObjectType; String baseName = declaredType.asElement().getSimpleName().toString().toLowerCase(); Variable builder = block.decl(ref(BeanDefinitionBuilder.class), baseName + "BeanDefinitionBuilder", ref(BeanDefinitionBuilder.class).staticInvoke("rootBeanDefinition") .arg(ref(transferObjectType).boxify().dotclass())); TypeElement typeElement = (TypeElement) declaredType.asElement(); java.util.List<VariableElement> variables = ElementFilter.fieldsIn(typeElement.getEnclosedElements()); for (VariableElement variable : variables) { String fieldName = variable.getSimpleName().toString(); if (SchemaTypeConversion.isSupported(variable.asType().toString())) { generateParseSupportedType(block, element, builder, fieldName); } else if (variable.asType().toString().contains(ProcessorCallback.class.getName())) { generateParseProcessorCallback(block, element, parserContext, builder, fieldName); } else if (context.getTypeMirrorUtils().isXmlType(variable.asType())) { generateParseXmlType(block, element, builder, fieldName); } else if (context.getTypeMirrorUtils().isArrayOrList(variable.asType())) { Variable listElement = block.decl(ref(org.w3c.dom.Element.class), fieldName + "ListElement", ExpressionFactory._null()); block.assign(listElement, ref(DomUtils.class).staticInvoke("getChildElementByTagName").arg(element) .arg(context.getNameUtils().uncamel(fieldName))); UpperBlockClosure managedList = generateParseArrayOrList(block, variable.asType(), listElement, builder, fieldName, parserContext); managedList.getNotRefBlock().add( builder.invoke("addPropertyValue").arg(fieldName).arg(managedList.getManagedCollection())); } else if (context.getTypeMirrorUtils().isMap(variable.asType())) { Variable listElement = block.decl(ref(org.w3c.dom.Element.class), fieldName + "ListElement", ExpressionFactory._null()); block.assign(listElement, ref(DomUtils.class).staticInvoke("getChildElementByTagName").arg(element) .arg(context.getNameUtils().uncamel(fieldName))); UpperBlockClosure managedMap = generateParseMap(block, variable.asType(), listElement, builder, fieldName, parserContext); managedMap.getNotRefBlock().add( builder.invoke("addPropertyValue").arg(fieldName).arg(managedMap.getManagedCollection())); } else if (context.getTypeMirrorUtils().isEnum(variable.asType())) { generateParseEnum(block, element, builder, fieldName); } } return builder; }
From source file:com.thoratou.exact.processors.ExactProcessor.java
private void readAnnotations(RoundEnvironment roundEnv, HashMap<String, ArrayList<Item>> itemMap, HashMap<String, ArrayList<ExtensionItem>> extItemMap) throws Exception { //retrieve all classes with @ExactNode annotation for (TypeElement typeElement : ElementFilter.typesIn(roundEnv.getElementsAnnotatedWith(ExactNode.class))) { Name qualifiedName = typeElement.getQualifiedName(); String className = qualifiedName.toString(); logger.info("Exact class : " + className); classMap.put(className, typeElement); for (ExecutableElement methodElement : ElementFilter.methodsIn(typeElement.getEnclosedElements())) { {/*from w w w .j a v a 2 s.c om*/ ExactPath annotation = methodElement.getAnnotation(ExactPath.class); if (annotation != null) { String methodName = methodElement.getSimpleName().toString(); String returnType = methodElement.getReturnType().toString(); String xPathString = annotation.value(); logger.info( "Exact method : " + methodName + " , " + annotation.value() + " , " + returnType); XPathParser parser = new XPathParser(xPathString); XPathPathExpr xPathPathExpr = parser.parse(); logger.info("XPath value = " + xPathPathExpr.toString()); Item item = new Item(); item.setxPathPathExpr(xPathPathExpr); item.setMethodName(methodName); item.setReturnType(returnType); if (itemMap.containsKey(className)) { ArrayList<Item> items = itemMap.get(className); items.add(item); } else { ArrayList<Item> items = new ArrayList<Item>(); items.add(item); itemMap.put(className, items); } methodMap.put(new Pair<String, String>(className, methodName), methodElement); } } { ExactExtension annotation = methodElement.getAnnotation(ExactExtension.class); if (annotation != null) { String methodName = methodElement.getSimpleName().toString(); String returnType = methodElement.getReturnType().toString(); String name = annotation.name(); String element = annotation.element(); String filter = annotation.filter(); logger.info("Exact extension : " + methodName + " , " + returnType + " , " + name + " , " + element + " , " + filter); XPathParser elementParser = new XPathParser(element); XPathPathExpr elementXPathPathExpr = elementParser.parse(); logger.info("XPath element = " + elementXPathPathExpr.toString()); XPathParser filterParser = new XPathParser(filter); XPathPathExpr filterXPathPathExpr = filterParser.parse(); logger.info("XPath filter = " + filterXPathPathExpr.toString()); ExtensionItem item = new ExtensionItem(); item.setName(name); item.setElement(elementXPathPathExpr); item.setFilter(filterXPathPathExpr); item.setMethodName(methodName); item.setReturnType(returnType); if (extItemMap.containsKey(className)) { ArrayList<ExtensionItem> items = extItemMap.get(className); items.add(item); } else { ArrayList<ExtensionItem> items = new ArrayList<ExtensionItem>(); items.add(item); extItemMap.put(className, items); } } } } } }