Helper class for storing long command lines inside temporary file.
/*
* Cobertura - http://cobertura.sourceforge.net/
*
* Copyright (C) 2005 Grzegorz Lukasik
*
* Note: This file is dual licensed under the GPL and the Apache
* Source License (so that it can be used from both the main
* Cobertura classes and the ant tasks).
*
* Cobertura is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation; either version 2 of the License,
* or (at your option) any later version.
*
* Cobertura is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Cobertura; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
//package net.sourceforge.cobertura.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
//import org.apache.log4j.Logger;
/**
* Helper class for storing long command lines inside temporary file.
* <p>
* Typical usage:
*
* <pre>
* builder = new CommandLineBuilder();
* builder.addArg("--someoption");
* builder.addArg("optionValue");
* ...
* builder.saveArgs();
* doSomething(builder.getCommandLineFile());
* builder.dispose();
* </pre>
*
* It will save options in <code>builder.getCommandLineFile()</code>. Options
* will be stored one in a line. To retrieve options from file helper method can
* be used (see documentation):
*
* <pre>
* String[] args = CommandLineBuilder.preprocessCommandLineArguments(args);
* </pre>
*
* </p>
*
* <p>
* NOTICE: No protection against line separators in arguments, should be OK for
* Cobertura needs.
* </p>
* <p>
* NOTICE: This class depends on local machine settings (line separator, default
* encoding). If arguments are saved on different machine than they are loaded,
* results are unspecified. No problem in Cobertura.
* </p>
*
* @author Grzegorz Lukasik
*/
public class CommandLineBuilder {
// private static final Logger logger = Logger
// .getLogger(CommandLineBuilder.class);
private static final String LINESEP = System.getProperty("line.separator");
// File that will be used to store arguments
private File commandLineFile = null;
// Writer that will be used to write arguments to the file
private FileWriter commandLineWriter = null;
/**
* Creates a new instance of the builder. Instances of this class should not
* be reused to create many command lines.
*
* @throws IOException
* if problems with creating temporary file for storing command
* line occur
*/
public CommandLineBuilder() throws IOException {
commandLineFile = File.createTempFile("cobertura.", ".cmdline");
commandLineFile.deleteOnExit();
commandLineWriter = new FileWriter(commandLineFile);
}
/**
* Adds command line argument. Each argument can be thought as a single cell
* in array passed to main method. This method should not be used after
* arguments were saved.
*
* @param arg
* command line argument to save
* @throws IOException
* if problems with temporary file occur
* @throws NullPointerException
* if <code>arg</code> is <code>null</code>
*/
public void addArg(String arg) throws IOException {
if (arg == null)
throw new NullPointerException();
commandLineWriter.write(arg + LINESEP);
}
/**
* Adds two command line arguments. Convienience function, calls
* {@link #addArg(String)} two times.
*
* @param arg1
* first command line argument to save
* @param arg2
* second command line argument to save
* @throws IOException
* if problems with temporary file occur
* @throws NullPointerException
* if any <code>arg</code> is <code>null</code>
*/
public void addArg(String arg1, String arg2) throws IOException {
addArg(arg1);
addArg(arg2);
}
/**
* Saves options and made file available to use. Use method
* {@link #getCommandLineFile} to get the file the arguments are saved in.
*
* @throws IOException
* if problems with temporary file occur
*/
public void saveArgs() throws IOException {
commandLineWriter.flush();
commandLineWriter.close();
}
/**
* Gets absolute path to the file with saved arguments. Notice, that however
* this method can be used as soon as an instance of this class is created,
* arguments should be read from the file after a call to {@link #saveArgs}
* method.
*
* @return absolute path to the file with arguments
*/
public String getCommandLineFile() {
return commandLineFile.getAbsolutePath();
}
/**
* Explicity frees all resources associated with this instance. Result of
* any other method call after disposing an instance of this class is
* unspecified.
*/
public void dispose() {
commandLineFile.delete();
}
/**
* Loads arguments from file if <code>--commandsfile</code> option is used.
* Checks if passed array contains <code>--commandsfile</code> String, and
* if so arguments from file specified in the very next array cell are read.
* If there are more then one <code>--commandsfile</code> the result is
* unspecified.
*
* @return The list of arguments read from commandsfile, or
* <code>args</code> if commandsfile option was not specified or the
* file cannot be read.
* @throws NullPointerException
* if args is null, or any argument is null
* @throws IllegalArgumentException
* if --commandsfile is specified as last option
* @throws IOException
* if I/O related error with temporary command line file occur
*/
public static String[] preprocessCommandLineArguments(String[] args)
throws IOException {
boolean hasCommandsFile = false;
String commandsFileName = null;
for (int i = 0; i < args.length; i++) {
if (args[i].equals("--commandsfile")) {
if (i == args.length - 1) {
throw new IllegalArgumentException(
"'--commandsfile' specified as last option.");
}
hasCommandsFile = true;
commandsFileName = args[++i];
}
}
if (hasCommandsFile) {
List arglist = new ArrayList();
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new FileReader(
commandsFileName));
String line;
while ((line = bufferedReader.readLine()) != null)
arglist.add(line);
} catch (IOException e) {
// logger.info(
// "I/O error when reading temporary commands file", e);
throw new IOException("Unable to read temporary commands file "
+ commandsFileName + ".");
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (IOException e) {
}
}
}
args = (String[]) arglist.toArray(new String[arglist.size()]);
}
return args;
}
}
Related examples in the same category
