Java DefaultJavaPrettyPrinter类代码示例

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public SpoonedFile(File[] sourceFiles, NopolContext nopolContext) {
    this.nopolContext = nopolContext;
    this.sourceFiles = sourceFiles;
    this.projectClasspath = nopolContext.getProjectClasspath();

    factory = SpoonModelLibrary.newFactory();
    factory.getEnvironment().setComplianceLevel(nopolContext.getComplianceLevel());
    factory.getEnvironment().setCommentEnabled(false);
    factory.getEnvironment().setLevel(Level.OFF.toString());

    factory = SpoonModelLibrary.modelFor(factory, sourceFiles, projectClasspath());

    compiler = new DynamicClassCompiler(compilationClasspath(), nopolContext.getComplianceLevel());
    manager = new RuntimeProcessingManager(factory);
    compiledClasses = MetaMap.newHashMap();
    prettyPrinter = new DefaultJavaPrettyPrinter(spoonEnvironment());
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public static void printJavaFileWithComment(CtType<?> type, File directory) {
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();
    env.setAutoImports(true);
    env.setCommentEnabled(true);
    JavaOutputProcessor processor = new JavaOutputProcessor(directory, new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);
    processor.createJavaFile(type);
    env.setAutoImports(false);
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
String getRefactoredCode() {
	Environment env = cmdAnalyser.getEnvironment();
	env.useTabulations(true);
	env.setAutoImports(true);
	DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(env);
	printer.calculate(null, new ArrayList<>(cmdAnalyser.getModel().getAllTypes()));
	return printer.getResult().replace(" \n", "\n").replaceAll("(\n)+", "\n");
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
@Override
public void run(final IMarker marker) {
	final Entry<CtExecutable<?>, UIListener> entry = DetectBlobListenerAction.getBlobCommands(marker);
	final WidgetProcessor widgetProc = new WidgetProcessor(true);
	
	System.out.println("Refactoring blob listener: " + entry);
	
	Launcher launcher = new Launcher(Collections.singletonList(widgetProc), DetectBlobListenerAction.currentAnalyser.getCmdAnalyser().getModelBuilder());
	launcher.process();
	
	System.out.println("Widgets processor ended");
	
	final CommandWidgetFinder finder = new CommandWidgetFinder(entry.getValue().getCommands(), widgetProc.getWidgetUsages());
	finder.process();
	final Collection<CommandWidgetFinder.WidgetFinderEntry> allEntries = finder.getResults().values();
	
	System.out.println("Widgets finder ended");
	
	entry.getValue().getCommands().forEach(cmd -> {
		final ListenerCommandRefactor ref = new ListenerCommandRefactor(cmd, null, false, false, false, allEntries);
		ref.execute();
		
		Environment env = widgetProc.getEnvironment();
		env.useTabulations(true);
		env.setAutoImports(true);
		DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(env);
		printer.calculate(null, cmd.getAllLocalStatmtsOrdered().stream().
				map(s -> s.getElements(new BasicFilter<CtTypeReference<?>>(CtTypeReference.class))).
				flatMap(s -> s.stream()).map(tref -> tref.getDeclaration()).collect(Collectors.toList()));
		System.out.println(printer.getResult());
	});
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public static void printAllClasses(Factory factory, File out, File fileFrom) {
    Environment env = factory.getEnvironment();
    Processor processor = new JavaOutputProcessorWithFilter(out, new DefaultJavaPrettyPrinter(env), allClassesName(fileFrom));
    try {
        ProcessingManager pm = new QueueProcessingManager(factory);
        pm.addProcessor(processor);
        pm.process(factory.Package().getRootPackage());
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public static void printJavaFile(File directory, CtType type) throws IOException {
    try {
        Factory factory = type.getFactory();
        Environment env = factory.getEnvironment();

        JavaOutputProcessor processor = new JavaOutputProcessor(directory, new DefaultJavaPrettyPrinter(env));
        processor.setFactory(factory);

        processor.createJavaFile(type);
        Log.trace("write type {} in directory {}", type.getQualifiedName(), directory);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
@Override
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = getPosition().getCompilationUnit().getMainType();
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
protected void printJavaFile(String directory, List<CtType> classes) throws IOException {
    Environment env = getFactory().getEnvironment();

    classes.stream()
            .forEach(cl -> {
                Log.debug("print java file: {}", directory + "/" + cl.getQualifiedName().replace(".", "/") + ".java");
                cl.getPosition().getCompilationUnit().getDeclaredTypes().stream()
                        .forEach(cc -> {
                            JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
                            processor.setFactory(getFactory());
                            processor.createJavaFile(cc);
                        });
            });
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
@Override
public void printJavaFile(String srcDir) throws IOException {
    CtType<?> type = loop.getParent(CtType.class);
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(srcDir), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), srcDir);
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
@Override
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = transformation.getOriginalClass(transformation.getTransplantationPoint());
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
/**
 * Prints the modified java file. When the transformation is done a new java file is created. This method performs a
 * pretty print of it
 *
 * @param directory Directory where the java file is going to be placed
 * @throws IOException
 */
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = getOriginalClass(transplantationPoint);
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public <T> DefaultJavaPrettyPrinter writeLocalVariable(
		CtLocalVariable<T> localVariable) {
	if (!context.noTypeDecl) {
		elementPrinterHelper.writeModifiers(localVariable);
		scan(localVariable.getType());
		printer.write(" ");
	}
	printer.write(localVariable.getType().toString());
	if (localVariable.getDefaultExpression() != null) {
		printer.write(" = ");
		scan(localVariable.getDefaultExpression());
	}
	return this;
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = getPosition().getCompilationUnit().getMainType();
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
@Override
public CompilationResult compile(Collection<? extends CtType> ctClassList, URL[] cp) {

	Map<String, String> toCompile = new HashMap<String, String>();
	prettyPrinter = new DefaultJavaPrettyPrinter(this.getFactory().getEnvironment());
	dcc = new JavaXToolsCompiler();
	
	for (CtType ctClass : ctClassList) {
		try {
			this.getProcessingManager().process(ctClass);
			toCompile.put(ctClass.getQualifiedName(), sourceForModelledClass(ctClass));
		} catch (Exception e) {
			logger.error("Error printing class "+ctClass.getQualifiedName(),e);
		}
	}

	List<String> cps = new ArrayList<>();
	cps.add("-cp");
	String path = "";
	for (URL url : cp) {
		path += ((url.getPath()) + File.pathSeparator);
	}
	cps.add(path);
	
	String compliance = ConfigurationProperties.getProperty("javacompliancelevel");
	cps.add("-source");
	cps.add("1."+ compliance);

	cps.add("-target");
	cps.add("1."+ compliance);
	
	CompilationResult rbc = dcc.javaBytecodeFor(toCompile, new HashMap<String, byte[]>(), cps);
	return rbc;
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
private String partialElementPrint(CtElement element) {
	DefaultJavaPrettyPrinter print = new DefaultJavaPrettyPrinter(element.getFactory().getEnvironment()) {
		@Override
		public DefaultJavaPrettyPrinter scan(CtElement e) {
			if (e != null && e.getMetadata("isMoved") == null) {
				return super.scan(e);
			}
			return this;
		}
	};

	print.scan(element);
	return print.getResult();
}