بهبود تدریجی

Case Study of a Command-Line Argument Parser

Listing 14-1

public static void main (String[] args)
{
    try
        {
            Args arg = new Args ("l,p#,d*", args);
            boolean logging = arg.getBoolean ('l');
            int port = arg.getInt ('p');
            String directory = arg.getString ('d');
            executeApplication (logging, port, directory);
        }
    catch (ArgsException e)
        {
            System.out.printf ("Argument error: %s\n", e.errorMessage ());
        }
}

Listing 14-2

package com.objectmentor.utilities.args;
import static com.objectmentor.utilities.args.ArgsException.ErrorCode.*;

import java.util.*;
public class Args
{
    private Map<Character, ArgumentMarshaler> marshalers;
    private Set<Character> argsFound;
    private ListIterator<String> currentArgument;
    public Args (String schema, String[] args) throws ArgsException
    {
        marshalers = new HashMap<Character, ArgumentMarshaler> ();
        argsFound = new HashSet<Character> ();
        parseSchema (schema);
        parseArgumentStrings (Arrays.asList (args));
    }
    private void
    parseSchema (String schema) throws ArgsException
    {
        for (String element : schema.split (","))
            if (element.length () > 0)
                parseSchemaElement (element.trim ());
    }
    private void
    parseSchemaElement (String element) throws ArgsException
    {
        char elementId = element.charAt (0);
        String elementTail = element.substring (1);
        validateSchemaElementId (elementId);
        if (elementTail.length () == 0)
            marshalers.put (elementId, new BooleanArgumentMarshaler ());
        else if (elementTail.equals ("*"))
            marshalers.put (elementId, new StringArgumentMarshaler ());
        else if (elementTail.equals ("#"))
            marshalers.put (elementId, new IntegerArgumentMarshaler ());
        else if (elementTail.equals ("##"))
            marshalers.put (elementId, new DoubleArgumentMarshaler ());
        else if (elementTail.equals ("[*]"))
            marshalers.put (elementId, new StringArrayArgumentMarshaler ());
        else
            throw new ArgsException (INVALID_ARGUMENT_FORMAT, elementId,
                                     elementTail);
    }
    private void
    validateSchemaElementId (char elementId) throws ArgsException
    {
        if (!Character.isLetter (elementId))
            throw new ArgsException (INVALID_ARGUMENT_NAME, elementId, null);
    }
    private void
    parseArgumentStrings (List<String> argsList) throws ArgsException
    {
        for (currentArgument = argsList.listIterator ();
             currentArgument.hasNext ();)
            {
                String argString = currentArgument.next ();
                if (argString.startsWith ("-"))
                    {
                        parseArgumentCharacters (argString.substring (1));
                    }
                else
                    {
                        currentArgument.previous ();
                        break;
                    }
            }
    }
    private void
    parseArgumentCharacters (String argChars) throws ArgsException
    {
        for (int i = 0; i < argChars.length (); i++)
            parseArgumentCharacter (argChars.charAt (i));
    }
    private void
    parseArgumentCharacter (char argChar) throws ArgsException
    {
        ArgumentMarshaler m = marshalers.get (argChar);
        if (m == null)
            {
                throw new ArgsException (UNEXPECTED_ARGUMENT, argChar, null);
            }
        else
            {
                argsFound.add (argChar);
                try
                    {
                        m.set (currentArgument);
                    }
                catch (ArgsException e)
                    {
                        e.setErrorArgumentId (argChar);
                        throw e;
                    }
            }
    }
    public boolean
    has (char arg)
    {
        return argsFound.contains (arg);
    }
    public int
    nextArgument ()
    {
        return currentArgument.nextIndex ();
    }
    public boolean
    getBoolean (char arg)
    {
        return BooleanArgumentMarshaler.getValue (marshalers.get (arg));
    }
    public String
    getString (char arg)
    {
        return StringArgumentMarshaler.getValue (marshalers.get (arg));
    }
    public int
    getInt (char arg)
    {
        return IntegerArgumentMarshaler.getValue (marshalers.get (arg));
    }
    public double
    getDouble (char arg)
    {
        return DoubleArgumentMarshaler.getValue (marshalers.get (arg));
    }
    public String[]
    getStringArray (char arg)
    {
        return StringArrayArgumentMarshaler.getValue (marshalers.get (arg));
    }
}

Listing 14-3 - ArgumentMarshaler.java

public interface ArgumentMarshaler
{
    void set (Iterator<String> currentArgument) throws ArgsException;
}

Listing 14-4 - BooleanArgumentMarshaler.java

public class BooleanArgumentMarshaler implements ArgumentMarshaler
{
    private boolean booleanValue = false;
    public void
    set (Iterator<String> currentArgument) throws ArgsException
    {
        booleanValue = true;
    }
    public static boolean
    getValue (ArgumentMarshaler am)
    {
        if (am != null && am instanceof BooleanArgumentMarshaler)
            return ((BooleanArgumentMarshaler)am).booleanValue;
        else
            return false;
    }
}

Listing 14-5 - StringArgumentMarshaler.java

import static com.objectmentor.utilities.args.ArgsException.ErrorCode.*;
public class StringArgumentMarshaler implements ArgumentMarshaler
{
    private String stringValue = "";
    public void
    set (Iterator<String> currentArgument) throws ArgsException
    {
        try
            {
                stringValue = currentArgument.next ();
            }
        catch (NoSuchElementException e)
            {
                throw new ArgsException (MISSING_STRING);
            }
    }
    public static String
    getValue (ArgumentMarshaler am)
    {
        if (am != null && am instanceof StringArgumentMarshaler)
            return ((StringArgumentMarshaler)am).stringValue;
        else
            return "";
    }
}

Listing 14-6 - IntegerArgumentMarshaler.java

import static com.objectmentor.utilities.args.ArgsException.ErrorCode.*;
public class IntegerArgumentMarshaler implements ArgumentMarshaler
{
    private int intValue = 0;
    public void
    set (Iterator<String> currentArgument) throws ArgsException
    {
        String parameter = null;
        try
            {
                parameter = currentArgument.next ();
                intValue = Integer.parseInt (parameter);
            }
        catch (NoSuchElementException e)
            {
                throw new ArgsException (MISSING_INTEGER);
            }
        catch (NumberFormatException e)
            {
                throw new ArgsException (INVALID_INTEGER, parameter);
            }
    }
    public static int
    getValue (ArgumentMarshaler am)
    {
        if (am != null && am instanceof IntegerArgumentMarshaler)
            return ((IntegerArgumentMarshaler)am).intValue;
        else
            return 0;
    }
}

Listing 14-7 - ArgsException.java

import static com.objectmentor.utilities.args.ArgsException.ErrorCode.*;
public class ArgsException extends Exception
{
    private char errorArgumentId = '\0';
    private String errorParameter = null;
    private ErrorCode errorCode = OK;
    public ArgsException () {}
    public ArgsException (String message) { super (message); }
    public ArgsException (ErrorCode errorCode) { this.errorCode = errorCode; }
    public ArgsException (ErrorCode errorCode, String errorParameter)
    {
        this.errorCode = errorCode;
        this.errorParameter = errorParameter;
    }
    public ArgsException (ErrorCode errorCode, char errorArgumentId,
                          String errorParameter)
    {
        this.errorCode = errorCode;
        this.errorParameter = errorParameter;
        this.errorArgumentId = errorArgumentId;
    }
    public char
    getErrorArgumentId ()
    {
        return errorArgumentId;
    }
    public void
    setErrorArgumentId (char errorArgumentId)
    {
        this.errorArgumentId = errorArgumentId;
    }
    public String
    getErrorParameter ()
    {
        return errorParameter;
    }
    public void
    setErrorParameter (String errorParameter)
    {
        this.errorParameter = errorParameter;
    }
    public ErrorCode
    getErrorCode ()
    {
        return errorCode;
    }
    public void
    setErrorCode (ErrorCode errorCode)
    {
        this.errorCode = errorCode;
    }
    public String
    errorMessage ()
    {
        switch (errorCode)
            {
            case OK:
                return "TILT: Should not get here.";
            case UNEXPECTED_ARGUMENT:
                return String.format ("Argument -%c unexpected.",
                                      errorArgumentId);
            case MISSING_STRING:
                return String.format (
                    "Could not find string parameter for -%c.",
                    errorArgumentId);
            case INVALID_INTEGER:
                return String.format (
                    "Argument -%c expects an integer but was '%s'.",
                    errorArgumentId, errorParameter);
            case MISSING_INTEGER:
                return String.format (
                    "Could not find integer parameter for -%c.",
                    errorArgumentId);
            case INVALID_DOUBLE:
                return String.format (
                    "Argument -%c expects a double but was '%s'.",
                    errorArgumentId, errorParameter);
            case MISSING_DOUBLE:
                return String.format (
                    "Could not find double parameter for -%c.",
                    errorArgumentId);
            case INVALID_ARGUMENT_NAME:
                return String.format ("'%c' is not a valid argument name.",
                                      errorArgumentId);
            case INVALID_ARGUMENT_FORMAT:
                return String.format ("'%s' is not a valid argument format.",
                                      errorParameter);
            }
        return "";
    }
    public enum ErrorCode
    {
        OK,
        INVALID_ARGUMENT_FORMAT,
        UNEXPECTED_ARGUMENT,
        INVALID_ARGUMENT_NAME,
        MISSING_STRING,
        MISSING_INTEGER,
        INVALID_INTEGER,
        MISSING_DOUBLE,
        INVALID_DOUBLE
    }
}

Listing 14-8 - Args.java (first draft)

import java.text.ParseException;
import java.util.*;
public class Args
{
    private String schema;
    private String[] args;
    private boolean valid = true;
    private Set<Character> unexpectedArguments = new TreeSet<Character> ();
    private Map<Character, Boolean> booleanArgs
        = new HashMap<Character, Boolean> ();
    private Map<Character, String> stringArgs
        = new HashMap<Character, String> ();
    private Map<Character, Integer> intArgs
        = new HashMap<Character, Integer> ();
    private Set<Character> argsFound = new HashSet<Character> ();
    private int currentArgument;
    private char errorArgumentId = '\0';
    private String errorParameter = "TILT";
    private ErrorCode errorCode = ErrorCode.OK;
    private enum ErrorCode
    {
        OK,
        MISSING_STRING,
        MISSING_INTEGER,
        INVALID_INTEGER,
        UNEXPECTED_ARGUMENT
    }
    public Args (String schema, String[] args) throws ParseException
    {
        this.schema = schema;
        this.args = args;
        valid = parse ();
    }
    private boolean
    parse () throws ParseException
    {
        if (schema.length () == 0 && args.length == 0)
            return true;
        parseSchema ();
        try
            {
                parseArguments ();
            }
        catch (ArgsException e)
            {
            }
        return valid;
    }
    private boolean
    parseSchema () throws ParseException
    {
        for (String element : schema.split (","))
            {
                if (element.length () > 0)
                    {
                        String trimmedElement = element.trim ();
                        parseSchemaElement (trimmedElement);
                    }
            }
        return true;
    }
    private void
    parseSchemaElement (String element) throws ParseException
    {
        char elementId = element.charAt (0);
        String elementTail = element.substring (1);
        validateSchemaElementId (elementId);
        if (isBooleanSchemaElement (elementTail))
            parseBooleanSchemaElement (elementId);
        else if (isStringSchemaElement (elementTail))
            parseStringSchemaElement (elementId);
        else if (isIntegerSchemaElement (elementTail))
            {
                parseIntegerSchemaElement (elementId);
            }
        else
            {
                throw new ParseException (
                    String.format ("Argument: %c has invalid format: %s.",
                                   elementId, elementTail),
                    0);
            }
    }
    private void
    validateSchemaElementId (char elementId) throws ParseException
    {
        if (!Character.isLetter (elementId))
            {
                throw new ParseException ("Bad character:" + elementId
                                              + "in Args format: " + schema,
                                          0);
            }
    }
    private void
    parseBooleanSchemaElement (char elementId)
    {
        booleanArgs.put (elementId, false);
    }
    private void
    parseIntegerSchemaElement (char elementId)
    {
        intArgs.put (elementId, 0);
    }
    private void
    parseStringSchemaElement (char elementId)
    {
        stringArgs.put (elementId, "");
    }
    private boolean
    isStringSchemaElement (String elementTail)
    {
        return elementTail.equals ("*");
    }
    private boolean
    isBooleanSchemaElement (String elementTail)
    {
        return elementTail.length () == 0;
    }
    private boolean
    isIntegerSchemaElement (String elementTail)
    {
        return elementTail.equals ("#");
    }
    private boolean
    parseArguments () throws ArgsException
    {
        for (currentArgument = 0; currentArgument < args.length;
             currentArgument++)
            {
                String arg = args[currentArgument];
                parseArgument (arg);
            }
        return true;
    }
    private void
    parseArgument (String arg) throws ArgsException
    {
        if (arg.startsWith ("-"))
            parseElements (arg);
    }
    private void
    parseElements (String arg) throws ArgsException
    {
        for (int i = 1; i < arg.length (); i++)
            parseElement (arg.charAt (i));
    }
    private void
    parseElement (char argChar) throws ArgsException
    {
        if (setArgument (argChar))
            argsFound.add (argChar);
        else
            {
                unexpectedArguments.add (argChar);
                errorCode = ErrorCode.UNEXPECTED_ARGUMENT;
                valid = false;
            }
    }
    private boolean
    setArgument (char argChar) throws ArgsException
    {
        if (isBooleanArg (argChar))
            setBooleanArg (argChar, true);
        else if (isStringArg (argChar))
            setStringArg (argChar);
        else if (isIntArg (argChar))
            setIntArg (argChar);
        else
            return false;
        return true;
    }
    private boolean
    isIntArg (char argChar)
    {
        return intArgs.containsKey (argChar);
    }
    private void
    setIntArg (char argChar) throws ArgsException
    {
        currentArgument++;
        String parameter = null;
        try
            {
                parameter = args[currentArgument];
                intArgs.put (argChar, new Integer (parameter));
            }
        catch (ArrayIndexOutOfBoundsException e)
            {
                valid = false;
                errorArgumentId = argChar;
                errorCode = ErrorCode.MISSING_INTEGER;
                throw new ArgsException ();
            }
        catch (NumberFormatException e)
            {
                valid = false;
                errorArgumentId = argChar;
                errorParameter = parameter;
                errorCode = ErrorCode.INVALID_INTEGER;
                throw new ArgsException ();
            }
    }
    private void
    setStringArg (char argChar) throws ArgsException
    {
        currentArgument++;
        try
            {
                stringArgs.put (argChar, args[currentArgument]);
            }
        catch (ArrayIndexOutOfBoundsException e)
            {
                valid = false;
                errorArgumentId = argChar;
                errorCode = ErrorCode.MISSING_STRING;
                throw new ArgsException ();
            }
    }
    private boolean
    isStringArg (char argChar)
    {
        return stringArgs.containsKey (argChar);
    }
    private void
    setBooleanArg (char argChar, boolean value)
    {
        booleanArgs.put (argChar, value);
    }
    private boolean
    isBooleanArg (char argChar)
    {
        return booleanArgs.containsKey (argChar);
    }
    public int
    cardinality ()
    {
        return argsFound.size ();
    }
    public String
    usage ()
    {
        if (schema.length () > 0)
            return "-[" + schema + "]";
        else
            return "";
    }
    public String
    errorMessage () throws Exception
    {
        switch (errorCode)
            {
            case OK:
                throw new Exception ("TILT: Should not get here.");
            case UNEXPECTED_ARGUMENT:
                return unexpectedArgumentMessage ();
            case MISSING_STRING:
                return String.format (
                    "Could not find string parameter for -%c.",
                    errorArgumentId);
            case INVALID_INTEGER:
                return String.format (
                    "Argument -%c expects an integer but was '%s'.",
                    errorArgumentId, errorParameter);
            case MISSING_INTEGER:
                return String.format (
                    "Could not find integer parameter for -%c.",
                    errorArgumentId);
            }
        return "";
    }
    private String
    unexpectedArgumentMessage ()
    {
        StringBuffer message = new StringBuffer ("Argument(s) -");
        for (char c : unexpectedArguments)
            {
                message.append (c);
            }
        message.append (" unexpected.");
        return message.toString ();
    }
    private boolean
    falseIfNull (Boolean b)
    {
        return b != null && b;
    }
    private int
    zeroIfNull (Integer i)
    {
        return i == null ? 0 : i;
    }
    private String
    blankIfNull (String s)
    {
        return s == null ? "" : s;
    }
    public String
    getString (char arg)
    {
        return blankIfNull (stringArgs.get (arg));
    }
    public int
    getInt (char arg)
    {
        return zeroIfNull (intArgs.get (arg));
    }
    public boolean
    getBoolean (char arg)
    {
        return falseIfNull (booleanArgs.get (arg));
    }
    public boolean
    has (char arg)
    {
        return argsFound.contains (arg);
    }
    public boolean
    isValid ()
    {
        return valid;
    }
    private class ArgsException extends Exception
    {
    }
}

Listing 14-9 - Args.java (Boolean only)

package com.objectmentor.utilities.getopts;
import java.util.*;
public class Args
{
    private String schema;
    private String[] args;
    private boolean valid;
    private Set<Character> unexpectedArguments = new TreeSet<Character> ();
    private Map<Character, Boolean> booleanArgs
        = new HashMap<Character, Boolean> ();
    private int numberOfArguments = 0;
    public Args (String schema, String[] args)
    {
        this.schema = schema;
        this.args = args;
        valid = parse ();
    }
    public boolean
    isValid ()
    {
        return valid;
    }
    private boolean
    parse ()
    {
        if (schema.length () == 0 && args.length == 0)
            return true;
        parseSchema ();
        parseArguments ();
        return unexpectedArguments.size () == 0;
    }
    private boolean
    parseSchema ()
    {
        for (String element : schema.split (","))
            {
                parseSchemaElement (element);
            }
        return true;
    }
    private void
    parseSchemaElement (String element)
    {
        if (element.length () == 1)
            {
                parseBooleanSchemaElement (element);
            }
    }
    private void
    parseBooleanSchemaElement (String element)
    {
        char c = element.charAt (0);
        if (Character.isLetter (c))
            {
                booleanArgs.put (c, false);
            }
    }
    private boolean
    parseArguments ()
    {
        for (String arg : args)
            parseArgument (arg);
        return true;
    }
    private void
    parseArgument (String arg)
    {
        if (arg.startsWith ("-"))
            parseElements (arg);
    }
    private void
    parseElements (String arg)
    {
        for (int i = 1; i < arg.length (); i++)
            parseElement (arg.charAt (i));
    }
    private void
    parseElement (char argChar)
    {
        if (isBoolean (argChar))
            {
                numberOfArguments++;
                setBooleanArg (argChar, true);
            }
        else
            unexpectedArguments.add (argChar);
    }
    private void
    setBooleanArg (char argChar, boolean value)
    {
        booleanArgs.put (argChar, value);
    }
    private boolean
    isBoolean (char argChar)
    {
        return booleanArgs.containsKey (argChar);
    }
    public int
    cardinality ()
    {
        return numberOfArguments;
    }
    public String
    usage ()
    {
        if (schema.length () > 0)
            return "-[" + schema + "]";
        else
            return "";
    }
    public String
    errorMessage ()
    {
        if (unexpectedArguments.size () > 0)
            {
                return unexpectedArgumentMessage ();
            }
        else
            return "";
    }
    private String
    unexpectedArgumentMessage ()
    {
        StringBuffer message = new StringBuffer ("Argument(s) -");
        for (char c : unexpectedArguments)
            {
                message.append (c);
            }
        message.append (" unexpected.");
        return message.toString ();
    }
    public boolean
    getBoolean (char arg)
    {
        return booleanArgs.get (arg);
    }
}

Listing 14-10 - Args.java (Boolean and String)

package com.objectmentor.utilities.getopts;
import java.text.ParseException;
import java.util.*;
public class Args
{
    private String schema;
    private String[] args;
    private boolean valid = true;
    private Set<Character> unexpectedArguments = new TreeSet<Character> ();
    private Map<Character, Boolean> booleanArgs
        = new HashMap<Character, Boolean> ();
    private Map<Character, String> stringArgs
        = new HashMap<Character, String> ();
    private Set<Character> argsFound = new HashSet<Character> ();
    private int currentArgument;
    private char errorArgument = '\0';
    enum ErrorCode
    {
        OK,
        MISSING_STRING
    }
    private ErrorCode errorCode = ErrorCode.OK;
    public Args (String schema, String[] args) throws ParseException
    {
        this.schema = schema;
        this.args = args;
        valid = parse ();
    }
    private boolean
    parse () throws ParseException
    {
        if (schema.length () == 0 && args.length == 0)
            return true;
        parseSchema ();
        parseArguments ();
        return valid;
    }
    private boolean
    parseSchema () throws ParseException
    {
        for (String element : schema.split (","))
            {
                if (element.length () > 0)
                    {
                        String trimmedElement = element.trim ();
                        parseSchemaElement (trimmedElement);
                    }
            }
        return true;
    }
    private void
    parseSchemaElement (String element) throws ParseException
    {
        char elementId = element.charAt (0);
        String elementTail = element.substring (1);
        validateSchemaElementId (elementId);
        if (isBooleanSchemaElement (elementTail))
            parseBooleanSchemaElement (elementId);
        else if (isStringSchemaElement (elementTail))
            parseStringSchemaElement (elementId);
    }
    private void
    validateSchemaElementId (char elementId) throws ParseException
    {
        if (!Character.isLetter (elementId))
            {
                throw new ParseException ("Bad character:" + elementId
                                              + "in Args format: " + schema,
                                          0);
            }
    }
    private void
    parseStringSchemaElement (char elementId)
    {
        stringArgs.put (elementId, "");
    }
    private boolean
    isStringSchemaElement (String elementTail)
    {
        return elementTail.equals ("*");
    }
    private boolean
    isBooleanSchemaElement (String elementTail)
    {
        return elementTail.length () == 0;
    }
    private void
    parseBooleanSchemaElement (char elementId)
    {
        booleanArgs.put (elementId, false);
    }
    private boolean
    parseArguments ()
    {
        for (currentArgument = 0; currentArgument < args.length;
             currentArgument++)
            {
                String arg = args[currentArgument];
                parseArgument (arg);
            }
        return true;
    }
    private void
    parseArgument (String arg)
    {
        if (arg.startsWith ("-"))
            parseElements (arg);
    }
    private void
    parseElements (String arg)
    {
        for (int i = 1; i < arg.length (); i++)
            parseElement (arg.charAt (i));
    }
    private void
    parseElement (char argChar)
    {
        if (setArgument (argChar))
            argsFound.add (argChar);
        else
            {
                unexpectedArguments.add (argChar);
                valid = false;
            }
    }
    private boolean
    setArgument (char argChar)
    {
        boolean set = true;
        if (isBoolean (argChar))
            setBooleanArg (argChar, true);
        else if (isString (argChar))
            setStringArg (argChar, "");
        else
            set = false;
        return set;
    }
    private void
    setStringArg (char argChar, String s)
    {
        currentArgument++;
        try
            {
                stringArgs.put (argChar, args[currentArgument]);
            }
        catch (ArrayIndexOutOfBoundsException e)
            {
                valid = false;
                errorArgument = argChar;
                errorCode = ErrorCode.MISSING_STRING;
            }
    }
    private boolean
    isString (char argChar)
    {
        return stringArgs.containsKey (argChar);
    }
    private void
    setBooleanArg (char argChar, boolean value)
    {
        booleanArgs.put (argChar, value);
    }
    private boolean
    isBoolean (char argChar)
    {
        return booleanArgs.containsKey (argChar);
    }
    public int
    cardinality ()
    {
        return argsFound.size ();
    }
    public String
    usage ()
    {
        if (schema.length () > 0)
            return "-[" + schema + "]";
        else
            return "";
    }
    public String
    errorMessage () throws Exception
    {
        if (unexpectedArguments.size () > 0)
            {
                return unexpectedArgumentMessage ();
            }
        else
            switch (errorCode)
                {
                case MISSING_STRING:
                    return String.format (
                        "Could not find string parameter for -%c.",
                        errorArgument);
                case OK:
                    throw new Exception ("TILT: Should not get here.");
                }
        return "";
    }
    private String
    unexpectedArgumentMessage ()
    {
        StringBuffer message = new StringBuffer ("Argument(s) -");
        for (char c : unexpectedArguments)
            {
                message.append (c);
            }
        message.append (" unexpected.");
        return message.toString ();
    }
    public boolean
    getBoolean (char arg)
    {
        return falseIfNull (booleanArgs.get (arg));
    }
    private boolean
    falseIfNull (Boolean b)
    {
        return b == null ? false : b;
    }
    public String
    getString (char arg)
    {
        return blankIfNull (stringArgs.get (arg));
    }
    private String
    blankIfNull (String s)
    {
        return s == null ? "" : s;
    }
    public boolean
    has (char arg)
    {
        return argsFound.contains (arg);
    }
    public boolean
    isValid ()
    {
        return valid;
    }
}

Listing 14-11 - ArgumentMarshaller appended to Args.java

private class ArgumentMarshaler
{
    private boolean booleanValue = false;
    public void setBoolean(boolean value) { booleanValue = value; }
    public boolean getBoolean() { return booleanValue; }
}
private class BooleanArgumentMarshaler extends ArgumentMarshaler
{}
private class StringArgumentMarshaler extends ArgumentMarshaler
{}
private class IntegerArgumentMarshaler extends ArgumentMarshaler
{}
}

private Map<Character, ArgumentMarshaler> booleanArgs = 
    new HashMap<Character, ArgumentMarshaler>();

...
private void parseBooleanSchemaElement(char elementId) 
{
   booleanArgs.put(elementId, new BooleanArgumentMarshaler());
}
...

private void setBooleanArg(char argChar, boolean value) {
   booleanArgs.get(argChar).setBoolean(value);
}
...

public boolean getBoolean(char arg) {
   return falseIfNull(booleanArgs.get(arg).getBoolean());
}

public boolean getBoolean(char arg) 
{
    return booleanArgs.get(arg).getBoolean();
}

public boolean getBoolean(char arg)
{
   Args.ArgumentMarshaler am = booleanArgs.get(arg);
   return am.getBoolean();
}

public boolean getBoolean(char arg) 
{
   Args.ArgumentMarshaler am = booleanArgs.get(arg);
   return am != null && am.getBoolean();
}

private Map<Character, ArgumentMarshaler> stringArgs
    = new HashMap<Character, ArgumentMarshaler> ();
... 

private void parseStringSchemaElement (char elementId)
{
    stringArgs.put (elementId, new StringArgumentMarshaler ());
}
... 

private void setStringArg (char argChar) throws ArgsException
{
    currentArgument++;
    try
        {
            stringArgs.get (argChar).setString (args[currentArgument]);
        }
    catch (ArrayIndexOutOfBoundsException e)
        {
            valid = false;
            errorArgumentId = argChar;
            errorCode = ErrorCode.MISSING_STRING;
            throw new ArgsException ();
        }
}
... 

public String getString (char arg)
{
    Args.ArgumentMarshaler am = stringArgs.get (arg);
    return am == null ? "" : am.getString ();
}
...

private class ArgumentMarshaler
{
    private boolean booleanValue = false;
    private String stringValue;

    public void setBoolean (boolean value)
    {
        booleanValue = value;
    }
    public boolean getBoolean ()
    {
        return booleanValue;
    }
    public void setString (String s)
    {
        stringValue = s;
    }
    public String getString ()
    {
        return stringValue == null ? "" : stringValue;
    }
}

private Map<Character, ArgumentMarshaler> intArgs
    = new HashMap<Character, ArgumentMarshaler> ();

private void parseIntegerSchemaElement (char elementId)
{
    intArgs.put (elementId, new IntegerArgumentMarshaler ());
}
...

private void setIntArg (char argChar) throws ArgsException
{
    currentArgument++;
    String parameter = null;
    try
        {
            parameter = args[currentArgument];
            intArgs.get (argChar).setInteger (Integer.parseInt (parameter));
        }
    catch (ArrayIndexOutOfBoundsException e)
        {
            valid = false;
            errorArgumentId = argChar;
            errorCode = ErrorCode.MISSING_INTEGER;
            throw new ArgsException ();
        }
    catch (NumberFormatException e)
        {
            valid = false;
            errorArgumentId = argChar;
            errorParameter = parameter;
            errorCode = ErrorCode.INVALID_INTEGER;
            throw new ArgsException ();
        }
}
...

public int getInt (char arg)
{
    Args.ArgumentMarshaler am = intArgs.get (arg);
    return am == null ? 0 : am.getInteger ();
}
...

private class ArgumentMarshaler
{
    private boolean booleanValue = false;
    private String stringValue;
    private int integerValue;
    public void setBoolean (boolean value)
    {
        booleanValue = value;
    }
    public boolean getBoolean ()
    {
        return booleanValue;
    }
    public void setString (String s)
    {
        stringValue = s;
    }
    public String getString ()
    {
        return stringValue == null ? "" : stringValue;
    }
    public void setInteger (int i)
    {
        integerValue = i;
    }
    public int getInteger ()
    {
        return integerValue;
    }
}

private abstract class ArgumentMarshaler {
    protected boolean booleanValue = false;
    private String stringValue;
    private int integerValue;
    public void setBoolean(boolean value) {
        booleanValue = value;
    }
    public boolean getBoolean() {
        return booleanValue;
    }
    public void setString(String s) {
    stringValue = s;
    }
    public String getString() {
        return stringValue == null ? "" : stringValue;
    }
    public void setInteger(int i) {
        integerValue = i;
    }
    public int getInteger() {
        return integerValue;
    }
    public abstract void set(String s);
}

private class BooleanArgumentMarshaler extends ArgumentMarshaler {
    public void set(String s) {
        booleanValue = true;
    }
}

private void setBooleanArg(char argChar, boolean value) {
    booleanArgs.get(argChar).set("true");
}

public boolean getBoolean(char arg) {
    Args.ArgumentMarshaler am = booleanArgs.get(arg);
    return am != null && (Boolean) am.get();
}

private abstract class ArgumentMarshaler {
    ...
    public Object get() {
        return null;
    }
}

private abstract class ArgumentMarshaler {
    ...
    public abstract Object get();
}

private class BooleanArgumentMarshaler extends ArgumentMarshaler {
    private boolean booleanValue = false;

    public void set(String s) {
        booleanValue = true;
    }

    public Object get() {
        return booleanValue;
    }
}

private void setStringArg(char argChar) throws ArgsException {
    currentArgument++;
    try {
        stringArgs.get(argChar).set(args[currentArgument]);
    } catch (ArrayIndexOutOfBoundsException e) {
        valid = false;
        errorArgumentId = argChar;
        errorCode = ErrorCode.MISSING_STRING;
        throw new ArgsException();
    }
}
... 
public String getString(char arg) {
    Args.ArgumentMarshaler am = stringArgs.get(arg);
    return am == null ? "" : (String) am.get();
}
... 
private abstract class ArgumentMarshaler {
    private int integerValue;
    public void setInteger(int i) {
        integerValue = i;
    }
    public int getInteger() {
        return integerValue;
    }
    public abstract void set(String s);
    public abstract Object get();
}
private class BooleanArgumentMarshaler extends ArgumentMarshaler {
    private boolean booleanValue = false;
    public void set(String s) {
        booleanValue = true;
    }
    public Object get() {
        return booleanValue;
    }
}
private class StringArgumentMarshaler extends ArgumentMarshaler {
    private String stringValue = "";
    public void set(String s) {
        stringValue = s;
    }
    public Object get() {
        return stringValue;
    }
}
private class IntegerArgumentMarshaler extends ArgumentMarshaler {
    public void set(String s) {}
    public Object get() {
        return null;
    }
}

private boolean isIntArg(char argChar) {
    return intArgs.containsKey(argChar);
}
private void setIntArg(char argChar) throws ArgsException {
    currentArgument++;
    String parameter = null;
    try {
        parameter = args[currentArgument];
        intArgs.get(argChar).set(parameter);
    } catch (ArrayIndexOutOfBoundsException e) {
        valid = false;
        errorArgumentId = argChar;
        errorCode = ErrorCode.MISSING_INTEGER;
        throw new ArgsException();
    } catch (ArgsException e) {
        valid = false;
        errorArgumentId = argChar;
        errorParameter = parameter;
        errorCode = ErrorCode.INVALID_INTEGER;
        throw e;
    }
}
... private void setBooleanArg(char argChar) {
    try {
        booleanArgs.get(argChar).set("true");
    } catch (ArgsException e) {
    }
}
... public int getInt(char arg) {
    Args.ArgumentMarshaler am = intArgs.get(arg);
    return am == null ? 0 : (Integer) am.get();
}
... private abstract class ArgumentMarshaler {
    public abstract void set(String s) throws ArgsException;
    public abstract Object get();
}
... private class IntegerArgumentMarshaler extends ArgumentMarshaler {
    private int intValue = 0;
    public void set(String s) throws ArgsException {
        try {
            intValue = Integer.parseInt(s);
        } catch (NumberFormatException e) {
            throw new ArgsException();
        }
    }
    public Object get() {
        return intValue;
    }
}

public class Args {
    ... private Map<Character, ArgumentMarshaler> booleanArgs =
        new HashMap<Character, ArgumentMarshaler>();
    private Map<Character, ArgumentMarshaler> stringArgs =
        new HashMap<Character, ArgumentMarshaler>();
    private Map<Character, ArgumentMarshaler> intArgs =
        new HashMap<Character, ArgumentMarshaler>();
    private Map<Character, ArgumentMarshaler> marshalers =
        new HashMap<Character, ArgumentMarshaler>();
    ... private void parseBooleanSchemaElement(char elementId) {
        ArgumentMarshaler m = new BooleanArgumentMarshaler();
        booleanArgs.put(elementId, m);
        marshalers.put(elementId, m);
    }
    private void parseIntegerSchemaElement(char elementId) {
        ArgumentMarshaler m = new IntegerArgumentMarshaler();
        intArgs.put(elementId, m);
        marshalers.put(elementId, m);
    }
    private void parseStringSchemaElement(char elementId) {
        ArgumentMarshaler m = new StringArgumentMarshaler();
        stringArgs.put(elementId, m);
        marshalers.put(elementId, m);
    }
}

private boolean isBooleanArg(char argChar) {
   return booleanArgs.containsKey(argChar);
}

private boolean isBooleanArg(char argChar) {
    ArgumentMarshaler m = marshalers.get(argChar);
    return m instanceof BooleanArgumentMarshaler;
}

private boolean isIntArg(char argChar) {
    ArgumentMarshaler m = marshalers.get(argChar);
    return m instanceof IntegerArgumentMarshaler;
}
private boolean isStringArg(char argChar) {
    ArgumentMarshaler m = marshalers.get(argChar);
    return m instanceof StringArgumentMarshaler;
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (isBooleanArg(m))
        setBooleanArg(argChar);
    else if (isStringArg(m))
        setStringArg(argChar);
    else if (isIntArg(m))
        setIntArg(argChar);
    else
        return false;
    return true;
}
private boolean isIntArg(ArgumentMarshaler m) {
    return m instanceof IntegerArgumentMarshaler;
}
private boolean isStringArg(ArgumentMarshaler m) {
    return m instanceof StringArgumentMarshaler;
}
private boolean isBooleanArg(ArgumentMarshaler m) {
    return m instanceof BooleanArgumentMarshaler;
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (m instanceof BooleanArgumentMarshaler)
        setBooleanArg(argChar);
    else if (m instanceof StringArgumentMarshaler)
        setStringArg(argChar);
    else if (m instanceof IntegerArgumentMarshaler)
        setIntArg(argChar);
    else
        return false;
    return true;
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (m instanceof BooleanArgumentMarshaler)
        setBooleanArg(m);
    else if (m instanceof StringArgumentMarshaler)
        setStringArg(argChar);
    else if (m instanceof IntegerArgumentMarshaler)
        setIntArg(argChar);
    else
        return false;
    return true;
}
...
private void setBooleanArg(ArgumentMarshaler m) {
    try {
        m.set("true"); // was: booleanArgs.get(argChar).set("true");
    } 
    catch (ArgsException e) {}
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    try {
        if (m instanceof BooleanArgumentMarshaler)
            setBooleanArg(m);
        else if (m instanceof StringArgumentMarshaler)
            setStringArg(m);
        else if (m instanceof IntegerArgumentMarshaler)
            setIntArg(m);
        else
            return false;
    } catch (ArgsException e) {
        valid = false;
        errorArgumentId = argChar;
        throw e;
    }
    return true;
}
private void setIntArg(ArgumentMarshaler m) throws ArgsException {
    currentArgument++;
    String parameter = null;
    try {
        parameter = args[currentArgument];
        m.set(parameter);
    } catch (ArrayIndexOutOfBoundsException e) {
        errorCode = ErrorCode.MISSING_INTEGER;
        throw new ArgsException();
    } catch (ArgsException e) {
        errorParameter = parameter;
        errorCode = ErrorCode.INVALID_INTEGER;
        throw e;
    }
}
private void setStringArg(ArgumentMarshaler m) throws ArgsException {
    currentArgument++;
    try {
        m.set(args[currentArgument]);
    } catch (ArrayIndexOutOfBoundsException e) {
        errorCode = ErrorCode.MISSING_STRING;
        throw new ArgsException();
    }
}

public boolean getBoolean(char arg) {
    Args.ArgumentMarshaler am = booleanArgs.get(arg);
    return am != null && (Boolean) am.get();
}

public boolean getBoolean(char arg) {
    Args.ArgumentMarshaler am = marshalers.get(arg);
    boolean b = false;
    try {
        b = am != null && (Boolean) am.get();
    } catch (ClassCastException e) {
        b = false;
    }
    return b;
}

private void parseBooleanSchemaElement(char elementId) {
    ArgumentMarshaler m = new BooleanArgumentMarshaler();
    //booleanArgs.put(elementId, m);
    marshalers.put(elementId, m);
}

public class Args {
    ...
    //private Map<Character, ArgumentMarshaler> booleanArgs =
        //new HashMap<Character, ArgumentMarshaler>();
    private Map<Character, ArgumentMarshaler> stringArgs =
        new HashMap<Character, ArgumentMarshaler>();
    private Map<Character, ArgumentMarshaler> intArgs =
        new HashMap<Character, ArgumentMarshaler>();
    private Map<Character, ArgumentMarshaler> marshalers =
        new HashMap<Character, ArgumentMarshaler>();
    ...

private void parseBooleanSchemaElement(char elementId) {
    marshalers.put(elementId, new BooleanArgumentMarshaler());
}
private void parseIntegerSchemaElement(char elementId) {
    marshalers.put(elementId, new IntegerArgumentMarshaler());
}
private void parseStringSchemaElement(char elementId) {
    marshalers.put(elementId, new StringArgumentMarshaler());
}
... 
public String getString(char arg) {
    Args.ArgumentMarshaler am = marshalers.get(arg);
    try {
        return am == null ? "" : (String) am.get();
    } catch (ClassCastException e) {
        return "";
    }
}
public int getInt(char arg) {
    Args.ArgumentMarshaler am = marshalers.get(arg);
    try {
        return am == null ? 0 : (Integer) am.get();
    } catch (Exception e) {
        return 0;
    }
}
...
public class Args {
    ... 
    //private Map<Character, ArgumentMarshaler> stringArgs =
        //new HashMap<Character, ArgumentMarshaler>();
    //private Map<Character, ArgumentMarshaler> intArgs =
        //new HashMap<Character, ArgumentMarshaler>();
    private Map<Character, ArgumentMarshaler> marshalers =
        new HashMap<Character, ArgumentMarshaler>();
    ...
}

private void parseSchemaElement(String element) throws ParseException {
    char elementId = element.charAt(0);
    String elementTail = element.substring(1);
    validateSchemaElementId(elementId);
    if (isBooleanSchemaElement(elementTail))
        marshalers.put(elementId, new BooleanArgumentMarshaler());
    else if (isStringSchemaElement(elementTail))
        marshalers.put(elementId, new StringArgumentMarshaler());
    else if (isIntegerSchemaElement(elementTail)) {
        marshalers.put(elementId, new IntegerArgumentMarshaler());
    } else {
        throw new ParseException(
            String.format(
                "Argument: %c has invalid format: %s.", elementId, elementTail),
            0);
    }
}

Listing 14-12 - Args.java (After first refactoring)

package com.objectmentor.utilities.getopts;
import java.text.ParseException;
import java.util.*;
public class Args {
    private String schema;
    private String[] args;
    private boolean valid = true;
    private Set<Character> unexpectedArguments = new TreeSet<Character>();
    private Map<Character, ArgumentMarshaler> marshalers =
        new HashMap<Character, ArgumentMarshaler>();
    private Set<Character> argsFound = new HashSet<Character>();
    private int currentArgument;
    private char errorArgumentId = '\0';
    private String errorParameter = "TILT";
    private ErrorCode errorCode = ErrorCode.OK;
    private enum ErrorCode {
        OK,
        MISSING_STRING,
        MISSING_INTEGER,
        INVALID_INTEGER,
        UNEXPECTED_ARGUMENT
    }
    public Args(String schema, String[] args) throws ParseException {
        this.schema = schema;
        this.args = args;
        valid = parse();
    }
    private boolean parse() throws ParseException {
        if (schema.length() == 0 && args.length == 0)
            return true;
        parseSchema();
        try {
            parseArguments();
        } catch (ArgsException e) {
        }
        return valid;
    }
    private boolean parseSchema() throws ParseException {
        for (String element : schema.split(",")) {
            if (element.length() > 0) {
                String trimmedElement = element.trim();
                parseSchemaElement(trimmedElement);
            }
        }
        return true;
    }
    private void parseSchemaElement(String element) throws ParseException {
        char elementId = element.charAt(0);
        String elementTail = element.substring(1);
        validateSchemaElementId(elementId);
        if (isBooleanSchemaElement(elementTail))
            marshalers.put(elementId, new BooleanArgumentMarshaler());
        else if (isStringSchemaElement(elementTail))
            marshalers.put(elementId, new StringArgumentMarshaler());
        else if (isIntegerSchemaElement(elementTail)) {
            marshalers.put(elementId, new IntegerArgumentMarshaler());
        } else {
            throw new ParseException(
                String.format("Argument: %c has invalid format: %s.", elementId,
                    elementTail),
                0);
        }
    }
    private void validateSchemaElementId(char elementId) throws ParseException {
        if (!Character.isLetter(elementId)) {
            throw new ParseException(
                "Bad character:" + elementId + "in Args format: " + schema, 0);
        }
    }
    private boolean isStringSchemaElement(String elementTail) {
        return elementTail.equals("*");
    }
    private boolean isBooleanSchemaElement(String elementTail) {
        return elementTail.length() == 0;
    }
    private boolean isIntegerSchemaElement(String elementTail) {
        return elementTail.equals("#");
    }
    private boolean parseArguments() throws ArgsException {
        for (currentArgument = 0; currentArgument < args.length;
             currentArgument++) {
            String arg = args[currentArgument];
            parseArgument(arg);
        }
        return true;
    }
    private void parseArgument(String arg) throws ArgsException {
        if (arg.startsWith("-"))
            parseElements(arg);
    }
    private void parseElements(String arg) throws ArgsException {
        for (int i = 1; i < arg.length(); i++) parseElement(arg.charAt(i));
    }
    private void parseElement(char argChar) throws ArgsException {
        if (setArgument(argChar))
            argsFound.add(argChar);
        else {
            unexpectedArguments.add(argChar);
            errorCode = ErrorCode.UNEXPECTED_ARGUMENT;
            valid = false;
        }
    }
    private boolean setArgument(char argChar) throws ArgsException {
        ArgumentMarshaler m = marshalers.get(argChar);
        try {
            if (m instanceof BooleanArgumentMarshaler)
                setBooleanArg(m);
            else if (m instanceof StringArgumentMarshaler)
                setStringArg(m);
            else if (m instanceof IntegerArgumentMarshaler)
                setIntArg(m);
            else
                return false;
        } catch (ArgsException e) {
            valid = false;
            errorArgumentId = argChar;
            throw e;
        }
        return true;
    }
    private void setIntArg(ArgumentMarshaler m) throws ArgsException {
        currentArgument++;
        String parameter = null;
        try {
            parameter = args[currentArgument];
            m.set(parameter);
        } catch (ArrayIndexOutOfBoundsException e) {
            errorCode = ErrorCode.MISSING_INTEGER;
            throw new ArgsException();
        } catch (ArgsException e) {
            errorParameter = parameter;
            errorCode = ErrorCode.INVALID_INTEGER;
            throw e;
        }
    }
    private void setStringArg(ArgumentMarshaler m) throws ArgsException {
        currentArgument++;
        try {
            m.set(args[currentArgument]);
        } catch (ArrayIndexOutOfBoundsException e) {
            errorCode = ErrorCode.MISSING_STRING;
            throw new ArgsException();
        }
    }
    private void setBooleanArg(ArgumentMarshaler m) {
        try {
            m.set("true");
        } catch (ArgsException e) {
        }
    }
    public int cardinality() {
        return argsFound.size();
    }
    public String usage() {
        if (schema.length() > 0)
            return "-[" + schema + "]";
        else
            return "";
    }
    public String errorMessage() throws Exception {
        switch (errorCode) {
            case OK:
                throw new Exception("TILT: Should not get here.");
            case UNEXPECTED_ARGUMENT:
                return unexpectedArgumentMessage();
            case MISSING_STRING:
                return String.format("Could not find string parameter for -%c.",
                    errorArgumentId);
            case INVALID_INTEGER:
                return String.format(
                    "Argument -%c expects an integer but was '%s'.",
                    errorArgumentId, errorParameter);
            case MISSING_INTEGER:
                return String.format(
                    "Could not find integer parameter for -%c.",
                    errorArgumentId);
        }
        return "";
    }
    private String unexpectedArgumentMessage() {
        StringBuffer message = new StringBuffer("Argument(s) -");
        for (char c : unexpectedArguments) {
            message.append(c);
        }
        message.append(" unexpected.");
        return message.toString();
    }
    public boolean getBoolean(char arg) {
        Args.ArgumentMarshaler am = marshalers.get(arg);
        boolean b = false;
        try {
            b = am != null && (Boolean) am.get();
        } catch (ClassCastException e) {
            b = false;
        }
        return b;
    }
    public String getString(char arg) {
        Args.ArgumentMarshaler am = marshalers.get(arg);
        try {
            return am == null ? "" : (String) am.get();
        } catch (ClassCastException e) {
            return "";
        }
    }
    public int getInt(char arg) {
        Args.ArgumentMarshaler am = marshalers.get(arg);
        try {
            return am == null ? 0 : (Integer) am.get();
        } catch (Exception e) {
            return 0;
        }
    }
    public boolean has(char arg) {
        return argsFound.contains(arg);
    }
    public boolean isValid() {
        return valid;
    }
    private class ArgsException extends Exception {}
    private abstract class ArgumentMarshaler {
        public abstract void set(String s) throws ArgsException;
        public abstract Object get();
    }
    private class BooleanArgumentMarshaler extends ArgumentMarshaler {
        private boolean booleanValue = false;
        public void set(String s) {
            booleanValue = true;
        }
        public Object get() {
            return booleanValue;
        }
    }
    private class StringArgumentMarshaler extends ArgumentMarshaler {
        private String stringValue = "";
        public void set(String s) {
            stringValue = s;
        }
        public Object get() {
            return stringValue;
        }
    }
    private class IntegerArgumentMarshaler extends ArgumentMarshaler {
        private int intValue = 0;
        public void set(String s) throws ArgsException {
            try {
                intValue = Integer.parseInt(s);
            } catch (NumberFormatException e) {
                throw new ArgsException();
            }
        }
        public Object get() {
            return intValue;
        }
    }
}

public class Args {
    private String schema;
    //private String[] args;
    private boolean valid = true;
    private Set<Character> unexpectedArguments = new TreeSet<Character>();
    private Map<Character, ArgumentMarshaler> marshalers =
        new HashMap<Character, ArgumentMarshaler>();
    private Set<Character> argsFound = new HashSet<Character>();
    private Iterator<String> currentArgument;
    private char errorArgumentId = '\0';
    private String errorParameter = "TILT";
    private ErrorCode errorCode = ErrorCode.OK;
    private List<String> argsList;
    private enum ErrorCode {
        OK,
        MISSING_STRING,
        MISSING_INTEGER,
        INVALID_INTEGER,
        UNEXPECTED_ARGUMENT
    }
    public Args(String schema, String[] args) throws ParseException {
        this.schema = schema;
        argsList = Arrays.asList(args);
        valid = parse();
    }
    private boolean parse() throws ParseException {
        if (schema.length() == 0 && argsList.size() == 0)
            return true;
        parseSchema();
        try {
            parseArguments();
        } catch (ArgsException e) {
        }
        return valid;
    }
    -- -private boolean parseArguments() throws ArgsException {
        for (currentArgument = argsList.iterator();
             currentArgument.hasNext();) {
            String arg = currentArgument.next();
            parseArgument(arg);
        }
        return true;
    }
    -- -private void setIntArg(ArgumentMarshaler m) throws ArgsException {
        String parameter = null;
        try {
            parameter = currentArgument.next();
            m.set(parameter);
        } catch (NoSuchElementException e) {
            errorCode = ErrorCode.MISSING_INTEGER;
            throw new ArgsException();
        } catch (ArgsException e) {
            errorParameter = parameter;
            errorCode = ErrorCode.INVALID_INTEGER;
            throw e;
        }
    }
    private void setStringArg(ArgumentMarshaler m) throws ArgsException {
        try {
            m.set(currentArgument.next());
        } catch (NoSuchElementException e) {
            errorCode = ErrorCode.MISSING_STRING;
            throw new ArgsException();
        }
    }
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (m == null)
        return false;
    try {
        if (m instanceof BooleanArgumentMarshaler)
            setBooleanArg(m);
        else if (m instanceof StringArgumentMarshaler)
            setStringArg(m);
        else if (m instanceof IntegerArgumentMarshaler)
            setIntArg(m);
        //else
            //return false;
    } catch (ArgsException e) {
        valid = false;
        errorArgumentId = argChar;
        throw e;
    }
    return true;
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (m == null)
        return false;
    try {
        if (m instanceof BooleanArgumentMarshaler)
            setBooleanArg(m, currentArgument);
        else if (m instanceof StringArgumentMarshaler)
            setStringArg(m);
        else if (m instanceof IntegerArgumentMarshaler)
            setIntArg(m);
    } catch (ArgsException e) {
        valid = false;
        errorArgumentId = argChar;
        throw e;
    }
    return true;
}
---
private void setBooleanArg(ArgumentMarshaler m,
    Iterator<String> currentArgument) throws ArgsException {
    //try {
        m.set("true");
    //    catch (ArgsException e) {
    //    }
    }

private abstract class ArgumentMarshaler {
    public abstract void set(Iterator<String> currentArgument)
        throws ArgsException;
    public abstract void set(String s) throws ArgsException;
    public abstract Object get();
}

private class BooleanArgumentMarshaler extends ArgumentMarshaler {
    private boolean booleanValue = false;
    public void set(Iterator<String> currentArgument) throws ArgsException {
        // booleanValue = true;
    }
    public void set(String s) {
        booleanValue = true;
    }
    public Object get() {
        return booleanValue;
    }
}
private class StringArgumentMarshaler extends ArgumentMarshaler {
    private String stringValue = "";
    public void set(Iterator<String> currentArgument) throws ArgsException {}
    public void set(String s) {
        stringValue = s;
    }
    public Object get() {
        return stringValue;
    }
}
private class IntegerArgumentMarshaler extends ArgumentMarshaler {
    private int intValue = 0;
    public void set(Iterator<String> currentArgument) throws ArgsException {}
    public void set(String s) throws ArgsException {
        try {
            intValue = Integer.parseInt(s);
        } catch (NumberFormatException e) {
            throw new ArgsException();
        }
    }
    public Object get() {
        return intValue;
    }
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (m == null)
        return false;
    try {
        if (m instanceof BooleanArgumentMarshaler)
            m.set(currentArgument);
        else if (m instanceof StringArgumentMarshaler)
            setStringArg(m);
        else if (m instanceof IntegerArgumentMarshaler)
            setIntArg(m);
    } catch (ArgsException e) {
        valid = false;
        errorArgumentId = argChar;
        throw e;
    }
    return true;
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (m == null)
        return false;
    try {
        if (m instanceof BooleanArgumentMarshaler)
            m.set(currentArgument);
        else if (m instanceof StringArgumentMarshaler)
            m.set(currentArgument);
        else if (m instanceof IntegerArgumentMarshaler)
            m.set(currentArgument);
    } catch (ArgsException e) {
        valid = false;
        errorArgumentId = argChar;
        throw e;
    }
    return true;
}
---
private class StringArgumentMarshaler extends ArgumentMarshaler {
    private String stringValue = "";
    public void set(Iterator<String> currentArgument) throws ArgsException {
        try {
            stringValue = currentArgument.next();
        } catch (NoSuchElementException e) {
            errorCode = ErrorCode.MISSING_STRING;
            throw new ArgsException();
        }
    }
    public void set(String s) {}
    public Object get() {
        return stringValue;
    }
}
private class IntegerArgumentMarshaler extends ArgumentMarshaler {
    private int intValue = 0;
    public void set(Iterator<String> currentArgument) throws ArgsException {
        String parameter = null;
        try {
            parameter = currentArgument.next();
            set(parameter);
        } catch (NoSuchElementException e) {
            errorCode = ErrorCode.MISSING_INTEGER;
            throw new ArgsException();
        } catch (ArgsException e) {
            errorParameter = parameter;
            errorCode = ErrorCode.INVALID_INTEGER;
            throw e;
        }
    }
    public void set(String s) throws ArgsException {
        try {
            intValue = Integer.parseInt(s);
        } catch (NumberFormatException e) {
            throw new ArgsException();
        }
    }
    public Object get() {
        return intValue;
    }
}

private boolean setArgument(char argChar) throws ArgsException {
    ArgumentMarshaler m = marshalers.get(argChar);
    if (m == null)
        return false;
    try {
        m.set(currentArgument);
        return true;
    } catch (ArgsException e) {
        valid = false;
        errorArgumentId = argChar;
        throw e;
    }
}

private class IntegerArgumentMarshaler extends ArgumentMarshaler {
    private int intValue = 0 public void set(Iterator<String> currentArgument)
        throws ArgsException {
        String parameter = null;
        try {
            parameter = currentArgument.next();
            intValue = Integer.parseInt(parameter);
        } catch (NoSuchElementException e) {
            errorCode = ErrorCode.MISSING_INTEGER;
            throw new ArgsException();
        } catch (NumberFormatException e) {
            errorParameter = parameter;
            errorCode = ErrorCode.INVALID_INTEGER;
            throw new ArgsException();
        }
    }
    public Object get() {
        return intValue;
    }
}

private interface ArgumentMarshaler {
    void set(Iterator<String> currentArgument) throws ArgsException;
    Object get();
}

public void testSimpleDoublePresent() throws Exception {
    Args args = new Args("x##", new String[] {"-x","42.3"});
    assertTrue(args.isValid());
    assertEquals(1, args.cardinality());
    assertTrue(args.has('x'));
    assertEquals(42.3, args.getDouble('x'), .001);
}

private void parseSchemaElement(String element) throws ParseException {
    char elementId = element.charAt(0);
    String elementTail = element.substring(1);
    validateSchemaElementId(elementId);
    if (elementTail.length() == 0)
        marshalers.put(elementId, new BooleanArgumentMarshaler());
    else if (elementTail.equals("*"))
        marshalers.put(elementId, new StringArgumentMarshaler());
    else if (elementTail.equals("#"))
        marshalers.put(elementId, new IntegerArgumentMarshaler());
    else if (elementTail.equals("##"))
        marshalers.put(elementId, new DoubleArgumentMarshaler());
    else
        throw new ParseException(
            String.format(
                "Argument: %c has invalid format: %s.", elementId, elementTail),
            0);
}

private class DoubleArgumentMarshaler implements ArgumentMarshaler {
    private double doubleValue = 0;
    public void set(Iterator<String> currentArgument) throws ArgsException {
        String parameter = null;
        try {
            parameter = currentArgument.next();
            doubleValue = Double.parseDouble(parameter);
        } catch (NoSuchElementException e) {
            errorCode = ErrorCode.MISSING_DOUBLE;
            throw new ArgsException();
        } catch (NumberFormatException e) {
            errorParameter = parameter;
            errorCode = ErrorCode.INVALID_DOUBLE;
            throw new ArgsException();
        }
    }
    public Object get() {
        return doubleValue;
    }
}

private enum ErrorCode {
    OK,
    MISSING_STRING,
    MISSING_INTEGER,
    INVALID_INTEGER,
    UNEXPECTED_ARGUMENT,

    MISSING_DOUBLE,
    INVALID_DOUBLE
}

public double getDouble(char arg) {
    Args.ArgumentMarshaler am = marshalers.get(arg);
    try {
        return am == null ? 0 : (Double) am.get();
    } catch (Exception e) {
        return 0.0;
    }
}

public void testInvalidDouble() throws Exception {
    Args args = new Args("x##", new String[] {"-x", "Forty two"});
    assertFalse(args.isValid());
    assertEquals(0, args.cardinality());
    assertFalse(args.has('x'));
    assertEquals(0, args.getInt('x'));
    assertEquals("Argument -x expects a double but was 'Forty two'.",
        args.errorMessage());
}
-- -public String errorMessage() throws Exception {
    switch (errorCode) {
        case OK:
            throw new Exception("TILT: Should not get here.");
        case UNEXPECTED_ARGUMENT:
            return unexpectedArgumentMessage();
        case MISSING_STRING:
            return String.format(
                "Could not find string parameter for -%c.", errorArgumentId);
        case INVALID_INTEGER:
            return String.format(
                "Argument -%c expects an integer but was '%s'.",
                errorArgumentId, errorParameter);
        case MISSING_INTEGER:
            return String.format(
                "Could not find integer parameter for -%c.", errorArgumentId);
        case INVALID_DOUBLE:
            return String.format("Argument -%c expects a double but was '%s'.",
                errorArgumentId, errorParameter);
        case MISSING_DOUBLE:
            return String.format(
                "Could not find double parameter for -%c.", errorArgumentId);
    }
    return "";
}

public void testMissingDouble() throws Exception {
    Args args = new Args("x##", new String[] {"-x"});
    assertFalse(args.isValid());
    assertEquals(0, args.cardinality());
    assertFalse(args.has('x'));
    assertEquals(0.0, args.getDouble('x'), 0.01);
    assertEquals(
        "Could not find double parameter for -x.", args.errorMessage());
}

public class ArgsException extends Exception {
    private char errorArgumentId = '\0';
    private String errorParameter = "TILT";
    private ErrorCode errorCode = ErrorCode.OK;
    public ArgsException() {}
    public ArgsException(String message) {
        super(message);
    }
    public enum ErrorCode {
        OK,
        MISSING_STRING,
        MISSING_INTEGER,
        INVALID_INTEGER,
        UNEXPECTED_ARGUMENT,
        MISSING_DOUBLE,
        INVALID_DOUBLE
    }
}
-- -public class Args {
    ... private char errorArgumentId = '\0';
    private String errorParameter = "TILT";
    private ArgsException.ErrorCode errorCode = ArgsException.ErrorCode.OK;
    private List<String> argsList;
    public Args(String schema, String[] args) throws ArgsException {
        this.schema = schema;
        argsList = Arrays.asList(args);
        valid = parse();
    }
    private boolean parse() throws ArgsException {
        if (schema.length() == 0 && argsList.size() == 0)
            return true;
        parseSchema();
        try {
            parseArguments();
        } catch (ArgsException e) {
        }
        return valid;
    }
    private boolean parseSchema() throws ArgsException {
        ...
    }
    private void parseSchemaElement(String element) throws ArgsException {
        ... else throw new ArgsException(String.format(
            "Argument: %c has invalid format: %s.", elementId, elementTail));
    }
    private void validateSchemaElementId(char elementId) throws ArgsException {
        if (!Character.isLetter(elementId)) {
            throw new ArgsException(
                "Bad character:" + elementId + "in Args format: " + schema);
        }
    }
    ... private void parseElement(char argChar) throws ArgsException {
        if (setArgument(argChar))
            argsFound.add(argChar);
        else {
            unexpectedArguments.add(argChar);
            errorCode = ArgsException.ErrorCode.UNEXPECTED_ARGUMENT;
            valid = false;
        }
    }
    ... private class StringArgumentMarshaler implements ArgumentMarshaler {
        private String stringValue = "";
        public void set(Iterator<String> currentArgument) throws ArgsException {
            try {
                stringValue = currentArgument.next();
            } catch (NoSuchElementException e) {
                errorCode = ArgsException.ErrorCode.MISSING_STRING;
                throw new ArgsException();
            }
        }
        public Object get() {
            return stringValue;
        }
    }
    private class IntegerArgumentMarshaler implements ArgumentMarshaler {
        private int intValue = 0;
        public void set(Iterator<String> currentArgument) throws ArgsException {
            String parameter = null;
            try {
                parameter = currentArgument.next();
                intValue = Integer.parseInt(parameter);
            } catch (NoSuchElementException e) {
                errorCode = ArgsException.ErrorCode.MISSING_INTEGER;
                throw new ArgsException();
            } catch (NumberFormatException e) {
                errorParameter = parameter;
                errorCode = ArgsException.ErrorCode.INVALID_INTEGER;
                throw new ArgsException();
            }
        }
        public Object get() {
            return intValue;
        }
    }
    private class DoubleArgumentMarshaler implements ArgumentMarshaler {
        private double doubleValue = 0;
        public void set(Iterator<String> currentArgument) throws ArgsException {
            String parameter = null;
            try {
                parameter = currentArgument.next();
                doubleValue = Double.parseDouble(parameter);
            } catch (NoSuchElementException e) {
                errorCode = ArgsException.ErrorCode.MISSING_DOUBLE;
                throw new ArgsException();
            } catch (NumberFormatException e) {
                errorParameter = parameter;
                errorCode = ArgsException.ErrorCode.INVALID_DOUBLE;
                throw new ArgsException();
            }
        }
        public Object get() {
            return doubleValue;
        }
    }
}

Listing 14-13 - ArgsTest.java

package com.objectmentor.utilities.args;
import junit.framework.TestCase;
public class ArgsTest extends TestCase {
    public void testCreateWithNoSchemaOrArguments() throws Exception {
        Args args = new Args("", new String[0]);
        assertEquals(0, args.cardinality());
    }
    public void testWithNoSchemaButWithOneArgument() throws Exception {
        try {
            new Args("", new String[] {"-x"});
            fail();
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.UNEXPECTED_ARGUMENT, e.getErrorCode());
            assertEquals('x', e.getErrorArgumentId());
        }
    }
    public void testWithNoSchemaButWithMultipleArguments() throws Exception {
        try {
            new Args("", new String[] {"-x", "-y"});
            fail();
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.UNEXPECTED_ARGUMENT, e.getErrorCode());
            assertEquals('x', e.getErrorArgumentId());
        }
    }
    public void testNonLetterSchema() throws Exception {
        try {
            new Args("*", new String[] {});
            fail("Args constructor should have thrown exception");
        } catch (ArgsException e) {
            assertEquals(ArgsException.ErrorCode.INVALID_ARGUMENT_NAME,
                e.getErrorCode());
            assertEquals('*', e.getErrorArgumentId());
        }
    }
    public void testInvalidArgumentFormat() throws Exception {
        try {
            new Args("f~", new String[] {});
            fail("Args constructor should have throws exception");
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.INVALID_FORMAT, e.getErrorCode());
            assertEquals('f', e.getErrorArgumentId());
        }
    }
    public void testSimpleBooleanPresent() throws Exception {
        Args args = new Args("x", new String[] {"-x"});
        assertEquals(1, args.cardinality());
        assertEquals(true, args.getBoolean('x'));
    }
    public void testSimpleStringPresent() throws Exception {
        Args args = new Args("x*", new String[] {"-x", "param"});
        assertEquals(1, args.cardinality());
        assertTrue(args.has('x'));
        assertEquals("param", args.getString('x'));
    }
    public void testMissingStringArgument() throws Exception {
        try {
            new Args("x*", new String[] {"-x"});
            fail();
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.MISSING_STRING, e.getErrorCode());
            assertEquals('x', e.getErrorArgumentId());
        }
    }
    public void testSpacesInFormat() throws Exception {
        Args args = new Args("x, y", new String[] {"-xy"});
        assertEquals(2, args.cardinality());
        assertTrue(args.has('x'));
        assertTrue(args.has('y'));
    }
    public void testSimpleIntPresent() throws Exception {
        Args args = new Args("x#", new String[] {"-x", "42"});
        assertEquals(1, args.cardinality());
        assertTrue(args.has('x'));
        assertEquals(42, args.getInt('x'));
    }
    public void testInvalidInteger() throws Exception {
        try {
            new Args("x#", new String[] {"-x", "Forty two"});
            fail();
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.INVALID_INTEGER, e.getErrorCode());
            assertEquals('x', e.getErrorArgumentId());
            assertEquals("Forty two", e.getErrorParameter());
        }
    }
    public void testMissingInteger() throws Exception {
        try {
            new Args("x#", new String[] {"-x"});
            fail();
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.MISSING_INTEGER, e.getErrorCode());
            assertEquals('x', e.getErrorArgumentId());
        }
    }
    public void testSimpleDoublePresent() throws Exception {
        Args args = new Args("x##", new String[] {"-x", "42.3"});
        assertEquals(1, args.cardinality());
        assertTrue(args.has('x'));
        assertEquals(42.3, args.getDouble('x'), .001);
    }
    public void testInvalidDouble() throws Exception {
        try {
            new Args("x##", new String[] {"-x", "Forty two"});
            fail();
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.INVALID_DOUBLE, e.getErrorCode());
            assertEquals('x', e.getErrorArgumentId());
            assertEquals("Forty two", e.getErrorParameter());
        }
    }
    public void testMissingDouble() throws Exception {
        try {
            new Args("x##", new String[] {"-x"});
            fail();
        } catch (ArgsException e) {
            assertEquals(
                ArgsException.ErrorCode.MISSING_DOUBLE, e.getErrorCode());
            assertEquals('x', e.getErrorArgumentId());
        }
    }
}

Listing 14-14 - ArgsExceptionTest.java

public class ArgsExceptionTest extends TestCase {
    public void testUnexpectedMessage() throws Exception {
        ArgsException e = new ArgsException(
            ArgsException.ErrorCode.UNEXPECTED_ARGUMENT, 'x', null);
        assertEquals("Argument -x unexpected.", e.errorMessage());
    }
    public void testMissingStringMessage() throws Exception {
        ArgsException e = new ArgsException(
            ArgsException.ErrorCode.MISSING_STRING, 'x', null);
        assertEquals(
            "Could not find string parameter for -x.", e.errorMessage());
    }
    public void testInvalidIntegerMessage() throws Exception {
        ArgsException e = new ArgsException(
            ArgsException.ErrorCode.INVALID_INTEGER, 'x', "Forty two");
        assertEquals("Argument -x expects an integer but was 'Forty two'.",
            e.errorMessage());
    }
    public void testMissingIntegerMessage() throws Exception {
        ArgsException e = new ArgsException(
            ArgsException.ErrorCode.MISSING_INTEGER, 'x', null);
        assertEquals(
            "Could not find integer parameter for -x.", e.errorMessage());
    }
    public void testInvalidDoubleMessage() throws Exception {
        ArgsException e = new ArgsException(
            ArgsException.ErrorCode.INVALID_DOUBLE, 'x', "Forty two");
        assertEquals("Argument -x expects a double but was 'Forty two'.",
            e.errorMessage());
    }
    public void testMissingDoubleMessage() throws Exception {
        ArgsException e = new ArgsException(
            ArgsException.ErrorCode.MISSING_DOUBLE, 'x', null);
        assertEquals(
            "Could not find double parameter for -x.", e.errorMessage());
    }
}

Listing 14-15 - ArgsException.java

public class ArgsException extends Exception {
    private char errorArgumentId = '\0';
    private String errorParameter = "TILT";
    private ErrorCode errorCode = ErrorCode.OK;
    public ArgsException() {}
    public ArgsException(String message) {
        super(message);
    }
    public ArgsException(ErrorCode errorCode) {
        this.errorCode = errorCode;
    }
    public ArgsException(ErrorCode errorCode, String errorParameter) {
        this.errorCode = errorCode;
        this.errorParameter = errorParameter;
    }
    public ArgsException(
        ErrorCode errorCode, char errorArgumentId, String errorParameter) {
        this.errorCode = errorCode;
        this.errorParameter = errorParameter;
        this.errorArgumentId = errorArgumentId;
    }
    public char getErrorArgumentId() {
        return errorArgumentId;
    }
    public void setErrorArgumentId(char errorArgumentId) {
        this.errorArgumentId = errorArgumentId;
    }
    public String getErrorParameter() {
        return errorParameter;
    }
    public void setErrorParameter(String errorParameter) {
        this.errorParameter = errorParameter;
    }
    public ErrorCode getErrorCode() {
        return errorCode;
    }
    public void setErrorCode(ErrorCode errorCode) {
        this.errorCode = errorCode;
    }
    public String errorMessage() throws Exception {
        switch (errorCode) {
            case OK:
                throw new Exception("TILT: Should not get here.");
            case UNEXPECTED_ARGUMENT:
                return String.format(
                    "Argument -%c unexpected.", errorArgumentId);
            case MISSING_STRING:
                return String.format("Could not find string parameter for -%c.",
                    errorArgumentId);
            case INVALID_INTEGER:
                return String.format(
                    "Argument -%c expects an integer but was '%s'.",
                    errorArgumentId, errorParameter);
            case MISSING_INTEGER:
                return String.format(
                    "Could not find integer parameter for -%c.",
                    errorArgumentId);
            case INVALID_DOUBLE:
                return String.format(
                    "Argument -%c expects a double but was '%s'.",
                    errorArgumentId, errorParameter);
            case MISSING_DOUBLE:
                return String.format("Could not find double parameter for -%c.",
                    errorArgumentId);
        }
        return "";
    }
    public enum ErrorCode {
        OK,
        INVALID_FORMAT,
        UNEXPECTED_ARGUMENT,
        INVALID_ARGUMENT_NAME,
        MISSING_STRING,
        MISSING_INTEGER,
        INVALID_INTEGER,
        MISSING_DOUBLE,
        INVALID_DOUBLE
    }
}

Listing 14-16 - Args.java

public class Args {
    private String schema;
    private Map<Character, ArgumentMarshaler> marshalers =
        new HashMap<Character, ArgumentMarshaler>();
    private Set<Character> argsFound = new HashSet<Character>();
    private Iterator<String> currentArgument;
    private List<String> argsList;
    public Args(String schema, String[] args) throws ArgsException {
        this.schema = schema;
        argsList = Arrays.asList(args);
        parse();
    }
    private void parse() throws ArgsException {
        parseSchema();
        parseArguments();
    }
    private boolean parseSchema() throws ArgsException {
        for (String element : schema.split(",")) {
            if (element.length() > 0) {
                parseSchemaElement(element.trim());
            }
        }
        return true;
    }
    private void parseSchemaElement(String element) throws ArgsException {
        char elementId = element.charAt(0);
        String elementTail = element.substring(1);
        validateSchemaElementId(elementId);
        if (elementTail.length() == 0)
            marshalers.put(elementId, new BooleanArgumentMarshaler());
        else if (elementTail.equals("*"))
            marshalers.put(elementId, new StringArgumentMarshaler());
        else if (elementTail.equals("#"))
            marshalers.put(elementId, new IntegerArgumentMarshaler());
        else if (elementTail.equals("##"))
            marshalers.put(elementId, new DoubleArgumentMarshaler());
        else
            throw new ArgsException(
                ArgsException.ErrorCode.INVALID_FORMAT, elementId, elementTail);
    }
    private void validateSchemaElementId(char elementId) throws ArgsException {
        if (!Character.isLetter(elementId)) {
            throw new ArgsException(
                ArgsException.ErrorCode.INVALID_ARGUMENT_NAME, elementId, null);
        }
    }
    private void parseArguments() throws ArgsException {
        for (currentArgument = argsList.iterator();
             currentArgument.hasNext();) {
            String arg = currentArgument.next();
            parseArgument(arg);
        }
    }
    private void parseArgument(String arg) throws ArgsException {
        if (arg.startsWith("-"))
            parseElements(arg);
    }
    private void parseElements(String arg) throws ArgsException {
        for (int i = 1; i < arg.length(); i++) parseElement(arg.charAt(i));
    }
    private void parseElement(char argChar) throws ArgsException {
        if (setArgument(argChar))
            argsFound.add(argChar);
        else {
            throw new ArgsException(
                ArgsException.ErrorCode.UNEXPECTED_ARGUMENT, argChar, null);
        }
    }
    private boolean setArgument(char argChar) throws ArgsException {
        ArgumentMarshaler m = marshalers.get(argChar);
        if (m == null)
            return false;
        try {
            m.set(currentArgument);
            return true;
        } catch (ArgsException e) {
            e.setErrorArgumentId(argChar);
            throw e;
        }
    }
    public int cardinality() {
        return argsFound.size();
    }
    public String usage() {
        if (schema.length() > 0)
            return "-[" + schema + "]";
        else
            return "";
    }
    public boolean getBoolean(char arg) {
        ArgumentMarshaler am = marshalers.get(arg);
        boolean b = false;
        try {
            b = am != null && (Boolean) am.get();
        } catch (ClassCastException e) {
            b = false;
        }
        return b;
    }
    public String getString(char arg) {
        ArgumentMarshaler am = marshalers.get(arg);
        try {
            return am == null ? "" : (String) am.get();
        } catch (ClassCastException e) {
            return "";
        }
    }
    public int getInt(char arg) {
        ArgumentMarshaler am = marshalers.get(arg);
        try {
            return am == null ? 0 : (Integer) am.get();
        } catch (Exception e) {
            return 0;
        }
    }
    public double getDouble(char arg) {
        ArgumentMarshaler am = marshalers.get(arg);
        try {
            return am == null ? 0 : (Double) am.get();
        } catch (Exception e) {
            return 0.0;
        }
    }
    public boolean has(char arg) {
        return argsFound.contains(arg);
    }
}