src.com.ibm.as400.access.CommandLineArguments Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400-jdk8 Show documentation
Show all versions of jt400-jdk8 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// JTOpen (IBM Toolbox for Java - OSS version)
//
// Filename: CommandLineArguments.java
//
// The source code contained herein is licensed under the IBM Public License
// Version 1.0, which has been approved by the Open Source Initiative.
// Copyright (C) 1997-2000 International Business Machines Corporation and
// others. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////
package com.ibm.as400.access;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
/**
* A utility that parses command line arguments into
* options specified in the format "-optionName optionValue".
*
* Here is an example of calling a program from the command line with arguments:
*
*
* A sample program: java myProgram systemName -userid myID -password myPWD
*
* The Java code to parse the command:
*
* // Create a vector to hold all the defined/expected command line arguments.
* Vector options = new Vector();
* options.addElement("-userID");
* options.addElement("-password");
*
* // Create a Hashtable to map shortcuts to the command line arguments.
* Hashtable shortcuts = new Hashtable();
* shortcuts.put("-u", "-userID");
* shortcuts.put("-p", "-password");
*
* // Create a CommandLineArguments object with the args array passed into main(String args[])
* // along with the vector and hashtable just created.
* CommandLineArguments arguments = new CommandLineArguments(args, options, shortcuts);
*
* // Get the name of the IBM i system that the user wants to run to.
* String system = arguments.getOptionValue("");
*
* // Get the user ID that the user wants to log in with.
* String uid = arguments.getOptionValue("-userID");
*
* // Get the password that the user wants to log in with.
* String pwd = arguments.getOptionValue("-password");
*
*
*
**/
public class CommandLineArguments //$B1C
{
// Private data.
private Vector extraOptions_ = new Vector ();
private Hashtable map_ = new Hashtable ();
/**
Creates a CommandLineArguments object.
@param args The command line arguments.
**/
public CommandLineArguments (String[] args)
{
this (args, null, new Hashtable ());
}
/**
Creates a CommandLineArguments object.
@param args The command line arguments.
@param expectedOptions The expected options. This is a Vector of
Strings, each starting with a hyphen ("-").
These are not case sensitive. Specify null
if any options are expected.
@param shortcuts The shortcuts. This is a Hashtable where
the keys are Strings for the shortcuts (e.g. "-?") and
the elements are Strings for the option (e.g. "-help").
All strings start with a hyphen ("-"). Specify
null if no shortcuts are used.
**/
public CommandLineArguments (String[] args, Vector expectedOptions, Hashtable shortcuts)
{
// Lowercase all of the expected option names.
if (expectedOptions != null) {
Vector normalizedExpectedOptions = new Vector ();
Enumeration list = expectedOptions.elements ();
while (list.hasMoreElements ())
normalizedExpectedOptions.addElement (list.nextElement ().toString ().toLowerCase ());
expectedOptions = normalizedExpectedOptions;
}
// Parse through the args.
// Note: Any leading arguments that aren't preceded by an option name,
// are associated as values to the special "unnamed" option, "-".
String currentOptionName = "-";
StringBuffer currentOptionValue = new StringBuffer ();
for (int i = 0; i < args.length; ++i) {
String arg = args[i];
if (isOptionName(arg)) { // @A2C
map_.put (currentOptionName, currentOptionValue);
currentOptionName = arg.toLowerCase ();
if (shortcuts != null)
if (shortcuts.containsKey (currentOptionName))
currentOptionName = ((String) shortcuts.get (currentOptionName)).toLowerCase ();
if (expectedOptions != null)
if (! expectedOptions.contains (currentOptionName))
extraOptions_.addElement (currentOptionName);
if (map_.containsKey (currentOptionName))
currentOptionValue = (StringBuffer) map_.get (currentOptionName);
else
currentOptionValue = new StringBuffer ();
}
else {
currentOptionValue.append (" ");
currentOptionValue.append (arg);
}
}
map_.put (currentOptionName, currentOptionValue);
}
/**
Returns the list of any extra options that were specified.
These are options that the application was not expecting.
@return The list of extra options. This is an Enumeration
which contains a String for each extra option.
If there were no extra options, an empty Enumeration is returned.
**/
public Enumeration getExtraOptions ()
{
return extraOptions_.elements ();
}
/**
Returns the list of option names that were specified.
@return The list of option names. This is an Enumeration
which contains a String for each option name.
Note: The list may include the special "unnamed" option, "-",
which is aliased as "".
**/
public Enumeration getOptionNames ()
{
return map_.keys ();
}
/**
Returns the value of an option.
@param optionName The option name.
@return The option value, or null if the
option was not specified.
**/
public String getOptionValue (String optionName)
{
// Note: We map "" to the special (unnamed) option "-".
String key;
if (! optionName.startsWith ("-"))
key = "-" + optionName.toLowerCase ();
else
key = optionName.toLowerCase ();
if (map_.containsKey (key))
return map_.get (key).toString ().trim ();
else
return null;
}
/**
Indicates whether the option was specified.
@param optionName The option name.
@return true if the option was specified; false otherwise.
**/
public boolean isOptionSpecified (String optionName)
{
return ( getOptionValue(optionName) != null );
}
private boolean isOptionName(String arg) // @A2A
{ // @A2A
if (! arg.startsWith("-")) // @A2A
return false; // @A2A
// @A2A
// Allow numeric option values, but disallow numeric option names. // @A2A
// This is to avoid mistaking a negative number for an option indicator.
try { // @A2A
Double.valueOf(arg.substring(1)); // @A2A
return false; // @A2A
} // @A2A
catch(NumberFormatException e) { // @A2A
return true; // @A2A
} // @A2A
} // @A2A
/**
The main() method for test this class. This should
be commented out for production code.
**/
/*
public static void main (String[] args)
{
Hashtable shortcuts = new Hashtable ();
shortcuts.put ("-sc", "-shortcut");
CommandLineArguments cla = new CommandLineArguments (args, null, shortcuts);
Enumeration list = cla.getOptionNames ();
while (list.hasMoreElements ()) {
String optionName = (String) list.nextElement ();
String optionValue = cla.getOptionValue (optionName);
System.out.println ("Option:");
System.out.println (" name: [" + optionName + "]");
System.out.println (" value: [" + optionValue + "]");
}
}
*/
}