Java ImportDeclaration.setName方法代码示例

import org.eclipse.jdt.core.dom.ImportDeclaration; //导入方法依赖的package包/类
/**
 * Adds an import to a compilation unit, if missing
 * 
 * @param node
 * @param newImportName
 */
@SuppressWarnings("unchecked")
private static void addImportToCompilationUnitIfMissing(final ASTNode node, final String newImportName) {
	final CompilationUnit compilationUnit = (CompilationUnit) node.getRoot();
	boolean hasImport = false;
	for (final Iterator<?> iterator = compilationUnit.imports().iterator(); iterator.hasNext() && !hasImport;) {
		final ImportDeclaration importDeclaration = (ImportDeclaration) iterator.next();
		final String importName = importDeclaration.getName().getFullyQualifiedName();
		if (importName.equals(newImportName)) {
			hasImport = true;
		}
	}
	if (!hasImport) {
		final ImportDeclaration newImportDeclaration = node.getAST().newImportDeclaration();
		newImportDeclaration.setName(node.getAST().newName(newImportName));
		compilationUnit.imports().add(newImportDeclaration);
	}
}
 

import org.eclipse.jdt.core.dom.ImportDeclaration; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void after(CaptureLog log) 
{
	if(this.isXStreamNeeded)
	{
		ImportDeclaration id = ast.newImportDeclaration();
		id.setName(ast.newName(new String[] { "com", "thoughtworks", "xstream", "XStream" }));
		cu.imports().add(id);
		
		// create XSTREAM constant: private static final XStream XSTREAM = new XStream();
		final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
		vd.setName(ast.newSimpleName("XSTREAM"));			
		final ClassInstanceCreation ci = ast.newClassInstanceCreation();
		ci.setType(this.createAstType("XStream", ast));
		vd.setInitializer(ci);
		final FieldDeclaration xstreamConst = ast.newFieldDeclaration(vd);
		xstreamConst.setType(this.createAstType("XStream", ast));
		xstreamConst.modifiers().add(ast.newModifier(ModifierKeyword.PRIVATE_KEYWORD));
		xstreamConst.modifiers().add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD));
		xstreamConst.modifiers().add(ast.newModifier(ModifierKeyword.FINAL_KEYWORD));
		td.bodyDeclarations().add(xstreamConst);
		
		this.isXStreamNeeded = false;
	}
	
	
	//-- creates utility method to set field value via reflections
	if(this.isSetFieldMethodNeeded)
	{
		this.createSetFieldMethod(td, cu, ast);
		this.isSetFieldMethodNeeded = false;
	}
	
	//-- creates utility method to get field value via reflections
	if(this.isGetFieldMethodNeeded)
	{
		this.createGetFieldMethod(td, cu, ast);
		this.isGetFieldMethodNeeded = false;
	}
	
	//-- creates utility method to call method via reflections
	if(this.isCallMethodMethodNeeded)
	{
		this.createCallMethod(td, cu, ast);
		this.isCallMethodMethodNeeded = false;
	}
	
	//-- creates utility method to call constructor via reflections
	if(this.isNewInstanceMethodNeeded)
	{
		this.createNewInstanceMethod(td, cu, ast);
		this.isNewInstanceMethodNeeded = false;
	}
}
 

import org.eclipse.jdt.core.dom.ImportDeclaration; //导入方法依赖的package包/类
public static void addImports(ASTRewrite rewrite, CompilationUnit compilationUnit,
        Comparator<? super ImportDeclaration> comparator, boolean staticImports, String... imports) {
    checkForNull(comparator, "import comparator");
    checkForNull(imports, "imports");

    final AST ast = rewrite.getAST();
    SortedSet<ImportDeclaration> importDeclarations = new TreeSet<ImportDeclaration>(comparator);
    for (String importName : imports) {
        ImportDeclaration importDeclaration = ast.newImportDeclaration();
        importDeclaration.setName(ast.newName(importName));
        importDeclaration.setStatic(staticImports);
        importDeclarations.add(importDeclaration);
    }
    addImports(rewrite, compilationUnit, importDeclarations);
}
 

import org.eclipse.jdt.core.dom.ImportDeclaration; //导入方法依赖的package包/类
private void addImport(AST ast, ListRewrite importRewrite, String fullyQualifierImport) {
    ImportDeclaration importDeclaration = ast.newImportDeclaration();
    importDeclaration.setName(ast.newName(fullyQualifierImport));
    importRewrite.insertLast(importDeclaration, null);
}
 

import org.eclipse.jdt.core.dom.ImportDeclaration; //导入方法依赖的package包/类
private ImportDeclaration getImportDeclaration(ASTRewrite rewrite) {
   ImportDeclaration newImportDeclaration = rewrite.getAST().newImportDeclaration();
newImportDeclaration.setOnDemand(true);
newImportDeclaration.setName(rewrite.getAST().newName(new String[] { "edu", "cmu", "cs", "aliasjava", "annotations" }));
   return newImportDeclaration;
  }
 

import org.eclipse.jdt.core.dom.ImportDeclaration; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public void before(CaptureLog log) {
	ast = AST.newAST(AST.JLS3);
	cu = ast.newCompilationUnit();

	// package declaration
	final PackageDeclaration p1 = ast.newPackageDeclaration();
	p1.setName(ast.newName(packageName.split("\\.")));
	cu.setPackage(p1);

	// import specifications
	ImportDeclaration id = ast.newImportDeclaration();
	id.setName(ast.newName(new String[] { "org", "junit", "Test" }));
	cu.imports().add(id);
	
	// class declaration
	td = ast.newTypeDeclaration();
	td.setName(ast.newSimpleName(cuName));
	td.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
	cu.types().add(td);
	

	
	// test method construction
	final MethodDeclaration md = ast.newMethodDeclaration();
	md.setName(ast.newSimpleName("test"));
	md.thrownExceptions().add(ast.newSimpleName("Exception"));

	
	
	// sets @Test annotation to test method
	final NormalAnnotation annotation = ast.newNormalAnnotation();
	annotation.setTypeName(ast.newSimpleName("Test"));
	md.modifiers().add(annotation);
	
	// sets method to public
	md.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
	td.bodyDeclarations().add(md);
	
	methodBlock = ast.newBlock();
	md.setBody(methodBlock);
	
}
 

import org.eclipse.jdt.core.dom.ImportDeclaration; //导入方法依赖的package包/类
private ImportDeclaration createImportDeclaration(AST ast, String name, boolean isStatic) {
    ImportDeclaration importDeclaration = ast.newImportDeclaration();
    importDeclaration.setName(ast.newName(name));
    importDeclaration.setStatic(isStatic);
    return importDeclaration;
}