16:34:38.672 INFO  jd.cli.Main - Decompiling commons-cli-1.2.jar
package org.apache.commons.cli;

public class AlreadySelectedException
  extends ParseException
{
  private OptionGroup group;
  private Option option;
  
  public AlreadySelectedException(String message)
  {
    super(message);
  }
  
  public AlreadySelectedException(OptionGroup group, Option option)
  {
    this("The option '" + option.getKey() + "' was specified but an option from this group " + "has already been selected: '" + group.getSelected() + "'");
    
    this.group = group;
    this.option = option;
  }
  
  public OptionGroup getOptionGroup()
  {
    return group;
  }
  
  public Option getOption()
  {
    return option;
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.AlreadySelectedException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

public class BasicParser
  extends Parser
{
  protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
  {
    return arguments;
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.BasicParser
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.io.PrintStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;

public class CommandLine
  implements Serializable
{
  private static final long serialVersionUID = 1L;
  private List args = new LinkedList();
  private List options = new ArrayList();
  
  public boolean hasOption(String opt)
  {
    return options.contains(resolveOption(opt));
  }
  
  public boolean hasOption(char opt)
  {
    return hasOption(String.valueOf(opt));
  }
  
  /**
   * @deprecated
   */
  public Object getOptionObject(String opt)
  {
    try
    {
      return getParsedOptionValue(opt);
    }
    catch (ParseException pe)
    {
      System.err.println("Exception found converting " + opt + " to desired type: " + pe.getMessage());
    }
    return null;
  }
  
  public Object getParsedOptionValue(String opt)
    throws ParseException
  {
    String res = getOptionValue(opt);
    
    Option option = resolveOption(opt);
    if (option == null) {
      return null;
    }
    Object type = option.getType();
    
    return res == null ? null : TypeHandler.createValue(res, type);
  }
  
  public Object getOptionObject(char opt)
  {
    return getOptionObject(String.valueOf(opt));
  }
  
  public String getOptionValue(String opt)
  {
    String[] values = getOptionValues(opt);
    
    return values == null ? null : values[0];
  }
  
  public String getOptionValue(char opt)
  {
    return getOptionValue(String.valueOf(opt));
  }
  
  public String[] getOptionValues(String opt)
  {
    List values = new ArrayList();
    for (Iterator it = options.iterator(); it.hasNext();)
    {
      Option option = (Option)it.next();
      if ((opt.equals(option.getOpt())) || (opt.equals(option.getLongOpt()))) {
        values.addAll(option.getValuesList());
      }
    }
    return values.isEmpty() ? null : (String[])values.toArray(new String[values.size()]);
  }
  
  private Option resolveOption(String opt)
  {
    opt = Util.stripLeadingHyphens(opt);
    for (Iterator it = options.iterator(); it.hasNext();)
    {
      Option option = (Option)it.next();
      if (opt.equals(option.getOpt())) {
        return option;
      }
      if (opt.equals(option.getLongOpt())) {
        return option;
      }
    }
    return null;
  }
  
  public String[] getOptionValues(char opt)
  {
    return getOptionValues(String.valueOf(opt));
  }
  
  public String getOptionValue(String opt, String defaultValue)
  {
    String answer = getOptionValue(opt);
    
    return answer != null ? answer : defaultValue;
  }
  
  public String getOptionValue(char opt, String defaultValue)
  {
    return getOptionValue(String.valueOf(opt), defaultValue);
  }
  
  public Properties getOptionProperties(String opt)
  {
    Properties props = new Properties();
    for (Iterator it = options.iterator(); it.hasNext();)
    {
      Option option = (Option)it.next();
      if ((opt.equals(option.getOpt())) || (opt.equals(option.getLongOpt())))
      {
        List values = option.getValuesList();
        if (values.size() >= 2) {
          props.put(values.get(0), values.get(1));
        } else if (values.size() == 1) {
          props.put(values.get(0), "true");
        }
      }
    }
    return props;
  }
  
  public String[] getArgs()
  {
    String[] answer = new String[args.size()];
    
    args.toArray(answer);
    
    return answer;
  }
  
  public List getArgList()
  {
    return args;
  }
  
  void addArg(String arg)
  {
    args.add(arg);
  }
  
  void addOption(Option opt)
  {
    options.add(opt);
  }
  
  public Iterator iterator()
  {
    return options.iterator();
  }
  
  public Option[] getOptions()
  {
    Collection processed = options;
    
    Option[] optionsArray = new Option[processed.size()];
    
    return (Option[])processed.toArray(optionsArray);
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.CommandLine
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

public abstract interface CommandLineParser
{
  public abstract CommandLine parse(Options paramOptions, String[] paramArrayOfString)
    throws ParseException;
  
  public abstract CommandLine parse(Options paramOptions, String[] paramArrayOfString, boolean paramBoolean)
    throws ParseException;
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.CommandLineParser
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.util.ArrayList;
import java.util.List;

public class GnuParser
  extends Parser
{
  protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
  {
    List tokens = new ArrayList();
    
    boolean eatTheRest = false;
    for (int i = 0; i < arguments.length; i++)
    {
      String arg = arguments[i];
      if ("--".equals(arg))
      {
        eatTheRest = true;
        tokens.add("--");
      }
      else if ("-".equals(arg))
      {
        tokens.add("-");
      }
      else if (arg.startsWith("-"))
      {
        String opt = Util.stripLeadingHyphens(arg);
        if (options.hasOption(opt))
        {
          tokens.add(arg);
        }
        else if ((opt.indexOf('=') != -1) && (options.hasOption(opt.substring(0, opt.indexOf('=')))))
        {
          tokens.add(arg.substring(0, arg.indexOf('=')));
          tokens.add(arg.substring(arg.indexOf('=') + 1));
        }
        else if (options.hasOption(arg.substring(0, 2)))
        {
          tokens.add(arg.substring(0, 2));
          tokens.add(arg.substring(2));
        }
        else
        {
          eatTheRest = stopAtNonOption;
          tokens.add(arg);
        }
      }
      else
      {
        tokens.add(arg);
      }
      if (eatTheRest) {
        for (i++; i < arguments.length; i++) {
          tokens.add(arguments[i]);
        }
      }
    }
    return (String[])tokens.toArray(new String[tokens.size()]);
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.GnuParser
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

class HelpFormatter$1 {}

/* Location:
 * Qualified Name:     org.apache.commons.cli.HelpFormatter.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.util.Comparator;

class HelpFormatter$OptionComparator
  implements Comparator
{
  HelpFormatter$OptionComparator(HelpFormatter.1 x0)
  {
    this();
  }
  
  public int compare(Object o1, Object o2)
  {
    Option opt1 = (Option)o1;
    Option opt2 = (Option)o2;
    
    return opt1.getKey().compareToIgnoreCase(opt2.getKey());
  }
  
  private HelpFormatter$OptionComparator() {}
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.HelpFormatter.OptionComparator
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

public class HelpFormatter
{
  public static final int DEFAULT_WIDTH = 74;
  public static final int DEFAULT_LEFT_PAD = 1;
  public static final int DEFAULT_DESC_PAD = 3;
  public static final String DEFAULT_SYNTAX_PREFIX = "usage: ";
  public static final String DEFAULT_OPT_PREFIX = "-";
  public static final String DEFAULT_LONG_OPT_PREFIX = "--";
  public static final String DEFAULT_ARG_NAME = "arg";
  /**
   * @deprecated
   */
  public int defaultWidth;
  /**
   * @deprecated
   */
  public int defaultLeftPad;
  /**
   * @deprecated
   */
  public int defaultDescPad;
  /**
   * @deprecated
   */
  public String defaultSyntaxPrefix;
  /**
   * @deprecated
   */
  public String defaultNewLine;
  /**
   * @deprecated
   */
  public String defaultOptPrefix;
  /**
   * @deprecated
   */
  public String defaultLongOptPrefix;
  /**
   * @deprecated
   */
  public String defaultArgName;
  protected Comparator optionComparator;
  
  public HelpFormatter()
  {
    defaultWidth = 74;
    
    defaultLeftPad = 1;
    
    defaultDescPad = 3;
    
    defaultSyntaxPrefix = "usage: ";
    
    defaultNewLine = System.getProperty("line.separator");
    
    defaultOptPrefix = "-";
    
    defaultLongOptPrefix = "--";
    
    defaultArgName = "arg";
    
    optionComparator = new OptionComparator(null);
  }
  
  public void setWidth(int width)
  {
    defaultWidth = width;
  }
  
  public int getWidth()
  {
    return defaultWidth;
  }
  
  public void setLeftPadding(int padding)
  {
    defaultLeftPad = padding;
  }
  
  public int getLeftPadding()
  {
    return defaultLeftPad;
  }
  
  public void setDescPadding(int padding)
  {
    defaultDescPad = padding;
  }
  
  public int getDescPadding()
  {
    return defaultDescPad;
  }
  
  public void setSyntaxPrefix(String prefix)
  {
    defaultSyntaxPrefix = prefix;
  }
  
  public String getSyntaxPrefix()
  {
    return defaultSyntaxPrefix;
  }
  
  public void setNewLine(String newline)
  {
    defaultNewLine = newline;
  }
  
  public String getNewLine()
  {
    return defaultNewLine;
  }
  
  public void setOptPrefix(String prefix)
  {
    defaultOptPrefix = prefix;
  }
  
  public String getOptPrefix()
  {
    return defaultOptPrefix;
  }
  
  public void setLongOptPrefix(String prefix)
  {
    defaultLongOptPrefix = prefix;
  }
  
  public String getLongOptPrefix()
  {
    return defaultLongOptPrefix;
  }
  
  public void setArgName(String name)
  {
    defaultArgName = name;
  }
  
  public String getArgName()
  {
    return defaultArgName;
  }
  
  public Comparator getOptionComparator()
  {
    return optionComparator;
  }
  
  public void setOptionComparator(Comparator comparator)
  {
    if (comparator == null) {
      optionComparator = new OptionComparator(null);
    } else {
      optionComparator = comparator;
    }
  }
  
  public void printHelp(String cmdLineSyntax, Options options)
  {
    printHelp(defaultWidth, cmdLineSyntax, null, options, null, false);
  }
  
  public void printHelp(String cmdLineSyntax, Options options, boolean autoUsage)
  {
    printHelp(defaultWidth, cmdLineSyntax, null, options, null, autoUsage);
  }
  
  public void printHelp(String cmdLineSyntax, String header, Options options, String footer)
  {
    printHelp(cmdLineSyntax, header, options, footer, false);
  }
  
  public void printHelp(String cmdLineSyntax, String header, Options options, String footer, boolean autoUsage)
  {
    printHelp(defaultWidth, cmdLineSyntax, header, options, footer, autoUsage);
  }
  
  public void printHelp(int width, String cmdLineSyntax, String header, Options options, String footer)
  {
    printHelp(width, cmdLineSyntax, header, options, footer, false);
  }
  
  public void printHelp(int width, String cmdLineSyntax, String header, Options options, String footer, boolean autoUsage)
  {
    PrintWriter pw = new PrintWriter(System.out);
    
    printHelp(pw, width, cmdLineSyntax, header, options, defaultLeftPad, defaultDescPad, footer, autoUsage);
    pw.flush();
  }
  
  public void printHelp(PrintWriter pw, int width, String cmdLineSyntax, String header, Options options, int leftPad, int descPad, String footer)
  {
    printHelp(pw, width, cmdLineSyntax, header, options, leftPad, descPad, footer, false);
  }
  
  public void printHelp(PrintWriter pw, int width, String cmdLineSyntax, String header, Options options, int leftPad, int descPad, String footer, boolean autoUsage)
  {
    if ((cmdLineSyntax == null) || (cmdLineSyntax.length() == 0)) {
      throw new IllegalArgumentException("cmdLineSyntax not provided");
    }
    if (autoUsage) {
      printUsage(pw, width, cmdLineSyntax, options);
    } else {
      printUsage(pw, width, cmdLineSyntax);
    }
    if ((header != null) && (header.trim().length() > 0)) {
      printWrapped(pw, width, header);
    }
    printOptions(pw, width, options, leftPad, descPad);
    if ((footer != null) && (footer.trim().length() > 0)) {
      printWrapped(pw, width, footer);
    }
  }
  
  public void printUsage(PrintWriter pw, int width, String app, Options options)
  {
    StringBuffer buff = new StringBuffer(defaultSyntaxPrefix).append(app).append(" ");
    
    Collection processedGroups = new ArrayList();
    
    List optList = new ArrayList(options.getOptions());
    Collections.sort(optList, getOptionComparator());
    for (Iterator i = optList.iterator(); i.hasNext();)
    {
      Option option = (Option)i.next();
      
      OptionGroup group = options.getOptionGroup(option);
      if (group != null)
      {
        if (!processedGroups.contains(group))
        {
          processedGroups.add(group);
          
          appendOptionGroup(buff, group);
        }
      }
      else {
        appendOption(buff, option, option.isRequired());
      }
      if (i.hasNext()) {
        buff.append(" ");
      }
    }
    printWrapped(pw, width, buff.toString().indexOf(' ') + 1, buff.toString());
  }
  
  private void appendOptionGroup(StringBuffer buff, OptionGroup group)
  {
    if (!group.isRequired()) {
      buff.append("[");
    }
    List optList = new ArrayList(group.getOptions());
    Collections.sort(optList, getOptionComparator());
    for (Iterator i = optList.iterator(); i.hasNext();)
    {
      appendOption(buff, (Option)i.next(), true);
      if (i.hasNext()) {
        buff.append(" | ");
      }
    }
    if (!group.isRequired()) {
      buff.append("]");
    }
  }
  
  private static void appendOption(StringBuffer buff, Option option, boolean required)
  {
    if (!required) {
      buff.append("[");
    }
    if (option.getOpt() != null) {
      buff.append("-").append(option.getOpt());
    } else {
      buff.append("--").append(option.getLongOpt());
    }
    if ((option.hasArg()) && (option.hasArgName())) {
      buff.append(" <").append(option.getArgName()).append(">");
    }
    if (!required) {
      buff.append("]");
    }
  }
  
  public void printUsage(PrintWriter pw, int width, String cmdLineSyntax)
  {
    int argPos = cmdLineSyntax.indexOf(' ') + 1;
    
    printWrapped(pw, width, defaultSyntaxPrefix.length() + argPos, defaultSyntaxPrefix + cmdLineSyntax);
  }
  
  public void printOptions(PrintWriter pw, int width, Options options, int leftPad, int descPad)
  {
    StringBuffer sb = new StringBuffer();
    
    renderOptions(sb, width, options, leftPad, descPad);
    pw.println(sb.toString());
  }
  
  public void printWrapped(PrintWriter pw, int width, String text)
  {
    printWrapped(pw, width, 0, text);
  }
  
  public void printWrapped(PrintWriter pw, int width, int nextLineTabStop, String text)
  {
    StringBuffer sb = new StringBuffer(text.length());
    
    renderWrappedText(sb, width, nextLineTabStop, text);
    pw.println(sb.toString());
  }
  
  protected StringBuffer renderOptions(StringBuffer sb, int width, Options options, int leftPad, int descPad)
  {
    String lpad = createPadding(leftPad);
    String dpad = createPadding(descPad);
    
    int max = 0;
    
    List prefixList = new ArrayList();
    
    List optList = options.helpOptions();
    
    Collections.sort(optList, getOptionComparator());
    for (Iterator i = optList.iterator(); i.hasNext();)
    {
      Option option = (Option)i.next();
      StringBuffer optBuf = new StringBuffer(8);
      if (option.getOpt() == null)
      {
        optBuf.append(lpad).append("   " + defaultLongOptPrefix).append(option.getLongOpt());
      }
      else
      {
        optBuf.append(lpad).append(defaultOptPrefix).append(option.getOpt());
        if (option.hasLongOpt()) {
          optBuf.append(',').append(defaultLongOptPrefix).append(option.getLongOpt());
        }
      }
      if (option.hasArg()) {
        if (option.hasArgName()) {
          optBuf.append(" <").append(option.getArgName()).append(">");
        } else {
          optBuf.append(' ');
        }
      }
      prefixList.add(optBuf);
      max = optBuf.length() > max ? optBuf.length() : max;
    }
    int x = 0;
    for (Iterator i = optList.iterator(); i.hasNext();)
    {
      Option option = (Option)i.next();
      StringBuffer optBuf = new StringBuffer(prefixList.get(x++).toString());
      if (optBuf.length() < max) {
        optBuf.append(createPadding(max - optBuf.length()));
      }
      optBuf.append(dpad);
      
      int nextLineTabStop = max + descPad;
      if (option.getDescription() != null) {
        optBuf.append(option.getDescription());
      }
      renderWrappedText(sb, width, nextLineTabStop, optBuf.toString());
      if (i.hasNext()) {
        sb.append(defaultNewLine);
      }
    }
    return sb;
  }
  
  protected StringBuffer renderWrappedText(StringBuffer sb, int width, int nextLineTabStop, String text)
  {
    int pos = findWrapPos(text, width, 0);
    if (pos == -1)
    {
      sb.append(rtrim(text));
      
      return sb;
    }
    sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
    if (nextLineTabStop >= width) {
      nextLineTabStop = 1;
    }
    String padding = createPadding(nextLineTabStop);
    for (;;)
    {
      text = padding + text.substring(pos).trim();
      pos = findWrapPos(text, width, 0);
      if (pos == -1)
      {
        sb.append(text);
        
        return sb;
      }
      if ((text.length() > width) && (pos == nextLineTabStop - 1)) {
        pos = width;
      }
      sb.append(rtrim(text.substring(0, pos))).append(defaultNewLine);
    }
  }
  
  protected int findWrapPos(String text, int width, int startPos)
  {
    int pos = -1;
    if ((((pos = text.indexOf('\n', startPos)) != -1) && (pos <= width)) || (((pos = text.indexOf('\t', startPos)) != -1) && (pos <= width))) {
      return pos + 1;
    }
    if (startPos + width >= text.length()) {
      return -1;
    }
    pos = startPos + width;
    char c;
    while ((pos >= startPos) && ((c = text.charAt(pos)) != ' ') && (c != '\n') && (c != '\r')) {
      pos--;
    }
    if (pos > startPos) {
      return pos;
    }
    pos = startPos + width;
    char c;
    while ((pos <= text.length()) && ((c = text.charAt(pos)) != ' ') && (c != '\n') && (c != '\r')) {
      pos++;
    }
    return pos == text.length() ? -1 : pos;
  }
  
  protected String createPadding(int len)
  {
    StringBuffer sb = new StringBuffer(len);
    for (int i = 0; i < len; i++) {
      sb.append(' ');
    }
    return sb.toString();
  }
  
  protected String rtrim(String s)
  {
    if ((s == null) || (s.length() == 0)) {
      return s;
    }
    int pos = s.length();
    while ((pos > 0) && (Character.isWhitespace(s.charAt(pos - 1)))) {
      pos--;
    }
    return s.substring(0, pos);
  }
  
  private static class OptionComparator
    implements Comparator
  {
    OptionComparator(HelpFormatter.1 x0)
    {
      this();
    }
    
    public int compare(Object o1, Object o2)
    {
      Option opt1 = (Option)o1;
      Option opt2 = (Option)o2;
      
      return opt1.getKey().compareToIgnoreCase(opt2.getKey());
    }
    
    private OptionComparator() {}
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.HelpFormatter
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

public class MissingArgumentException
  extends ParseException
{
  private Option option;
  
  public MissingArgumentException(String message)
  {
    super(message);
  }
  
  public MissingArgumentException(Option option)
  {
    this("Missing argument for option: " + option.getKey());
    this.option = option;
  }
  
  public Option getOption()
  {
    return option;
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.MissingArgumentException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.util.Iterator;
import java.util.List;

public class MissingOptionException
  extends ParseException
{
  private List missingOptions;
  
  public MissingOptionException(String message)
  {
    super(message);
  }
  
  public MissingOptionException(List missingOptions)
  {
    this(createMessage(missingOptions));
    this.missingOptions = missingOptions;
  }
  
  public List getMissingOptions()
  {
    return missingOptions;
  }
  
  private static String createMessage(List missingOptions)
  {
    StringBuffer buff = new StringBuffer("Missing required option");
    buff.append(missingOptions.size() == 1 ? "" : "s");
    buff.append(": ");
    
    Iterator it = missingOptions.iterator();
    while (it.hasNext())
    {
      buff.append(it.next());
      if (it.hasNext()) {
        buff.append(", ");
      }
    }
    return buff.toString();
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.MissingOptionException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class Option
  implements Cloneable, Serializable
{
  private static final long serialVersionUID = 1L;
  public static final int UNINITIALIZED = -1;
  public static final int UNLIMITED_VALUES = -2;
  private String opt;
  private String longOpt;
  private String argName = "arg";
  private String description;
  private boolean required;
  private boolean optionalArg;
  private int numberOfArgs = -1;
  private Object type;
  private List values = new ArrayList();
  private char valuesep;
  
  public Option(String opt, String description)
    throws IllegalArgumentException
  {
    this(opt, null, false, description);
  }
  
  public Option(String opt, boolean hasArg, String description)
    throws IllegalArgumentException
  {
    this(opt, null, hasArg, description);
  }
  
  public Option(String opt, String longOpt, boolean hasArg, String description)
    throws IllegalArgumentException
  {
    OptionValidator.validateOption(opt);
    
    this.opt = opt;
    this.longOpt = longOpt;
    if (hasArg) {
      numberOfArgs = 1;
    }
    this.description = description;
  }
  
  public int getId()
  {
    return getKey().charAt(0);
  }
  
  String getKey()
  {
    if (opt == null) {
      return longOpt;
    }
    return opt;
  }
  
  public String getOpt()
  {
    return opt;
  }
  
  public Object getType()
  {
    return type;
  }
  
  public void setType(Object type)
  {
    this.type = type;
  }
  
  public String getLongOpt()
  {
    return longOpt;
  }
  
  public void setLongOpt(String longOpt)
  {
    this.longOpt = longOpt;
  }
  
  public void setOptionalArg(boolean optionalArg)
  {
    this.optionalArg = optionalArg;
  }
  
  public boolean hasOptionalArg()
  {
    return optionalArg;
  }
  
  public boolean hasLongOpt()
  {
    return longOpt != null;
  }
  
  public boolean hasArg()
  {
    return (numberOfArgs > 0) || (numberOfArgs == -2);
  }
  
  public String getDescription()
  {
    return description;
  }
  
  public void setDescription(String description)
  {
    this.description = description;
  }
  
  public boolean isRequired()
  {
    return required;
  }
  
  public void setRequired(boolean required)
  {
    this.required = required;
  }
  
  public void setArgName(String argName)
  {
    this.argName = argName;
  }
  
  public String getArgName()
  {
    return argName;
  }
  
  public boolean hasArgName()
  {
    return (argName != null) && (argName.length() > 0);
  }
  
  public boolean hasArgs()
  {
    return (numberOfArgs > 1) || (numberOfArgs == -2);
  }
  
  public void setArgs(int num)
  {
    numberOfArgs = num;
  }
  
  public void setValueSeparator(char sep)
  {
    valuesep = sep;
  }
  
  public char getValueSeparator()
  {
    return valuesep;
  }
  
  public boolean hasValueSeparator()
  {
    return valuesep > 0;
  }
  
  public int getArgs()
  {
    return numberOfArgs;
  }
  
  void addValueForProcessing(String value)
  {
    switch (numberOfArgs)
    {
    case -1: 
      throw new RuntimeException("NO_ARGS_ALLOWED");
    }
    processValue(value);
  }
  
  private void processValue(String value)
  {
    if (hasValueSeparator())
    {
      char sep = getValueSeparator();
      
      int index = value.indexOf(sep);
      while (index != -1)
      {
        if (values.size() == numberOfArgs - 1) {
          break;
        }
        add(value.substring(0, index));
        
        value = value.substring(index + 1);
        
        index = value.indexOf(sep);
      }
    }
    add(value);
  }
  
  private void add(String value)
  {
    if ((numberOfArgs > 0) && (values.size() > numberOfArgs - 1)) {
      throw new RuntimeException("Cannot add value, list full.");
    }
    values.add(value);
  }
  
  public String getValue()
  {
    return hasNoValues() ? null : (String)values.get(0);
  }
  
  public String getValue(int index)
    throws IndexOutOfBoundsException
  {
    return hasNoValues() ? null : (String)values.get(index);
  }
  
  public String getValue(String defaultValue)
  {
    String value = getValue();
    
    return value != null ? value : defaultValue;
  }
  
  public String[] getValues()
  {
    return hasNoValues() ? null : (String[])values.toArray(new String[values.size()]);
  }
  
  public List getValuesList()
  {
    return values;
  }
  
  public String toString()
  {
    StringBuffer buf = new StringBuffer().append("[ option: ");
    
    buf.append(opt);
    if (longOpt != null) {
      buf.append(" ").append(longOpt);
    }
    buf.append(" ");
    if (hasArgs()) {
      buf.append("[ARG...]");
    } else if (hasArg()) {
      buf.append(" [ARG]");
    }
    buf.append(" :: ").append(description);
    if (type != null) {
      buf.append(" :: ").append(type);
    }
    buf.append(" ]");
    
    return buf.toString();
  }
  
  private boolean hasNoValues()
  {
    return values.isEmpty();
  }
  
  public boolean equals(Object o)
  {
    if (this == o) {
      return true;
    }
    if ((o == null) || (getClass() != o.getClass())) {
      return false;
    }
    Option option = (Option)o;
    if (opt != null ? !opt.equals(opt) : opt != null) {
      return false;
    }
    if (longOpt != null ? !longOpt.equals(longOpt) : longOpt != null) {
      return false;
    }
    return true;
  }
  
  public int hashCode()
  {
    int result = opt != null ? opt.hashCode() : 0;
    result = 31 * result + (longOpt != null ? longOpt.hashCode() : 0);
    return result;
  }
  
  public Object clone()
  {
    try
    {
      Option option = (Option)super.clone();
      values = new ArrayList(values);
      return option;
    }
    catch (CloneNotSupportedException cnse)
    {
      throw new RuntimeException("A CloneNotSupportedException was thrown: " + cnse.getMessage());
    }
  }
  
  void clearValues()
  {
    values.clear();
  }
  
  /**
   * @deprecated
   */
  public boolean addValue(String value)
  {
    throw new UnsupportedOperationException("The addValue method is not intended for client use. Subclasses should use the addValueForProcessing method instead. ");
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.Option
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

public final class OptionBuilder
{
  private static String longopt;
  private static String description;
  private static String argName;
  private static boolean required;
  private static int numberOfArgs = -1;
  private static Object type;
  private static boolean optionalArg;
  private static char valuesep;
  private static OptionBuilder instance = new OptionBuilder();
  
  private static void reset()
  {
    description = null;
    argName = "arg";
    longopt = null;
    type = null;
    required = false;
    numberOfArgs = -1;
    
    optionalArg = false;
    valuesep = '\000';
  }
  
  public static OptionBuilder withLongOpt(String newLongopt)
  {
    longopt = newLongopt;
    
    return instance;
  }
  
  public static OptionBuilder hasArg()
  {
    numberOfArgs = 1;
    
    return instance;
  }
  
  public static OptionBuilder hasArg(boolean hasArg)
  {
    numberOfArgs = hasArg ? 1 : -1;
    
    return instance;
  }
  
  public static OptionBuilder withArgName(String name)
  {
    argName = name;
    
    return instance;
  }
  
  public static OptionBuilder isRequired()
  {
    required = true;
    
    return instance;
  }
  
  public static OptionBuilder withValueSeparator(char sep)
  {
    valuesep = sep;
    
    return instance;
  }
  
  public static OptionBuilder withValueSeparator()
  {
    valuesep = '=';
    
    return instance;
  }
  
  public static OptionBuilder isRequired(boolean newRequired)
  {
    required = newRequired;
    
    return instance;
  }
  
  public static OptionBuilder hasArgs()
  {
    numberOfArgs = -2;
    
    return instance;
  }
  
  public static OptionBuilder hasArgs(int num)
  {
    numberOfArgs = num;
    
    return instance;
  }
  
  public static OptionBuilder hasOptionalArg()
  {
    numberOfArgs = 1;
    optionalArg = true;
    
    return instance;
  }
  
  public static OptionBuilder hasOptionalArgs()
  {
    numberOfArgs = -2;
    optionalArg = true;
    
    return instance;
  }
  
  public static OptionBuilder hasOptionalArgs(int numArgs)
  {
    numberOfArgs = numArgs;
    optionalArg = true;
    
    return instance;
  }
  
  public static OptionBuilder withType(Object newType)
  {
    type = newType;
    
    return instance;
  }
  
  public static OptionBuilder withDescription(String newDescription)
  {
    description = newDescription;
    
    return instance;
  }
  
  public static Option create(char opt)
    throws IllegalArgumentException
  {
    return create(String.valueOf(opt));
  }
  
  public static Option create()
    throws IllegalArgumentException
  {
    if (longopt == null)
    {
      reset();
      throw new IllegalArgumentException("must specify longopt");
    }
    return create(null);
  }
  
  public static Option create(String opt)
    throws IllegalArgumentException
  {
    Option option = null;
    try
    {
      option = new Option(opt, description);
      
      option.setLongOpt(longopt);
      option.setRequired(required);
      option.setOptionalArg(optionalArg);
      option.setArgs(numberOfArgs);
      option.setType(type);
      option.setValueSeparator(valuesep);
      option.setArgName(argName);
    }
    finally
    {
      reset();
    }
    return option;
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.OptionBuilder
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.io.Serializable;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class OptionGroup
  implements Serializable
{
  private static final long serialVersionUID = 1L;
  private Map optionMap = new HashMap();
  private String selected;
  private boolean required;
  
  public OptionGroup addOption(Option option)
  {
    optionMap.put(option.getKey(), option);
    
    return this;
  }
  
  public Collection getNames()
  {
    return optionMap.keySet();
  }
  
  public Collection getOptions()
  {
    return optionMap.values();
  }
  
  public void setSelected(Option option)
    throws AlreadySelectedException
  {
    if ((selected == null) || (selected.equals(option.getOpt()))) {
      selected = option.getOpt();
    } else {
      throw new AlreadySelectedException(this, option);
    }
  }
  
  public String getSelected()
  {
    return selected;
  }
  
  public void setRequired(boolean required)
  {
    this.required = required;
  }
  
  public boolean isRequired()
  {
    return required;
  }
  
  public String toString()
  {
    StringBuffer buff = new StringBuffer();
    
    Iterator iter = getOptions().iterator();
    
    buff.append("[");
    while (iter.hasNext())
    {
      Option option = (Option)iter.next();
      if (option.getOpt() != null)
      {
        buff.append("-");
        buff.append(option.getOpt());
      }
      else
      {
        buff.append("--");
        buff.append(option.getLongOpt());
      }
      buff.append(" ");
      buff.append(option.getDescription());
      if (iter.hasNext()) {
        buff.append(", ");
      }
    }
    buff.append("]");
    
    return buff.toString();
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.OptionGroup
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class Options
  implements Serializable
{
  private static final long serialVersionUID = 1L;
  private Map shortOpts = new HashMap();
  private Map longOpts = new HashMap();
  private List requiredOpts = new ArrayList();
  private Map optionGroups = new HashMap();
  
  public Options addOptionGroup(OptionGroup group)
  {
    Iterator options = group.getOptions().iterator();
    if (group.isRequired()) {
      requiredOpts.add(group);
    }
    while (options.hasNext())
    {
      Option option = (Option)options.next();
      
      option.setRequired(false);
      addOption(option);
      
      optionGroups.put(option.getKey(), group);
    }
    return this;
  }
  
  Collection getOptionGroups()
  {
    return new HashSet(optionGroups.values());
  }
  
  public Options addOption(String opt, boolean hasArg, String description)
  {
    addOption(opt, null, hasArg, description);
    
    return this;
  }
  
  public Options addOption(String opt, String longOpt, boolean hasArg, String description)
  {
    addOption(new Option(opt, longOpt, hasArg, description));
    
    return this;
  }
  
  public Options addOption(Option opt)
  {
    String key = opt.getKey();
    if (opt.hasLongOpt()) {
      longOpts.put(opt.getLongOpt(), opt);
    }
    if (opt.isRequired())
    {
      if (requiredOpts.contains(key)) {
        requiredOpts.remove(requiredOpts.indexOf(key));
      }
      requiredOpts.add(key);
    }
    shortOpts.put(key, opt);
    
    return this;
  }
  
  public Collection getOptions()
  {
    return Collections.unmodifiableCollection(helpOptions());
  }
  
  List helpOptions()
  {
    return new ArrayList(shortOpts.values());
  }
  
  public List getRequiredOptions()
  {
    return requiredOpts;
  }
  
  public Option getOption(String opt)
  {
    opt = Util.stripLeadingHyphens(opt);
    if (shortOpts.containsKey(opt)) {
      return (Option)shortOpts.get(opt);
    }
    return (Option)longOpts.get(opt);
  }
  
  public boolean hasOption(String opt)
  {
    opt = Util.stripLeadingHyphens(opt);
    
    return (shortOpts.containsKey(opt)) || (longOpts.containsKey(opt));
  }
  
  public OptionGroup getOptionGroup(Option opt)
  {
    return (OptionGroup)optionGroups.get(opt.getKey());
  }
  
  public String toString()
  {
    StringBuffer buf = new StringBuffer();
    
    buf.append("[ Options: [ short ");
    buf.append(shortOpts.toString());
    buf.append(" ] [ long ");
    buf.append(longOpts);
    buf.append(" ]");
    
    return buf.toString();
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.Options
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

class OptionValidator
{
  static void validateOption(String opt)
    throws IllegalArgumentException
  {
    if (opt == null) {
      return;
    }
    if (opt.length() == 1)
    {
      char ch = opt.charAt(0);
      if (!isValidOpt(ch)) {
        throw new IllegalArgumentException("illegal option value '" + ch + "'");
      }
    }
    else
    {
      char[] chars = opt.toCharArray();
      for (int i = 0; i < chars.length; i++) {
        if (!isValidChar(chars[i])) {
          throw new IllegalArgumentException("opt contains illegal character value '" + chars[i] + "'");
        }
      }
    }
  }
  
  private static boolean isValidOpt(char c)
  {
    return (isValidChar(c)) || (c == ' ') || (c == '?') || (c == '@');
  }
  
  private static boolean isValidChar(char c)
  {
    return Character.isJavaIdentifierPart(c);
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.OptionValidator
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

public class ParseException
  extends Exception
{
  public ParseException(String message)
  {
    super(message);
  }
}

/* Location:
 * Qualified Name:     org.apache.commons.cli.ParseException
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.apache.commons.cli;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Properties;

public abstract class Parser
  implements CommandLineParser
{
  protected CommandLine cmd;
  private Options options;
  private List requiredOptions;
  
  protected void setOptions(Options options)
  {
    this.options = options;
    requiredOptions = new ArrayList(options.getRequiredOptions());
  }
  
  protected Options getOptions()
  {
    return options;
  }
  
  protected List getRequiredOptions()
  {
    return requiredOptions;
  }
  
  protected abstract String[] flatten(Options paramOptions, String[] paramArrayOfString, boolean paramBoolean);
  
  public CommandLine parse(Options options, String[] arguments)
    throws ParseException
  {
    return parse(options, arguments, null, false);
  }
  
  public CommandLine parse(Options options, String[] arguments, Properties properties)
    throws ParseException
  {
    return parse(options, arguments, properties, false);
  }
  
  public CommandLine parse(Options options, String[] arguments, boolean stopAtNonOption)
    throws ParseException
  {
    return parse(options, arguments, null, stopAtNonOption);
  }
  
  public CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption)
    throws ParseException
  {
    for (Iterator it = options.helpOptions().iterator(); it.hasNext();)
    {
      Option opt = (Option)it.next();
      opt.clearValues();
    }
    setOptions(options);
    
    cmd = new CommandLine();
    
    boolean eatTheRest = false;
    if (arguments == null) {
      arguments = new String[0];
    }
    List tokenList = Arrays.asList(flatten(getOptions(), arguments, stopAtNonOption));
    
    ListIterator iterator = tokenList.listIterator();
    while (iterator.hasNext())
    {
      String t = (String)iterator.next();
      if ("--".equals