下面列出了javax.lang.model.element.Element#getEnclosedElements ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Checks if an public empty constructor is available
*/
private boolean hasPublicEmptyConstructor(DeclaredType type) {
Element element = type.asElement();
List<? extends Element> containing = element.getEnclosedElements();
for (Element e : containing) {
if (e.getKind() == ElementKind.CONSTRUCTOR) {
ExecutableElement c = (ExecutableElement) e;
if ((c.getParameters() == null || c.getParameters().isEmpty()) && c.getModifiers()
.contains(javax.lang.model.element.Modifier.PUBLIC)) {
return true;
}
}
}
return false;
}
private List<Method> getMethods(Element classElement) {
List<? extends Element> enclosedElements = classElement.getEnclosedElements();
List<Method> methods = new ArrayList<>();
for (Element methodElement : enclosedElements) {
if (methodElement.getKind() != ElementKind.METHOD) continue;
Symbol.MethodSymbol methodSymbol = (Symbol.MethodSymbol) methodElement;
if (skipTest(methodSymbol)) continue;
String name = methodSymbol.getSimpleName().toString();
TypeName returnType = TypeName.get(methodSymbol.getReturnType());
List<Param> params = getParams(methodSymbol);
Mockery mockery = getAnnotation(methodSymbol, Mockery.class);
methods.add(new Method(name, methodElement,
returnType, params, mockery != null));
}
return methods;
}
private void bindingMembersCheck( WebBeansModel model ) {
TypeMirror mirror = model.resolveType("foo.TestClass1");
Element clazz = ((DeclaredType) mirror).asElement();
List<? extends Element> children = clazz.getEnclosedElements();
List<ExecutableElement> methods = ElementFilter.methodsIn( children );
assertEquals(2, methods.size());
for (ExecutableElement method : methods) {
Name simpleName = method.getSimpleName();
List<VariableElement> eventInjectionPoints = model.
getEventInjectionPoints( method, (DeclaredType) mirror);
assertEquals("Observer "+simpleName+" matches "+eventInjectionPoints.size()
+" events. But should match exactly one", 1, eventInjectionPoints.size());
VariableElement variableElement = eventInjectionPoints.get(0);
TypeElement containingType = model.getCompilationController().
getElementUtilities().enclosingTypeElement( variableElement);
Name varName = variableElement.getSimpleName();
assertEquals("Event injection point should be inside class foo.Clazz," +
"but found inside "+ containingType.getQualifiedName(),
"foo.Clazz", containingType.getQualifiedName().toString());
assertEquals("Observer method "+simpleName+" should match to" +
" event field 'event', but found :"+varName, "event", varName.toString());
}
}
private boolean isSubcommand(ExecutableElement method, RoundEnvironment roundEnv) {
Element typeElement = method.getEnclosingElement();
if (typeElement.getAnnotation(Command.class) != null && typeElement.getAnnotation(Command.class).addMethodSubcommands()) {
return true;
}
if (typeElement.getAnnotation(Command.class) == null) {
Set<Element> elements = new HashSet<Element>(typeElement.getEnclosedElements());
// The class is a Command if it has any fields or methods annotated with the below:
return roundEnv.getElementsAnnotatedWith(Option.class).removeAll(elements)
|| roundEnv.getElementsAnnotatedWith(Parameters.class).removeAll(elements)
|| roundEnv.getElementsAnnotatedWith(Mixin.class).removeAll(elements)
|| roundEnv.getElementsAnnotatedWith(ArgGroup.class).removeAll(elements)
|| roundEnv.getElementsAnnotatedWith(Unmatched.class).removeAll(elements)
|| roundEnv.getElementsAnnotatedWith(Spec.class).removeAll(elements);
}
return false;
}
private void buildAllColumns(Element element) {
if (null == element) {
return;
}
List<? extends Element> eles = element.getEnclosedElements();
for (Element e : eles) {
if (ElementKind.FIELD == e.getKind()) {
if (e.getModifiers().contains(Modifier.PRIVATE)) {
throw new RuntimeException(e.getSimpleName().toString() + " in " + element.asType().toString() + " CAN NOT be private!");
}
Column column = e.getAnnotation(Column.class);
if (null != column) {
mColumnList.add(new ColumnEntry(e, element));
}
}
}
}
private ImmutableList<DocFlag> generateFlagsInfo(Element classElement) throws ElementException {
ImmutableList.Builder<DocFlag> result = ImmutableList.builder();
AnnotationHelper<UsesFlags> annotation = annotationHelper(classElement, UsesFlags.class);
if (annotation == null) {
return result.build();
}
for (DeclaredType flag : annotation.getClassListValue("value")) {
Element flagClass = flag.asElement();
for (Element member : flagClass.getEnclosedElements()) {
Parameter flagAnnotation = member.getAnnotation(Parameter.class);
if (flagAnnotation == null
|| !(member instanceof VariableElement)
|| flagAnnotation.hidden()) {
continue;
}
result.add(new DocFlag(Joiner.on(", ").join(flagAnnotation.names()),
simplerJavaTypes(member.asType()), flagAnnotation.description()));
}
}
return result.build();
}
private static String findSetterMethod(Element classElement,
VariableElement fieldElement,
AutoBundleField fieldAnnotation) {
final String operation = "set";
final String argKeyName = fieldAnnotation.key().length() > 0
? fieldAnnotation.key() : fieldElement.toString();
for (Element element : classElement.getEnclosedElements()) {
final String methodName = element.getSimpleName().toString();
AutoBundleSetter annotation = element.getAnnotation(AutoBundleSetter.class);
if (annotation != null) {
// annotated setter
if (argKeyName.equals(annotation.key())) {
// check modifier
if (element.getModifiers().contains(Modifier.PRIVATE)) {
throw new ProcessingException("@AutoBundleSetter must not be private");
}
return methodName;
}
} else {
// default setter
if (ElementKind.METHOD == element.getKind() &&
!element.getModifiers().contains(Modifier.PRIVATE) &&
element.getSimpleName().toString().startsWith(operation)) {
if (methodName.equals(
createOperationMethod(operation, argKeyName))) {
int methodModifierLevel = ModifierHelper.getModifierLevel(element);
int fieldModifierLevel = ModifierHelper.getModifierLevel(fieldElement);
if (methodModifierLevel - fieldModifierLevel >= 0) {
return methodName;
}
}
}
}
}
return null;
}
@Override
public boolean process(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv) {
final Trees trees = Trees.instance(this.processingEnv);
for (Element element : ElementFilter.typesIn(roundEnv.getRootElements())) {
checkTreePath(trees, element, 2);
for (Element member : element.getEnclosedElements())
checkTreePath(trees, member, 3);
}
return true;
}
@Override
public boolean process(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv) {
final Trees trees = Trees.instance(this.processingEnv);
for (Element element : ElementFilter.typesIn(roundEnv.getRootElements())) {
checkTreePath(trees, element, 2);
for (Element member : element.getEnclosedElements())
checkTreePath(trees, member, 3);
}
return true;
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
for (Element element : roundEnv.getRootElements()) {
String packageStr = element.getEnclosingElement().toString();
String classStr = element.getSimpleName().toString();
ClassName className = ClassName.get(packageStr, classStr + "$Binding");
MethodSpec.Builder constructorBuilder = MethodSpec.constructorBuilder()
.addModifiers(Modifier.PUBLIC)
.addParameter(ClassName.get(packageStr, classStr), "activity");
boolean hasBinding = false;
for (Element enclosedElement : element.getEnclosedElements()) {
BindView bindView = enclosedElement.getAnnotation(BindView.class);
if (bindView != null) {
hasBinding = true;
constructorBuilder.addStatement("activity.$N = activity.findViewById($L)",
enclosedElement.getSimpleName(), bindView.value());
}
}
TypeSpec builtClass = TypeSpec.classBuilder(className)
.addModifiers(Modifier.PUBLIC)
.addMethod(constructorBuilder.build())
.build();
if (hasBinding) {
try {
JavaFile.builder(packageStr, builtClass)
.build().writeTo(filer);
} catch (IOException e) {
e.printStackTrace();
}
}
}
return false;
}
private static ExecutableElement findAttribute(Element e, String attrName) {
for (Element attr : e.getEnclosedElements()) {
if (attr.getKind() == ElementKind.METHOD && attr.getSimpleName().contentEquals(attrName)) {
return (ExecutableElement)attr;
}
}
return null;
}
private static void searchSubTree(
Element e,
Set<Element> found,
Class<? extends Annotation> type
) {
if (e.getAnnotation(type) != null) {
found.add(e);
}
for (Element ee : e.getEnclosedElements()) {
searchSubTree(ee, found, type);
}
}
@Override
public boolean process(Set<? extends TypeElement> annotations,
RoundEnvironment roundEnv) {
final Trees trees = Trees.instance(this.processingEnv);
for (Element element : ElementFilter.typesIn(roundEnv.getRootElements())) {
checkTreePath(trees, element, 2);
for (Element member : element.getEnclosedElements())
checkTreePath(trees, member, 3);
}
return true;
}
private List<Element> getItems0(Element te, boolean filter, Set<ElementKind> kinds) {
List<Element> elements = new ArrayList<>();
for (Element e : te.getEnclosedElements()) {
if (kinds.contains(e.getKind())) {
if (!filter || shouldDocument(e)) {
elements.add(e);
}
}
}
return elements;
}
@Override
public Boolean visitSwitch(SwitchTree node, Void p) {
boolean lastCaseExit = false;
boolean defaultSeen = false;
Set<Element> enumValues = null;
if (node.getExpression() != null) {
TypeMirror exprType = info.getTrees().getTypeMirror(new TreePath(getCurrentPath(), node.getExpression()));
if (isValidType(exprType) && exprType.getKind() == TypeKind.DECLARED) {
Element el = ((DeclaredType)exprType).asElement();
enumValues = new HashSet<>();
for (Element f : el.getEnclosedElements()) {
if (f.getKind() == ElementKind.ENUM_CONSTANT) {
enumValues.add(f);
}
}
}
}
for (CaseTree ct : node.getCases()) {
Boolean res = scan(ct, null);
if (res == Boolean.FALSE) {
return res;
}
lastCaseExit = res == Boolean.TRUE;
if (ct.getExpression() == null) {
defaultSeen = true;
} else if (enumValues != null ) {
TreePath casePath = new TreePath(getCurrentPath(), ct);
Element v = info.getTrees().getElement(new TreePath(
casePath, ct.getExpression()));
if (v != null) {
enumValues.remove(v);
}
}
}
if (enumValues != null && enumValues.isEmpty()) {
defaultSeen = true;
}
return lastCaseExit == Boolean.TRUE && defaultSeen;
}
void addPublicTypes(List<TypeElement> list, Element e) {
ElementKind kind = e.getKind();
if ((kind.isClass() || kind.isInterface())
&& e.getModifiers().contains(Modifier.PUBLIC)) {
list.add((TypeElement)e);
for (Element enc : e.getEnclosedElements()) {
addPublicTypes(list, enc);
}
}
}
private void processEvents(ComponentInfo componentInfo,
Element componentElement) {
for (Element element : componentElement.getEnclosedElements()) {
if (!isPublicMethod(element)) {
continue;
}
// Get the name of the prospective event.
String eventName = element.getSimpleName().toString();
processConditionalAnnotations(componentInfo, element, eventName);
SimpleEvent simpleEventAnnotation = element.getAnnotation(SimpleEvent.class);
// Remove overriden events unless SimpleEvent is again specified.
// See comment in processProperties for an example.
if (simpleEventAnnotation == null) {
if (componentInfo.events.containsKey(eventName)) {
componentInfo.events.remove(eventName);
}
} else {
String eventDescription = simpleEventAnnotation.description();
String longEventDescription = elementUtils.getDocComment(element);
if (eventDescription.isEmpty()) {
eventDescription = longEventDescription;
if (eventDescription == null) {
messager.printMessage(Diagnostic.Kind.WARNING,
"In component " + componentInfo.name +
", event " + eventName +
" is missing a description.");
eventDescription = "";
}
}
boolean userVisible = simpleEventAnnotation.userVisible();
boolean deprecated = elementUtils.isDeprecated(element);
Event event = new Event(eventName, eventDescription, longEventDescription, userVisible, deprecated);
componentInfo.events.put(event.name, event);
// Verify that this element has an ExecutableType.
if (!(element instanceof ExecutableElement)) {
throw new RuntimeException("In component " + componentInfo.name +
", the representation of SimpleEvent " + eventName +
" does not implement ExecutableElement.");
}
ExecutableElement e = (ExecutableElement) element;
// Extract the parameters.
for (VariableElement ve : e.getParameters()) {
event.addParameter(ve.getSimpleName().toString(),
ve.asType().toString(),
ve.getAnnotation(IsColor.class) != null);
updateComponentTypes(ve.asType());
}
}
}
}
private void parseRouteNodes(Set<? extends Element> routeElements) {
TypeMirror type_Activity = elements.getTypeElement(ACTIVITY).asType();
for (Element element : routeElements) {
TypeMirror tm = element.asType();
RouteNode route = element.getAnnotation(RouteNode.class);
if (types.isSubtype(tm, type_Activity)) { // Activity
logger.info(">>> Found activity route: " + tm.toString() + " <<<");
Node node = new Node();
String path = route.path();
checkPath(path);
node.setPath(path);
node.setDesc(route.desc());
node.setPriority(route.priority());
node.setNodeType(NodeType.ACTIVITY);
node.setRawType(element);
Map<String, Integer> paramsType = new HashMap<>();
Map<String, String> paramsDesc = new HashMap<>();
for (Element field : element.getEnclosedElements()) {
if (field.getKind().isField() && field.getAnnotation(Autowired.class) != null) {
Autowired paramConfig = field.getAnnotation(Autowired.class);
paramsType.put(StringUtils.isEmpty(paramConfig.name())
? field.getSimpleName().toString() : paramConfig.name(), typeUtils.typeExchange(field));
paramsDesc.put(StringUtils.isEmpty(paramConfig.name())
? field.getSimpleName().toString() : paramConfig.name(), typeUtils.typeDesc(field));
}
}
node.setParamsType(paramsType);
node.setParamsDesc(paramsDesc);
if (!routerNodes.contains(node)) {
routerNodes.add(node);
}
} else {
throw new IllegalStateException("only activity can be annotated by RouteNode");
}
}
}
/**
* Creates a Statement Factory class
* @param className object holding an entity class
* @throws Exception exception generated while creating source
*/
private void writeStatementFactory(String className, String tableName) throws Exception {
Map<String, Object> input = inputStart(className);
Map<String,String> keyFields = new HashMap<>();
Map<String,String> nonKeyFields = new HashMap<>();
Map<String,String> udtFields = new HashMap<>();
List<String> imports = new ArrayList<>();
for (Element element : roundEnv.getRootElements()) {
if (element.getSimpleName().toString().equals(CasquatchNamingConvention.classToSimpleClass(className))) {
for (Element enclosedElement : element.getEnclosedElements()) {
if (enclosedElement.getKind().equals(ElementKind.FIELD)) {
if(
enclosedElement.getAnnotation(com.fasterxml.jackson.annotation.JsonIgnore.class)==null &&
enclosedElement.getAnnotation(com.tmobile.opensource.casquatch.annotation.CasquatchIgnore.class)==null
) {
String type = "";
if(enclosedElement.asType().getKind()== TypeKind.DECLARED) {
type=processingEnv.getTypeUtils().erasure(enclosedElement.asType()).toString();
for(TypeMirror typeMirror : ((DeclaredType)enclosedElement.asType()).getTypeArguments()) {
if (!imports.contains(typeMirror.toString())) imports.add(typeMirror.toString());
}
}
else {
type=enclosedElement.asType().toString();
}
if (!imports.contains(type)) imports.add(type);
if(enclosedElement.getAnnotation(com.tmobile.opensource.casquatch.annotation.PartitionKey.class)!=null) {
keyFields.put(enclosedElement.getSimpleName().toString(),type);
}
else if(enclosedElement.getAnnotation(com.tmobile.opensource.casquatch.annotation.ClusteringColumn.class)!=null) {
keyFields.put(enclosedElement.getSimpleName().toString(),type);
}
else if(enclosedElement.getAnnotation(com.tmobile.opensource.casquatch.annotation.UDT.class)!=null) {
udtFields.put(enclosedElement.getSimpleName().toString(),type);
if (!imports.contains("com.datastax.oss.driver.api.core.data.UdtValue")) imports.add("com.datastax.oss.driver.api.core.data.UdtValue");
}
else {
nonKeyFields.put(enclosedElement.getSimpleName().toString(),type);
}
}
}
}
}
}
if(!tableName.isEmpty()) {
input.put("table",tableName);
}
else {
input.put("table", CasquatchNamingConvention.javaVariableToCql(CasquatchNamingConvention.classToVar(CasquatchNamingConvention.classToSimpleClass(className))));
}
input.put("imports",imports);
input.put("keyFields", keyFields);
input.put("udtFields", udtFields);
input.put("nonKeyFields", nonKeyFields);
createSource(CasquatchNamingConvention.classToStatementFactory(className),"StatementFactory.ftl",input);
}
/**
* Generate YourModel$$Repository class
* @param element
* @throws IOException
*/
private void generateRepositoryClass(Element element) throws IOException {
String packageName = elements.getPackageOf(element).getQualifiedName().toString();
ClassName entityClass = ClassName.get(packageName, element.getSimpleName().toString());
ClassName stringClass = ClassName.get(String.class);
ClassName contextClass = ClassName.get(Context.class);
ClassName utilClass = ClassName.get(PreferencesUtil.class);
Pref prefAnnotation = element.getAnnotation(Pref.class);
String tableName = prefAnnotation.name();
MethodSpec constructorSpec = MethodSpec.constructorBuilder()
.addModifiers(Modifier.PRIVATE)
.build();
MethodSpec getNameSpec = MethodSpec.methodBuilder("getName")
.addModifiers(Modifier.PRIVATE, Modifier.FINAL, Modifier.STATIC)
.returns(stringClass)
.addStatement("return $S", tableName)
.build();
MethodSpec.Builder getEntitySpecBuilder = MethodSpec.methodBuilder("getEntity")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC)
.addParameter(contextClass, "context")
.returns(entityClass)
.addStatement("$T entity = new $T()", entityClass, entityClass);
MethodSpec.Builder putEntitySpecBuilder = MethodSpec.methodBuilder("putEntity")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC)
.addParameter(contextClass, "context")
.addParameter(entityClass, "entity");
MethodSpec.Builder clearSpecBuilder = MethodSpec.methodBuilder("clear")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC)
.addParameter(contextClass, "context")
.addStatement("$T.clear(context, getName())",
utilClass);
for (Element element1 : element.getEnclosedElements()) {
if (element1.getAnnotation(PrefField.class) != null) {
handlePrefField(element1, getEntitySpecBuilder, putEntitySpecBuilder);
}
}
getEntitySpecBuilder.addStatement("return entity");
String className = element.getSimpleName() + "SpotRepository";
TypeSpec repository = TypeSpec.classBuilder(className)
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(constructorSpec)
.addMethod(getNameSpec)
.addMethod(getEntitySpecBuilder.build())
.addMethod(putEntitySpecBuilder.build())
.addMethod(clearSpecBuilder.build())
.build();
JavaFile.builder(packageName, repository)
.build()
.writeTo(filer);
}