---

Options.java

package gov.nasa.arc.ase.util;

import java.io.*;
import java.lang.reflect.*;
import java.util.*;

public class Options {
  private Hashtable parsers;
  private Hashtable printers;
  private Class mainClass;
  private String defaultParam;
  private boolean multipleParam;

  private String[] args;

  public Options(Class m) {
    init(m, null, true);
  }  
  public Options(Class m, String p) {
    init(m, p, true);
  }  
  public Options(Class m, String p, boolean u) {
    init(m, p, u);
  }  
  public void addParser(String type, String name) {
    Class[] arguments = new Class[1];
    arguments[0] = String.class;
    try {
      parsers.put(type, getClass().getMethod(name, arguments));
    } catch(NoSuchMethodException e) {
      e.printStackTrace();
      System.exit(1);
    }
  }  
  public void addPrinter(String type, String name) {
    Class[] arguments = new Class[1];
    arguments[0] = Object.class;
    try {
      printers.put(type, getClass().getMethod(name, arguments));
    } catch(NoSuchMethodException e) {
      e.printStackTrace();
      System.exit(1);
    }
  }  
  public Class getMainClass() {
    return mainClass;
  }  
  private void init(Class m, String p, boolean u) {
    mainClass = m;
    defaultParam = p;
    multipleParam = u;

    parsers = new Hashtable();
    printers = new Hashtable();
    addParser("java.lang.String", "parseString");
    addParser("int", "parseInt");
    addParser("long", "parseLong");
  }  
  public String[] parse(String[] args) {
    this.args = args;

    boolean allowParameter = defaultParam != null;
    boolean inParams = false;
    Vector params = new Vector();

    for(int i = 0; i < args.length; i++) {
      String arg = args[i];
      if(arg.startsWith("-") && !inParams) {
    boolean found = false;
    Field[] f= getClass().getFields();

    if(arg.equals("--"))
      inParams = found = true;

    for(int j = 0; j < f.length && !found; j++)
      if(Modifier.isPublic(f[j].getModifiers())) {
        String name = f[j].getName().replace('_', '-');
        String type = f[j].getType().getName();

        try {
          if(type.equals("boolean")) {
        if(arg.equals("-" + name)) {
          f[j].setBoolean(this, true);
          found = true;
        }
        if(arg.equals("-no-" + name)) {
          f[j].setBoolean(this, false);
          found = true;
        }
          } else if(arg.equals("-" + name)) {
        String value = null;

        found = true;
        i++;
        if(i != args.length)
          value = args[i];
        Method parser = (Method)parsers.get(type);
        if(parser == null) {
          Debug.println(Debug.ERROR, mainClass.getName() + ": invalid type -- " + type);
          System.exit(1);
        }

        Object[] arguments = new Object[1];
        arguments[0] = value;
        try {
          f[j].set(this, parser.invoke(this, arguments));
        } catch(InvocationTargetException e) {
          if(value == null && e.getTargetException() instanceof IllegalArgumentException) {
            Debug.println(Debug.ERROR, mainClass.getName() + ": option requires an argument -- " + arg);
            System.exit(1);
          }
          e.printStackTrace();
          System.exit(1);
        }
          }
        } catch(IllegalAccessException e) {
          e.printStackTrace();
          System.exit(1);
        }
      }
    if(!found) {
      Debug.println(Debug.ERROR, mainClass.getName() + ": invalid option -- " + arg);
      System.exit(1);
    }
      } else {
    if(!allowParameter) {
      Debug.println(Debug.ERROR, mainClass.getName() + ": invalid parameter -- " + arg);
      System.exit(1);
    } else {
      allowParameter = multipleParam;
      params.addElement(arg);
    }
      }
    }
    String[] stringParams = new String[params.size()];
    for(int i = 0; i < params.size(); i++) {
      stringParams[i] = (String)params.elementAt(i);
    }

    return stringParams;
  }  
  public Object parseInt(String s) {
    if(s == null) throw new IllegalArgumentException();
    return new Integer(Integer.parseInt(s));
  }  
  public Object parseLong(String s) {
    if(s == null) throw new IllegalArgumentException();
    return new Long(Long.parseLong(s));
  }  
  public Object parseString(String s) {
    if(s == null) throw new IllegalArgumentException();
    return s;
  }  
  public void print() {
    Field[] f = getClass().getFields();
    int maxlen = 0;
    for(int i = 0; i < f.length; i++)
      if(Modifier.isPublic(f[i].getModifiers())) {
    int l = f[i].getName().length();
    if(maxlen < l)
      maxlen = l;
      }

    for(int i = 0; i < f.length; i++)
      if(Modifier.isPublic(f[i].getModifiers())) {
    String name = f[i].getName();
    while(name.length() != maxlen)
      name = name + " ";
    Debug.print(Debug.WARNING, name + ": ");
    try {
      Object o = f[i].get(this);
      String type = f[i].getType().getName();
      Method printer = (Method)printers.get(type);
      String s;
      if(o == null)
        s = "null";
      else
        s = o.toString();

      if(printer != null) {
        Object[] arguments = new Object[1];
        arguments[0] = o;
        try {
          s = (String)printer.invoke(this, arguments);
        } catch(InvocationTargetException e) {
        }
      }
      Debug.println(Debug.WARNING, s);
    } catch(IllegalAccessException e) {
      e.printStackTrace();
      System.exit(1);
    }
      }
  }  
  public void print(PrintStream out) {
    Field[] f = getClass().getFields();
    int maxlen = 0;
    for(int i = 0; i < f.length; i++)
      if(Modifier.isPublic(f[i].getModifiers())) {
    int l = f[i].getName().length();
    if(maxlen < l)
      maxlen = l;
      }

    for(int i = 0; i < f.length; i++)
      if(Modifier.isPublic(f[i].getModifiers())) {
    String name = f[i].getName();
    while(name.length() != maxlen)
      name = name + " ";
    out.print(name + ": ");
    try {
      Object o = f[i].get(this);
      String type = f[i].getType().getName();
      Method printer = (Method)printers.get(type);
      String s;
      if(o == null)
        s = "null";
      else
        s = o.toString();

      if(printer != null) {
        Object[] arguments = new Object[1];
        arguments[0] = o;
        try {
          s = (String)printer.invoke(this, arguments);
        } catch(InvocationTargetException e) {
        }
      }
      out.println(s);
    } catch(IllegalAccessException e) {
      e.printStackTrace();
      System.exit(1);
    }
      }
  }  
  public String toString() {
    StringBuffer sb = new StringBuffer();

    for(int i = 0; i < args.length; i++) {
      if(args[i].indexOf(" ") != -1)
    sb.append('"');
      sb.append(args[i]);
      if(args[i].indexOf(" ") != -1)
    sb.append('"');
      sb.append(" ");
    }

    return sb.toString();
  }  
  public void usage() {
    Debug.println(Debug.ERROR, "usage: ");
    Debug.println(Debug.ERROR);

    Debug.print(Debug.ERROR, mainClass.getName() + " ");
    if(defaultParam != null) {
      Debug.print(Debug.ERROR, "<" + defaultParam + ">");
      if(multipleParam)
    Debug.print(Debug.ERROR, " ...");
    }
    Debug.println(Debug.ERROR);

    Field[] f = getClass().getFields();
    for(int i = 0; i < f.length; i++)
      if(Modifier.isPublic(f[i].getModifiers())) {
    String name = f[i].getName().replace('_', '-');
    String type = f[i].getType().getName();

    Debug.print(Debug.ERROR, "\t-" + name);
    if(type.equals("boolean"))
      Debug.print(Debug.ERROR, " | -no-" + name);
    else
      Debug.print(Debug.ERROR, " <" + name + ">");
    Debug.println(Debug.ERROR);
      }
    Debug.println(Debug.ERROR);
    Debug.println(Debug.ERROR,"The default values are:");
    Debug.println(Debug.ERROR,"-----------------------");
    print();
    System.exit(1);
  }  
}

---