Helper class for storing long command lines inside temporary file. : Console « Development Class « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JDK 6
25.JNDI LDAP
26.JPA
27.JSP
28.JSTL
29.Language Basics
30.Network Protocol
31.PDF RTF
32.Reflection
33.Regular Expressions
34.Scripting
35.Security
36.Servlets
37.Spring
38.Swing Components
39.Swing JFC
40.SWT JFace Eclipse
41.Threads
42.Tiny Application
43.Velocity
44.Web Services SOA
45.XML
Java » Development Class » ConsoleScreenshots 
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(&quot;--someoption&quot;);
 *  builder.addArg(&quot;optionValue&quot;);
 *  ...
 *  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 argthrows 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 arg2throws 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
1.Turn System.out into a PrintWriterTurn System.out into a PrintWriter
2.Output to standard output and standard error; and input from standard input.Output to standard output and standard error; and input from standard input.
3.VarArgsDemo - show 1.5 variable argumentsVarArgsDemo - show 1.5 variable arguments
4.How to read from standard inputHow to read from standard input
5.How to deal with the console parametersHow to deal with the console parameters
6.Read input from consoleRead input from console
7.Command line input
8.Read an int from Standard Input
9.Read an int from Standard Input, using 1.5
10.SimpleCalc -- simple calculator using 1.5 java.util.Scanner
11.Show use of Argv to get an integer value from command lineShow use of Argv to get an integer value from command line
12.Java program to calculate the area of a circleJava program to calculate the area of a circle
13.Java program to demonstrate menu selectionJava program to demonstrate menu selection
14.Utility class for printing aligned columns of text
15.Processing the command line
16.A representation of the command line arguments passed to a Java class' main(String[]) method
17.CommandLine Parser
18.This parses command line arguments optimized for ease of programmer use.
19.Console read and write Utils
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.