Java TypeDeclaration.getMembers方法代码示例

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private void getJavaMethods (ArrayList<JavaMethod> methods, TypeDeclaration type) {
	classStack.push(type);
	if (type.getMembers() != null) {
		for (BodyDeclaration member : type.getMembers()) {
			if (member instanceof ClassOrInterfaceDeclaration || member instanceof EnumDeclaration) {
				getJavaMethods(methods, (TypeDeclaration)member);
			} else {
				if (member instanceof MethodDeclaration) {
					MethodDeclaration method = (MethodDeclaration)member;
					if (!ModifierSet.hasModifier(((MethodDeclaration)member).getModifiers(), ModifierSet.NATIVE)) continue;
					methods.add(createMethod(method));
				}
			}
		}
	}
	classStack.pop();
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
public static FieldDeclaration getDeclaration(CompilationUnit unit, Field field) {
	TypeDeclaration typeDecl = getDeclaration(unit, field.getDeclaringClass());
	if (typeDecl == null) {
		return null;
	}
	for (BodyDeclaration decl : typeDecl.getMembers()) {
		if (decl instanceof FieldDeclaration) {
			FieldDeclaration fieldDecl = (FieldDeclaration) decl;
			List<VariableDeclarator> variables = fieldDecl.getVariables();
			if (variables.size() != 1) {
				continue;
			}
			if (field.getName().equals(variables.get(0).getId().getName())) {
				return fieldDecl;
			}
		}
	}
	return null;
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
public static Node getNode(TypeDeclaration typeDecl, String name) {
	if (typeDecl.getMembers() == null) {
		return null;
	}
	for (BodyDeclaration bodyDecl : typeDecl.getMembers()) {
		String bodyDeclName = getName(bodyDecl);
		if (bodyDeclName != null && name.startsWith(bodyDeclName)) {
			if (name.length() == bodyDeclName.length()) {
				return bodyDecl;
			}
			else if (bodyDecl instanceof MethodDeclaration || bodyDecl instanceof ConstructorDeclaration) {
				if (signatureMatches(bodyDecl, name.substring(bodyDeclName.length()))) {
					return bodyDecl;
				}
			}
			else if (bodyDecl instanceof TypeDeclaration) {
				return getNode((TypeDeclaration) bodyDecl, name.substring(bodyDeclName.length() + 1));
			}
		}
	}
	return null;
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private static MethodDeclaration find( TypeDeclaration decl , MethodDeclaration analogous )
{
	for( BodyDeclaration bodyDecl : decl.getMembers( ) )
	{
		if( bodyDecl instanceof MethodDeclaration )
		{
			MethodDeclaration methodDecl = ( MethodDeclaration ) bodyDecl;
			if( methodDecl.getName( ).equals( analogous.getName( ) )
					&& methodDecl.getModifiers( ) == analogous.getModifiers( )
					&& sameTypes( methodDecl.getParameters( ) , analogous.getParameters( ) ) )
			{
				return methodDecl;
			}
		}
	}
	return null;
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private void feedTestClass(TypeDeclaration type, UseCase useCase) throws IOException {
    if (type.getComment() != null) {
        useCase.setComment(type.getComment().getContent());
    }
    int scenarioIndex = 0;
    for (BodyDeclaration bodyDeclaration : type.getMembers()) {
        if (bodyDeclaration instanceof MethodDeclaration) {
            MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration;
            if (containsAnnotation(methodDeclaration, "Test")) {
                feedAndOrderScenario(scenarioIndex, methodDeclaration, useCase);
                scenarioIndex++;
            } else if (containsAnnotation(methodDeclaration, "BeforeClass")) {
                feedTestContext(methodDeclaration, useCase.beforeUseCase,useCase);
            } else if (containsAnnotation(methodDeclaration, "AfterClass")) {
                feedTestContext(methodDeclaration, useCase.afterUseCase,useCase);
            } else if (containsAnnotation(methodDeclaration, "Before")) {
                feedTestContext(methodDeclaration, useCase.beforeScenario,useCase);
            } else if (containsAnnotation(methodDeclaration, "After")) {
                feedTestContext(methodDeclaration, useCase.afterScenario,useCase);
            } else {
                feedTestFixture(methodDeclaration, useCase);
            }
        }
    }
    useCase.helpers.completeDescriptionFromSource(configuration);
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private int countAccessorMethods()
{        
    int count = 0;
    
    List<TypeDeclaration> types = compUnit.getTypes();
    
    if (types != null)
        for (TypeDeclaration type : types)
        {
            List<BodyDeclaration> members = type.getMembers();
            if (members != null)                
                for (BodyDeclaration member : members)
                {
                    if (member instanceof MethodDeclaration)
                    {
                        MethodDeclaration method = (MethodDeclaration) member;                   

                        if (isAccessorMethod(method))
                            ++count;         
                    }
                }
            
        }
    
    return count;
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private LinkedList<String> getAttributesNames()
{
    List<TypeDeclaration> types = compUnit.getTypes();
    LinkedList<String> attNames = new LinkedList<String>();
    
    if (types != null)
    {
        for (TypeDeclaration type : types)
        {
            List<BodyDeclaration> members = type.getMembers();
            if (members != null)
                for (BodyDeclaration member : members)
                    if (member instanceof FieldDeclaration)
                    {
                        FieldDeclaration t = (FieldDeclaration) member;
                        List<VariableDeclarator> variables = t.getVariables();
                        for (VariableDeclarator v : variables)
                            attNames.add(v.getId().getName());
                    }
        }
    }
    
    return attNames;
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private static void changeMethods(CompilationUnit cu, String rootClass) {
    addImport(cu, rootClass);
    String rootClassShort = rootClass
            .substring(rootClass.lastIndexOf(".") + 1);

    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;
                if (isSetRootComponentMethod(method)) {
                    changeSetRootMethod(method, rootClassShort);
                }
            } else if (member instanceof FieldDeclaration) {
                FieldDeclaration field = (FieldDeclaration) member;
                if (isRootField(field)) {
                    changeRootField(field, rootClassShort);
                }
            }
        }
    }
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
public int[] ensureClaraFieldExists(String id, String className) {
	
	List<TypeDeclaration> types = cu.getTypes();
	for (TypeDeclaration type : types) {
		List<BodyDeclaration> members = type.getMembers();
		if (members==null) {
			break;
		}
		for (BodyDeclaration member : members) {
			if (member instanceof FieldDeclaration) {
				FieldDeclaration field = (FieldDeclaration) member;
				if (isClaraField(field, id, className)) {
					return getMemberRowCol(field);
				}
			}
		}
	}
	
	FieldDeclaration fd = addClaraField(id, className);
	
	reparse();
	String name = fd.getVariables().get(0).getId().getName();
	int[] hmm = getFieldRowCol(name);
	
	return hmm;
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
public Declaration(TypeDeclaration decl) {
    className = decl.getName();
    methods = new ArrayList<String>();
    attributes = new HashSet<String>();
    processAnnotations(decl);
    for (BodyDeclaration method : decl.getMembers()) {
        processAnnotations(method);
        if (method instanceof MethodDeclaration)
            methods.add(((MethodDeclaration)method).getName());
    }
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private static List<String> insertBuilder( TypeDeclaration builderParentDecl , File javaFile ) throws Exception
{
	List<String> lines = readLines( javaFile );
	
	String[ ] classNames = getNestedClassNames( builderParentDecl );
	
	List<BodyDeclaration> members = builderParentDecl.getMembers( );
	
	for( int m = members.size( ) - 1 ; m >= 0 ; m-- )
	{
		BodyDeclaration decl = members.get( m );
		
		// re-parse after every insertion, since the end line of the
		// destination type will have changed
		CompilationUnit compunit = parse( lines );
		
		TypeDeclaration destType = find( compunit , classNames );
		
		BodyDeclaration toReplace = null;
		if( decl instanceof MethodDeclaration )
		{
			toReplace = find( destType , ( MethodDeclaration ) decl );
		}
		else if( decl instanceof TypeDeclaration )
		{
			toReplace = find( destType , ( ( TypeDeclaration ) decl ).getName( ) );
		}
		
		if( toReplace != null )
		{
			replace( lines , getTotalLineRegion( toReplace ) , decl.toString( ) );
		}
		else
		{
			insert( lines , destType.getEndLine( ) - 1 , destType.getEndColumn( ) - 1 , decl.toString( ) );
		}
	}
	
	return lines;
}
 

import japa.parser.ast.body.TypeDeclaration; //导入方法依赖的package包/类
private void feedHelperClass(TypeDeclaration type, Helper helper) {
    for (BodyDeclaration bodyDeclaration : type.getMembers()) {
        if (bodyDeclaration instanceof MethodDeclaration) {
            MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDeclaration;
            feedTestFixture(methodDeclaration, helper);
        }
    }
}
 

import japa.parser.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);
}