Java CompilationUnit.setPackage方法代码示例

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
public static String mergeContent(CompilationUnit one, CompilationUnit two) throws Exception {

        // 包声明不同，返回null
        if (!one.getPackage().equals(two.getPackage())) return null;

        CompilationUnit cu = new CompilationUnit();

        // add package declaration to the compilation unit
        PackageDeclaration pd = new PackageDeclaration();
        pd.setName(one.getPackage().getName());
        cu.setPackage(pd);

        // check and merge file comment;
        Comment fileComment = mergeSelective(one.getComment(), two.getComment());
        cu.setComment(fileComment);

        // check and merge imports
        List<ImportDeclaration> ids = mergeListNoDuplicate(one.getImports(), two.getImports());
        cu.setImports(ids);

        // check and merge Types
        List<TypeDeclaration> types = mergeTypes(one.getTypes(), two.getTypes());
        cu.setTypes(types);

        return cu.toString();
    }
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
@Override public Node visit(final CompilationUnit n, final A arg) {
	if (n.getPackage() != null) {
		n.setPackage((PackageDeclaration) n.getPackage().accept(this, arg));
	}
	final List<ImportDeclaration> imports = n.getImports();
	if (imports != null) {
		for (int i = 0; i < imports.size(); i++) {
			imports.set(i, (ImportDeclaration) imports.get(i).accept(this, arg));
		}
		removeNulls(imports);
	}
	final List<TypeDeclaration> types = n.getTypes();
	if (types != null) {
		for (int i = 0; i < types.size(); i++) {
			types.set(i, (TypeDeclaration) types.get(i).accept(this, arg));
		}
		removeNulls(types);
	}
	return n;
}
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
@Override
public void execute(PathResolver pathResolver) throws Exception {
    CompilationUnit cu = new CompilationUnit();
    String basePackage = BasePackageDetector.detect();
    cu.setPackage(new PackageDeclaration(ASTHelper.createNameExpr(basePackage + "form")));

    ClassOrInterfaceDeclaration formClass = new ClassOrInterfaceDeclaration(
            ModifierSet.PUBLIC, false, CaseConverter.pascalCase(tableName) + "Form");
    ASTHelper.addTypeDeclaration(cu, formClass);
    formClass.setExtends(Collections.singletonList(
            new ClassOrInterfaceType("FormBase")
    ));

    fields.stream()
            .filter(f -> !f.isId())
            .forEach(f -> ASTHelper.addMember(formClass, fieldDeclaration(f)));
    fields.stream()
            .filter(f -> !f.isId())
            .forEach(f -> ASTHelper.addMember(formClass, getterDeclaration(f)));
    fields.stream()
            .filter(f -> !f.isId())
            .forEach(f -> ASTHelper.addMember(formClass, setterDeclaration(f)));

    try (Writer writer = new OutputStreamWriter(pathResolver.destinationAsStream(destination))) {
        writer.write(cu.toString());
    }
}
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
public void execute(PathResolver pathResolver) throws Exception {
    CompilationUnit cu = new CompilationUnit();
    cu.setPackage(new PackageDeclaration(ASTHelper.createNameExpr(pkgName)));
    cu.setImports(Arrays.asList(
            new ImportDeclaration(ASTHelper.createNameExpr("org.seasar.doma.jdbc.Config"), false, false),
            new ImportDeclaration(ASTHelper.createNameExpr("org.seasar.doma.jdbc.dialect.Dialect"), false, false),
            new ImportDeclaration(ASTHelper.createNameExpr("org.seasar.doma.jdbc.dialect.H2Dialect"), false, false),
            new ImportDeclaration(ASTHelper.createNameExpr("javax.sql.DataSource"), false, false)
    ));

    ClassOrInterfaceDeclaration type = new ClassOrInterfaceDeclaration(ModifierSet.PUBLIC, false, "DomaConfig");
    type.setImplements(Collections.singletonList(new ClassOrInterfaceType("Config")));
    ASTHelper.addTypeDeclaration(cu, type);


    MethodDeclaration getDataSourceMethod = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.createReferenceType("DataSource", 0), "getDataSource");
    getDataSourceMethod.setAnnotations(Collections.singletonList(OVERRIDE_ANNOTATION));
    BlockStmt getDataSourceBody = new BlockStmt();
    ASTHelper.addStmt(getDataSourceBody, new ReturnStmt(new NullLiteralExpr()));
    getDataSourceMethod.setBody(getDataSourceBody);
    ASTHelper.addMember(type, getDataSourceMethod);

    MethodDeclaration getDialectMethod = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.createReferenceType("Dialect", 0), "getDialect");
    getDialectMethod.setAnnotations(Collections.singletonList(OVERRIDE_ANNOTATION));
    BlockStmt getDialectBody = new BlockStmt();

    ObjectCreationExpr newDialect = new ObjectCreationExpr(null, new ClassOrInterfaceType("H2Dialect"), null);
    ASTHelper.addStmt(getDialectBody, new ReturnStmt(newDialect));
    getDialectMethod.setBody(getDialectBody);
    ASTHelper.addMember(type, getDialectMethod);

    try (OutputStreamWriter writer = new OutputStreamWriter(
            pathResolver.destinationAsStream(destination))) {
        writer.write(cu.toString());
    }
}
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
/**
 * creates the compilation unit
 */
private static CompilationUnit createCU() {
    CompilationUnit cu = new CompilationUnit();
    // set the package
    cu.setPackage(new PackageDeclaration(ASTHelper.createNameExpr("java.parser.test")));

    // create the type declaration
    ClassOrInterfaceDeclaration type = new ClassOrInterfaceDeclaration(ModifierSet.PUBLIC, false, "GeneratedClass");
    ASTHelper.addTypeDeclaration(cu, type);

    // create a method
    MethodDeclaration method = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.VOID_TYPE, "main");
    method.setModifiers(ModifierSet.addModifier(method.getModifiers(), ModifierSet.STATIC));
    ASTHelper.addMember(type, method);

    // add a parameter to the method
    Parameter param = ASTHelper.createParameter(ASTHelper.createReferenceType("String", 0), "args");
    param.setVarArgs(true);
    ASTHelper.addParameter(method, param);

    // add a body to the method
    BlockStmt block = new BlockStmt();
    method.setBody(block);

    // add a statement do the method body
    NameExpr clazz = new NameExpr("System");
    FieldAccessExpr field = new FieldAccessExpr(clazz, "out");
    MethodCallExpr call = new MethodCallExpr(field, "println");
    ASTHelper.addArgument(call, new StringLiteralExpr("Hello World!"));
    ASTHelper.addStmt(block, call);

    return cu;
}
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
@Before
public void setup(){
  CompilationUnit cu = new CompilationUnit();
  // set the package
  cu.setPackage(new PackageDeclaration(ASTHelper.createNameExpr("java.parser.test")));

  // create the type declaration
  ClassOrInterfaceDeclaration type = new ClassOrInterfaceDeclaration(ModifierSet.PUBLIC, false, "GeneratedClass");
  ASTHelper.addTypeDeclaration(cu, type);

  // create a method
  MethodDeclaration method = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.VOID_TYPE, "main");
  method.setModifiers(ModifierSet.addModifier(method.getModifiers(), ModifierSet.STATIC));
  ASTHelper.addMember(type, method);

  // add a parameter to the method
  Parameter param = ASTHelper.createParameter(ASTHelper.createReferenceType("String", 0), "args");
  param.setVarArgs(true);
  ASTHelper.addParameter(method, param);

  // add a body to the method
  BlockStmt block = new BlockStmt();
  method.setBody(block);

  // add a statement do the method body
  NameExpr clazz = new NameExpr("System");
  FieldAccessExpr field = new FieldAccessExpr(clazz, "out");
  MethodCallExpr call = new MethodCallExpr(field, "println");
  ASTHelper.addArgument(call, new StringLiteralExpr("Hello World!"));
  ASTHelper.addStmt(block, call);

  unit = cu;
}
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
@Override
public void execute(PathResolver pathResolver) throws Exception {
    CompilationUnit cu = new CompilationUnit();
    cu.setPackage(new PackageDeclaration(ASTHelper.createNameExpr("db.migration")));
    List<ImportDeclaration> imports = new ArrayList<>();
    imports.add(new ImportDeclaration(ASTHelper.createNameExpr("org.flywaydb.core.api.migration.jdbc.JdbcMigration"), false, false));
    imports.add(new ImportDeclaration(ASTHelper.createNameExpr("java.sql.Connection"), false, false));
    imports.add(new ImportDeclaration(ASTHelper.createNameExpr("java.sql.Statement"), false, false));
    cu.setImports(imports);

    String version = LocalDateTime.now().format(VERSION_FMT);
    ClassOrInterfaceDeclaration migrationClass = new ClassOrInterfaceDeclaration(
            ModifierSet.PUBLIC, false, "V" + version + "__Create"
            + CaseConverter.pascalCase(tableName));
    ASTHelper.addTypeDeclaration(cu, migrationClass);

    List<ClassOrInterfaceType> implementList = new ArrayList<>();
    implementList.add(new ClassOrInterfaceType("JdbcMigration"));
    migrationClass.setImplements(implementList);
    MethodDeclaration migrateMethod = new MethodDeclaration(ModifierSet.PUBLIC, ASTHelper.VOID_TYPE, "migrate");
    ASTHelper.addMember(migrationClass, migrateMethod);
    ASTHelper.addParameter(migrateMethod, ASTHelper.createParameter(
            ASTHelper.createReferenceType("Connection", 0), "connection"
    ));
    migrateMethod.setThrows(Collections.singletonList(ASTHelper.createNameExpr("Exception")));

    List<AnnotationExpr> annotations = new ArrayList<>();
    annotations.add(new MarkerAnnotationExpr(ASTHelper.createNameExpr("Override")));
    migrateMethod.setAnnotations(annotations);

    BlockStmt block = new BlockStmt();
    migrateMethod.setBody(block);

    TryStmt tryStmt = new TryStmt(createStatementExecuteBlock(), null, null);
    tryStmt.setResources(Collections.singletonList(createAssignStatement()));
    ASTHelper.addStmt(block, tryStmt);

    try (Writer writer = new OutputStreamWriter(
            pathResolver.destinationAsStream(
                    "src/main/java/db/migration/" + migrationClass.getName() + ".java"))) {
        writer.write(cu.toString());
    }
}
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
@When("the package declaration is set to \"$packageName\"")
public void whenThePackageDeclarationIsSetTo(String packageName) {
    CompilationUnit compilationUnit = (CompilationUnit) state.get("cu1");
    compilationUnit.setPackage(new PackageDeclaration(new NameExpr(packageName)));
    state.put("cu1", compilationUnit);
}
 

import com.github.javaparser.ast.CompilationUnit; //导入方法依赖的package包/类
@Override
public CompilationUnit doMerge(CompilationUnit first, CompilationUnit second) {

  CompilationUnit unit = new CompilationUnit();

  unit.setPackage(mergeSingle(first.getPackage(), second.getPackage()));

  unit.setImports(mergeCollections(first.getImports(), second.getImports()));

  unit.setTypes(mergeCollections(first.getTypes(), second.getTypes()));

  return unit;
}