private String incorrectDataTypeMessage(ArrayList<String> argList) {
String errorMessage = this.usageMessage();
if (incorrectArgumentType.equals("positional")) {
PositionalArgument currentArg = positionalArgumentList.get(incorrectDataTypeIndex);
errorMessage +=
"\n"
+ programName
+ ".java: error: argument "
+ currentArg.getName()
+ ": invalid "
+ currentArg.getType()
+ " value: "
+ argList.get(incorrectDataTypeIndex);
return errorMessage;
} else {
NamedArgument currentArg = namedArgumentList.get(incorrectDataTypeIndex);
errorMessage +=
"\n"
+ programName
+ ".java: error: argument "
+ currentArg.getName()
+ ": invalid "
+ currentArg.getType()
+ " value: "
+ incorrectArgValueForSpecifiedDataType;
return errorMessage;
}
}
private String usageMessage() {
String message = "usage: java " + programName + " required:";
for (int i = 0; i < positionalArgumentList.size(); i++) {
PositionalArgument currentArg = positionalArgumentList.get(i);
message += " " + currentArg.getName();
}
return message;
}
/**
* Returns the positional argument at the specified position where argPosition starts at 1
*
* @param argPosition the integer position of the positional argument to find
* @return the positional argument with the specified position, position starts at index 1
*/
public PositionalArgument getPositionalArgument(int argPosition) {
PositionalArgument returnArg = null;
for (int i = 0; i < positionalArgumentList.size(); i++) {
PositionalArgument currentArg = positionalArgumentList.get(i);
if (currentArg.getPosition() == argPosition - 1) {
returnArg = currentArg;
}
}
return returnArg;
}
/**
* Returns the positional argument with the specified string name
*
* @param argName the name of the positional argument to return
* @return the positional argument with the specified name
*/
public PositionalArgument getPositionalArgument(String argName) {
PositionalArgument returnArg = null;
for (int i = 0; i < positionalArgumentList.size(); i++) {
PositionalArgument currentArg = positionalArgumentList.get(i);
if (currentArg.getName().equals(argName)) {
returnArg = currentArg;
}
}
return returnArg;
}
private void parsePositionalArgumentValues(List<PositionalArgument> posArgList)
throws IncorrectArgumentValueException {
for (int i = 0; i < posArgList.size(); i++) {
PositionalArgument currentArg = posArgList.get(i);
String errorArg = currentArg.getName();
String[] valueSet = currentArg.getValueSet();
if (!valueSet[0].equals("")) {
Boolean valueSetContainsArgValue = false;
String errorValue = "";
for (int j = 0; j < valueSet.length; j++) {
if (currentArg.getType().equals("integer")) {
int intValue = (Integer) currentArg.getValue();
if (valueSet[j].equals(Integer.toString(intValue))) {
valueSetContainsArgValue = true;
}
errorValue = Integer.toString(intValue);
} else if (currentArg.getType().equals("float")) {
float floatValue = (Float) currentArg.getValue();
if (valueSet[j].equals(Float.toString(floatValue))) {
valueSetContainsArgValue = true;
}
errorValue = Float.toString(floatValue);
} else if (currentArg.getType().equals("string")) {
String stringValue = (String) currentArg.getValue();
if (valueSet[j].equals(stringValue)) {
valueSetContainsArgValue = true;
}
errorValue = stringValue;
}
/*else{
Boolean boolValue = (Boolean)currentArg.getValue();
if(valueSet[j].equals(Boolean.toString(boolValue))){
valueSetContainsArgValue = true;
}
errorValue = Boolean.toString(boolValue);
}*/
}
if (!valueSetContainsArgValue) {
throw new IncorrectArgumentValueException(
incorrectArgumentValueMessage(errorArg, errorValue));
}
}
}
}
/**
* Parses input data from the command line and throws the correct exceptions if tinput data is an
* incorrect format
*
* @param args the input data from the command line
* @throws HelpException if the help argument is given in the input data
* @throws IncorrectNumberOfArgsException if an incorrect number of positional arguments is given
* in the input data
* @throws IncorrectArgTypeException if an input argument is given as the wrong dataType specified
* by the user
* @throws ArgumentDoesNotExistException if a named argument is given in the input data that has
* not been created by the user
* @throws IncorrectArgumentValueException if the input data is not a possible value for a
* specified argument
*/
public void parse(String[] args)
throws HelpException, IncorrectNumberOfArgsException, IncorrectArgTypeException,
ArgumentDoesNotExistException, IncorrectArgumentValueException {
ArrayList<String> tempPositionalArgList = getPositionalArgs(args);
try {
setLongFormNamedArgValues(args);
setShortFormNamedArgValues(args);
} catch (Exception e) {
throw new IncorrectArgTypeException(incorrectDataTypeMessage(tempPositionalArgList));
}
invalidNamedArgument(args); // throws ArgumentDoesNotExistException
NamedArgument helpArgument = getNamedArgument("help");
if (helpArgument != null) {
Boolean helpArgValue = (Boolean) helpArgument.getValue();
if (helpArgValue) {
throw new HelpException(helpMessage());
}
}
if (positionalArgumentList.size() != tempPositionalArgList.size()) {
throw new IncorrectNumberOfArgsException(incorrectNumberOfArgsMessage(tempPositionalArgList));
} else if (positionalArgumentList.size() == tempPositionalArgList.size()) {
for (int i = 0; i < tempPositionalArgList.size(); i++) {
PositionalArgument currentArg = positionalArgumentList.get(i);
currentArg.setValue(tempPositionalArgList.get(i));
}
try {
parseDataType(tempPositionalArgList);
} catch (Exception e) {
throw new IncorrectArgTypeException(incorrectDataTypeMessage(tempPositionalArgList));
}
parseNamedArgumentValues(namedArgumentList); // throws IncorrectArgumentValueException
parsePositionalArgumentValues(
positionalArgumentList); // throws IncorrectArgumentValueException
}
}
private String helpMessage() {
String helpMessage = this.usageMessage();
/*for(int i = 0; i < namedArgumentList.size(); i++){
NamedArgument namedArg = namedArgumentList.get(i);
helpMessage += " [" + namedArg.getName() + "]";
}*/
helpMessage += "\n" + programDescription + "\npositional arguments:";
for (int i = 0; i < positionalArgumentList.size(); i++) {
PositionalArgument currentArg = positionalArgumentList.get(i);
helpMessage +=
"\n["
+ currentArg.getName()
+ "] ("
+ currentArg.getType()
+ ") "
+ currentArg.getDescription();
}
helpMessage += "\nnamed arguments:";
for (int i = 0; i < namedArgumentList.size(); i++) {
NamedArgument currentArg = namedArgumentList.get(i);
helpMessage +=
"\n[--"
+ currentArg.getName()
+ "] [-"
+ currentArg.getShortFormName()
+ "] ("
+ currentArg.getType()
+ ") "
+ currentArg.getDescription()
+ " (optional)";
}
return helpMessage;
}
private String incorrectNumberOfArgsMessage(ArrayList<String> argList) {
int numOfArgs = positionalArgumentList.size();
if (argList.size() < numOfArgs) {
String message = this.usageMessage();
message += "\n" + programName + ".java: error: the following arguments are required:";
for (int j = argList.size(); j < numOfArgs; j++) {
PositionalArgument currentArg = positionalArgumentList.get(j);
message += " " + currentArg.getName();
}
return message;
} else {
String message = this.usageMessage();
message += "\n" + programName + ".java: error: unrecognized arguments:";
for (int j = numOfArgs; j < argList.size(); j++) {
message += " " + argList.get(j);
}
return message;
}
}
private void parseDataType(ArrayList<String> argList) throws NumberFormatException {
// checking positional args
for (int index = 0; index < argList.size(); index++) {
incorrectDataTypeIndex = index;
incorrectArgumentType = "positional";
PositionalArgument currentArg = positionalArgumentList.get(index);
if (currentArg.getType().equals("integer")) {
int argValue = Integer.parseInt(argList.get(index));
currentArg.setValue(argList.get(index));
// currentArg.setValue(argValue);
} else if (currentArg.getType().equals("float")) {
float argValue = Float.parseFloat(argList.get(index));
currentArg.setValue(argList.get(index));
} else if (currentArg.getType().equals("string")) {
String argValue = argList.get(index);
currentArg.setValue(argValue);
} else {
Boolean argValue = parseBool(argList.get(index));
currentArg.setValue(argList.get(index));
}
}
}
/**
* Writes argument parser information to the specified XML file. The program name, program
* description, positional arguments, and named arguments are saved in the file in standard XML
* format. It also saves each aspect of the arguments such as argument name, description,
* dataType, defaultValue, and possible value set.
*
* @param fileName the XML file to which all information will be written
*/
public void writeToXMLFile(String fileName) {
File outputFile = new File(fileName);
try {
PrintWriter outputFileWriter = new PrintWriter(outputFile);
outputFileWriter.println("<?xml version=" + "\"1.0\"?>");
outputFileWriter.println("<program>");
outputFileWriter.println("<name>" + getProgramName() + "</name>");
outputFileWriter.println("<description>" + getProgramDescription() + "</description>");
outputFileWriter.println("<arguments>");
for (int i = 0; i < positionalArgumentList.size(); i++) {
PositionalArgument posArg = positionalArgumentList.get(i);
outputFileWriter.println("<positional>");
outputFileWriter.println("<name>" + posArg.getName() + "</name>");
outputFileWriter.println("<type>" + posArg.getType() + "</type>");
outputFileWriter.println("<description>" + posArg.getDescription() + "</description>");
outputFileWriter.println(
"<position>"
+ (posArg.getPosition() + 1)
+ "</position>"); // prints position starting at 1
String[] valueSet = posArg.getValueSet();
if (!valueSet[0].equals("")) {
String line = "<valueset>";
line += valueSet[0];
for (int j = 1; j < valueSet.length; j++) {
line += "," + valueSet[j];
}
line += "</valueset>";
outputFileWriter.println(line);
}
// outputFileWriter.println(line);
outputFileWriter.println("</positional>");
}
for (int j = 0; j < namedArgumentList.size(); j++) {
NamedArgument namedArg = namedArgumentList.get(j);
outputFileWriter.println("<named>");
outputFileWriter.println("<name>" + namedArg.getName() + "</name>");
outputFileWriter.println("<shortname>" + namedArg.getShortFormName() + "</shortname>");
outputFileWriter.println("<type>" + namedArg.getType() + "</type>");
outputFileWriter.println("<description>" + namedArg.getDescription() + "</description>");
outputFileWriter.println("<default>" + namedArg.getDefaultValue() + "</default>");
String[] valueSet = namedArg.getValueSet();
if (!valueSet[0].equals("")) {
String line = "<valueset>";
line += valueSet[0];
for (int k = 1; k < valueSet.length; k++) {
line += "," + valueSet[k];
}
line += "</valueset>";
outputFileWriter.println(line);
}
outputFileWriter.println("</named>");
}
outputFileWriter.println("</arguments>");
outputFileWriter.println("</program>");
outputFileWriter.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
/**
* Adds a new positional argument to be parsed from the command line
*
* @param arg a new instance of a positional argument If a positional argument is not supplied,
* the program should exit, and the usage information should be displayed along with the error
* stating the missing argument. If an additional (i.e., one too many) positional argument is
* specified, then the program should exit, and the usage information should be displayed
* along with the error stating the additional argument.
*/
public void addPositionalArgument(PositionalArgument arg) {
posCount++;
arg.setPosition(posCount);
positionalArgumentList.add(arg);
}