Java TypeDeclaration.getMembers方法代码示例

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private static void addResourceType(List<String> supportedTypes, TypeSpec.Builder result,
    TypeDeclaration node) {
  if (!supportedTypes.contains(node.getName())) {
    return;
  }

  String type = node.getName();
  TypeSpec.Builder resourceType = TypeSpec.classBuilder(type).addModifiers(PUBLIC, STATIC, FINAL);

  for (BodyDeclaration field : node.getMembers()) {
    if (field instanceof FieldDeclaration) {
      addResourceField(resourceType, ((FieldDeclaration) field).getVariables().get(0),
          getSupportAnnotationClass(type));
    }
  }

  result.addType(resourceType.build());
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private void extractInformation(String filename) throws ClassParserException {
	List<TypeDeclaration> types = cu.getTypes();
	for (TypeDeclaration type : types) {
		if (type instanceof ClassOrInterfaceDeclaration) {
			clazz = (ClassOrInterfaceDeclaration) type;
		}
		List<BodyDeclaration> members = type.getMembers();
		for (BodyDeclaration member : members) {
			if (member instanceof FieldDeclaration) {
				fields.add((FieldDeclaration) member);
			}
			else if (member instanceof ConstructorDeclaration) {
				constructors.add((ConstructorDeclaration) member);
			}
			else if (member instanceof MethodDeclaration) {
				methods.add((MethodDeclaration) member);
			}
		}
	}
	if (clazz == null) {
		throw new ClassParserException("No toplevel type declaration found in " + filename + ".");
	}
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
public static MethodDeclaration getMethodByPositionAndClassPosition(CompilationUnit compilationUnit,
                                                                     int methodPosition, int classPosition) {
    TypeDeclaration type = compilationUnit.getTypes().get(classPosition -1);

    int memberCount = 0;
    int methodCount = 0;
    for(BodyDeclaration bodyDeclaration : type.getMembers()) {
        if(bodyDeclaration instanceof MethodDeclaration){
            if(methodCount == methodPosition -1) {
                return (MethodDeclaration) type.getMembers().get(memberCount);
            }
            methodCount++;
        }
        memberCount++;
    }
    throw new IllegalArgumentException("Method not found at position " +methodPosition+ "in class " + classPosition);
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private static void changeMethods(CompilationUnit cu) {
    List<TypeDeclaration> types = cu.getTypes();
    for (TypeDeclaration type : types) {
        List<BodyDeclaration> members = type.getMembers();
        for (BodyDeclaration member : members) {
            if (member instanceof MethodDeclaration) {
                MethodDeclaration method = (MethodDeclaration) member;
                changeMethod(method);
            }
        }
    }
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
public static BodyDeclaration getMemberByTypeAndPosition(TypeDeclaration typeDeclaration, int position,
                                                   Class<? extends BodyDeclaration> typeClass){
    int typeCount = 0;
    for(BodyDeclaration declaration : typeDeclaration.getMembers()){
        if(declaration.getClass().equals(typeClass)){
            if(typeCount == position){
                return declaration;
            }
            typeCount++;
        }
    }
    throw new IllegalArgumentException("No member " + typeClass + " at position: " + position );
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
@Override
protected UnitCache<EmulTypeElement> doCompile(TypeDeclaration unit) {
    String unitName = unit.getName();

    String qualifiedName = TypeUtil.determineQualifiedName(
        getCompileUnit(), unit.getNameExpr());

    TypeMirror type = new EmulType(new StringName(qualifiedName), TypeKind.DECLARED);
    Name name = new StringName(unitName);

    ElementKind kind = ElementKind.OTHER;
    List<Element> members = new ArrayList<>();
    Set<Modifier> modifierSet = ModifierUtil.asSet(unit.getModifiers());

    if(unit instanceof AnnotationDeclaration) {
        kind = ElementKind.ANNOTATION_TYPE;
    } else if(unit instanceof EnumDeclaration) {
        kind = ElementKind.ENUM;
    } else if(unit instanceof ClassOrInterfaceDeclaration) {
        if(((ClassOrInterfaceDeclaration) unit).isInterface()) {
            kind = ElementKind.INTERFACE;
        } else {
            kind = ElementKind.CLASS;
        }
    }

    EmulTypeElement element = new EmulTypeElement(type, kind, parent, members,
        modifierSet, name, name, NestingKind.TOP_LEVEL);

    // Children
    NodeToElementCompiler compiler = new NodeToElementCompiler(getCompileUnit(), element);
    for(BodyDeclaration member : unit.getMembers()) {
        Element childElem = compiler.compile(member);
        if(childElem != null) {
            members.add(childElem);
        }
    }

    return new UnitCache<>(element);
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private EnumDeclaration findModel(TypeDeclaration mainType) {
	for(BodyDeclaration member:mainType.getMembers()){
		if(member instanceof EnumDeclaration){
			EnumDeclaration mem=(EnumDeclaration)member;
			if(mem.getName().equals("Field")){
				return (EnumDeclaration) member;
			}
		}
	}
	return null;
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
/**
 *
 * @param td
 *      the parsed enum
 * @return
 *      an enum structure
 */
private EnumDecl parseEnum(TypeDeclaration td) {
    // enum
    EnumDeclaration enumeration = (EnumDeclaration) td;
    EnumDecl enumDecl = new EnumDecl();
    ClassRef superClass = new ClassRef();

    if (td.getComment()!= null) {
        List<String> javadoc = ParserUtils.prepareComments(td.getComment().getContent());
        enumDecl.setDoc(javadoc);
    }
    enumDecl.setName(td.getName());
    enumDecl.setVisibility(visibility(td.getModifiers()));
    if (enumeration.getEntries() != null) {
        List<Ident> entries = new ArrayList<>();
        for (Ident entry : entries) {
            Ident ident = new Ident(entry.getName());
            entries.add(ident);
            this.loc++;
        }
        enumDecl.setEnumConstants(entries);
    }
    List<InterfaceRef> implems = new ArrayList<>();
    if (enumeration.getImplements() != null) {
        for (ClassOrInterfaceType obj : enumeration.getImplements()) {
            InterfaceRef implInterface = new InterfaceRef(null, obj.toString());
            implems.add(implInterface);
        }
    }
    enumDecl.setImplementedInterfaces(implems);
    List<Attribute> attributes = new ArrayList<>();
    List<ConstructorDecl> constructors = new ArrayList<>();
    List<Method> methods = new ArrayList<>();

    if (td.getMembers() != null) {
        for (BodyDeclaration bodyElmt : td.getMembers()) {
            if (bodyElmt instanceof FieldDeclaration) { // attribute
                FieldDeclaration fd = (FieldDeclaration) bodyElmt;
                attributes.addAll(parseAttribute(fd));
                this.loc++;
            } else if (bodyElmt instanceof ConstructorDeclaration) { // constructor
                ConstructorDeclaration cd = (ConstructorDeclaration) bodyElmt;
                constructors.add(parseConstructor(cd, attributes, superClass.getClassName()));
                this.loc++;
            } else if (bodyElmt instanceof MethodDeclaration) { // method
                MethodDeclaration md = (MethodDeclaration) bodyElmt;
                methods.add(parseMethod(md, attributes));
                this.loc++;
            } else if (bodyElmt instanceof ClassOrInterfaceDeclaration) {
                this.classes.add(parseClass((TypeDeclaration) bodyElmt));
                this.loc++;
            }
        }
    }
    enumDecl.setAttributes(attributes);
    enumDecl.setConstructors(constructors);
    enumDecl.setMethods(methods);

    return enumDecl;
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
/**
 * Adds the given declaration to the specified type. The list of members
 * will be initialized if it is <code>null</code>.
 * 
 * @param type
 *            type declaration
 * @param decl
 *            member declaration
 */
public static void addMember(TypeDeclaration type, BodyDeclaration decl) {
    List<BodyDeclaration> members = type.getMembers();
    if (isNullOrEmpty(members)) {
        members = new ArrayList<BodyDeclaration>();
        type.setMembers(members);
    }
    members.add(decl);
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
/**
 * Adds the given declaration to the specified type. The list of members
 * will be initialized if it is <code>null</code>.
 * 
 * @param type
 *            type declaration
 * @param decl
 *            member declaration
 */
public static void addMember(TypeDeclaration type, BodyDeclaration decl) {
    List<BodyDeclaration> members = type.getMembers();
    if (members == null) {
        members = new ArrayList<BodyDeclaration>();
        type.setMembers(members);
    }
    members.add(decl);
}
 

import com.github.javaparser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
/**
 * Adds the given declaration to the specified type. The list of members
 * will be initialized if it is <code>null</code>.
 *
 * @param type
 *            type declaration
 * @param decl
 *            member declaration
 */
public static void addMember(TypeDeclaration type, BodyDeclaration decl) {
    List<BodyDeclaration> members = type.getMembers();
    if (isNullOrEmpty(members)) {
        members = new ArrayList<BodyDeclaration>();
        type.setMembers(members);
    }
    members.add(decl);
}