OptionList verwaltet die bekannten Optionen und
* wertet die Kommandozeile aus.
*
*
*
* OptionList options = new OptionList(args);
* StringOption opt = new StringOption("program-name", "n");
* opt.setMediumName("name");
* opt.setPropertyName("program.name");
* opt.setDefault("PROGRAM");
* options.add(opt);
*
* if (options.validate() == false) {
* fail(options.getError());
* }
*
* options.setProperties(properties);
* println("Optionen:");
* println(options.list());
*
*
*
* OptionList ohne
* Argumente.
*/
public OptionList() {
String[] args = new String[0];
init(args, 0);
}
/**
* Erzeugt eine neue Instanz der Klasse OptionList.
*
* @param cmdline
* String[][]
*/
public OptionList(String[][] cmdline) {
String[] args = Arrays.stream(cmdline)
.flatMap(arr -> Arrays.stream(arr))
.toArray(String[]::new);
init(args, 0);
}
/**
* Erzeugt eine neue Instanz der Klasse OptionList.
*
* @param cmdline
* a String[] value
*/
public OptionList(String[] cmdline) {
if (cmdline == null)
throw new IllegalArgumentException("Variable args is null!");
init(cmdline, 0);
}
/**
* Erzeugt eine neue Instanz der Klasse OptionList.
*
* Der Parameter offset gibt an ab welchem Element der
* Kommandozeile die Argumente ausgewertet werden sollen. Damit ist möglich
* den Parametern Unterbefehle voranzustellen, z.B. wie in cocs update
* --force.
*
* @param cmdline
* a String[] value
*/
public OptionList(String[] cmdline, int offset) {
if (cmdline == null) {
throw new IllegalArgumentException(
"The argument cmdline may not be null!");
}
if (offset < 0) {
throw new IllegalArgumentException(
"The argument offset must be greater than 0!");
}
if (offset > cmdline.length) {
throw new IllegalArgumentException(
"The argument offset is greater than the lehgth of the command line!");
}
init(cmdline, offset);
}
/**
* Die Methode getError liefert die letzte Fehlermeldung an den
* Aufrufer zurück.
*
* @return String
*/
public String getError() {
if (error == null) {
error = "";
}
return String.join(" ", args) + "\n\n" + error;
}
/**
* Die Methode findOption sucht nach der angegebenen Option in
* der aktuellen Liste von Optionen.
*
* Falls die Option nicht gefunden werden kann, wird null
* zurückgegeben.
*
* @param option
* Die Option nach der gesucht wird.
* @return Die gefundene Option oder null.
*/
public Option findOption(Option option) {
Object obj;
int index = optList.indexOf(option);
if (index != -1) {
obj = optList.get(index);
if (obj != null && obj instanceof Option) {
return (Option) obj;
}
}
return null;
}
/**
* The method findOption tries to find the given option by
* name. If the option can not be found, null is returned.
*
* @param name
* a String value
* @return The option or null if no option can be found.
*/
public Option findOption(String name) {
if (name == null) {
throw new IllegalArgumentException(
" The argument name may not be null!");
}
return optMap.get(name);
}
public Option findExistingOption(Option option) {
if (option == null) {
throw new IllegalArgumentException(
" The argument option may not be null!");
}
Option existing;
existing = optMap.get(option.getLongName());
if (existing != null) {
return existing;
}
existing = optMap.get(option.getMediumName());
if (existing != null) {
return existing;
}
existing = optMap.get(option.getShortName());
if (existing != null) {
return existing;
}
existing = optMap.get(option.getPropertyName());
if (existing != null) {
return existing;
}
throw new OptionException("Can't find existing option!");
}
/**
* The method getOption tries to find the given option by name.
* If the option can not be found, an OptionException is thrown.
*
* @param name
* a String value
* @return The option.
*/
public Option getOption(String name) throws OptionException {
if (name == null) {
throw new IllegalArgumentException(
"The argument name may not be null!");
}
Option option = optMap.get(name);
if (option == null) {
String msg = MessageFormat.format(
ResourceServices.getString(res, "C_ERROR_OPTION_UNKNOWN"),
name);
throw new OptionException(msg);
}
return option;
}
public BooleanOption getBooleanOption(String name) {
if (name == null) {
throw new IllegalArgumentException(
"The argument name may not be null!");
}
Option option = getOption(name);
if (option instanceof BooleanOption) {
return (BooleanOption) option;
} else {
String msg = MessageFormat.format(ResourceServices.getString(res,
"C_ERROR_OPTION_INVALID_TYPE"), name, "boolean", option
.getClass().getName());
throw new OptionException(msg);
} // end of else
}
public void add(Option option) throws OptionException {
if (option == null) {
throw new IllegalArgumentException(
" The argument option may not be null!");
}
if (option.isValid() == false) {
throw new OptionException(ResourceServices.getString(res,
"C_ERROR_INVALID_OPTION") + option.getUniqueName());
}
if (exists(option)) {
Option existing = findExistingOption(option);
throw new OptionException(MessageFormat.format(ResourceServices
.getString(res, "C_ERROR_OPTION_ALREADY_IN_USE"), option
.getFQName(), existing.getFQName()));
}
optList.add(option);
Arrays.stream(option.getNames()).forEach(n -> optMap.put(n, option));
}
/**
* Die Methode getRemainingArgs liefert die nach der
* Validierung überzähligen Argumente. Also diejenigen Argumente, die nicht
* definiert waren.
*
* @return String[]
*/
public String[] getRemainingArgs() {
if (remainingArgs == null) {
return new String[0];
}
return remainingArgs.stream().toArray(String[]::new);
}
/**
* Describe getString method here.
*
* @param name
* a String value
* @return a String value
*/
public String getString(String name) {
if (name == null)
throw new IllegalArgumentException("Variable name is null!");
Option option = optMap.get(name);
if (option == null) {
return "";
}
if (option.getValue() == null) {
return null;
}
return option.getValue().toString();
}
/**
* Describe getString method here.
*
* @param name
* a String value
* @param deflt
* a String value
* @return a String value
*/
public String getString(String name, String deflt) {
if (name == null)
throw new IllegalArgumentException("Variable name is null!");
Option option = optMap.get(name);
if (option == null || option.isUnset())
return deflt;
if (option.getValue() == null) {
return deflt;
} else {
return option.getValue().toString();
}
}
public void addDeprecatedPropertyAlias(Option option, String alias)
throws OptionException {
if (option == null) {
throw new IllegalArgumentException(
"The argument option may not be null!");
}
if (alias == null || alias.length() == 0 || alias.equals("!")) {
throw new IllegalArgumentException(
"The argument alias is invalid: " + alias);
}
if (deprecatedPropertiesMap == null) {
throw new IllegalStateException(
" The field deprecatedPropertiesMap may not be null!");
}
String name = alias;
if (name.startsWith("!")) {
name = name.substring(1);
} // end of if (name.startsWith("!"))
Option opt = optMap.get(name);
if (opt != null && opt.equals(option) == false) {
throw new OptionException(MessageFormat.format(ResourceServices
.getString(res, "C_ERROR_OPTION_ALREADY_IN_USE"), name));
}
deprecatedPropertiesMap.put(alias, option);
}
public boolean setProperties(String fname) throws FileNotFoundException,
IOException {
if (fname == null) {
throw new IllegalArgumentException(
" The argument fname may not be null!");
}
Properties props = new Properties();
props.load(new FileInputStream(fname));
return setProperties(props);
}
public boolean setProperties(Properties props) throws OptionException {
if (props == null) {
throw new IllegalArgumentException(
" The argument props may not be null!");
}
Object obj;
Option option;
String name;
String value;
String buffer = "";
// props.forEach(Property p -> System.out.println());
for (Iterator