ParameterParser
Related Doc:
package scli
Definition of a function that can resolve aliases.
Definition of a function that can resolve aliases.
The idea is that the function gets passed in a parameter key. If this key is known to be an alias, the function should return a defined Option with the key the alias is for; this key is then used as replacement for the alias. If the key cannot be resolved as an alias, the function should return None; the key is then used as is.
Definition of a function to classify parameters on the command line.
Definition of a function to classify parameters on the command line.
The function is passed the sequence with parameters and the index of the current one to be inspected. It returns the result of the classification as a CliElement object.
A trait describing an item encountered on the command line.
A trait describing an item encountered on the command line.
During parameter parsing the single items on the command line need to be classified into options, switches, or input parameters. For this purpose, a classification function is used which returns sub classes of this trait. The parser needs to handle the sub classes differently.
This trait also plays a role for error handling: It stores the original key and the raw value of the represented parameter. This information is useful when generating meaningful error messages.
In addition, the position of the corresponding element on the command line can be queried. This is needed by some use cases that override the values of options with values appearing later on the command line.
Definition of a function to classify specific parameters whose key has already been extracted.
Definition of a function to classify specific parameters whose key has already been extracted.
This function type is similar to CliClassifierFunc, but there are a couple of differences: First, it is invoked with a parameter key in addition to the sequence of parameters and the current index; so it will be called only for options or switches. Second, this function can fail to classify a parameter. The idea here is that multiple functions of this type can be combined, each of which is specialized for a specific parameter type. If none of those are able to detect the parameter type, an input parameter can be assumed as fallback.
Definition of a function that detects options referencing a parameters file.
Definition of a function that detects options referencing a parameters file.
The library supports externalizing complex parameter lists in files. These files can be specified on the command line using specific options. This function type is used by the processFileOptions() function to determine the parameter files to be loaded. The function is passed a CliElement; if this element references a parameters file, it returns a defined Option with the key of the file option (to be used in error messages) and the file name.
A concrete CliElement class representing an input parameter.
A concrete CliElement class representing an input parameter.
the value to be added to the input parameters
the index of this element on the command line
Definition of a function that can extract the key of an option or switch parameter from a command line element.
Definition of a function that can extract the key of an option or switch parameter from a command line element.
The function is passed the string encountered on the command line. A concrete implementation probably checks whether this string starts with a prefix indicating an option or switch. If so, the key is returned (with the prefix removed); otherwise, result is an empty Option.
A concrete CliElement class representing an option.
A concrete CliElement class representing an option.
The option is identified by its key. If possible, its value is extracted; but this may noe be possible, for instance if the option key was the last parameter on the command line.
the key of the option
an Option with the value
the index of this element on the command line
A data class that stores a list with supported prefixes for options.
A data class that stores a list with supported prefixes for options.
When parsing the command line each item is checked whether it starts with one of the prefixes defined by this class. If so, the item is considered an option or a switch.
Command line applications often distinguish between full parameter names and short alias names. The alias has the same meaning as the regular parameter name, but it is shorter to type on the command line. Typically, a different prefix is used distinguish between the long and short parameter names, such as --target-directory for the full name and -d for the short alias. When constructing an instance the prefixes to be managed are specified as ParameterKey objects; hence, it can be stated whether a prefix is used for long or short parameter names.
A specialized exception class to report problems during the processing of parameter files.
A specialized exception class to report problems during the processing of parameter files.
During parameter file processing, I/O exceptions can occur. Such exceptions are converted to exceptions of this type. They transport some more information which is useful when handling errors, e.g. printing help or error information.
Type definition for the map with resolved parameter values.
Type definition for the map with resolved parameter values. The array with command line options is transformed in such a map which allows direct access to the value(s) assigned to parameters. The map stores CliElement objects, so that the original information from the command line is still available.
A concrete CliElement class representing a set of switches.
A concrete CliElement class representing a set of switches.
A single parameter on the command line can contain multiple switches, e.g. if multiple short keys are composed, as in tar xvzf. Therefore, this class holds a list with switches that have been extracted. For each switch its key and its value (which is derived from the default value defined in the parameter model) is stored.
Note: The properties for key and value are dummies; during parameter parsing, for each switch in the result, a new element is created.
a list with switches and their values that have been extracted
the index of this element on the command line
An OptionPrefixes object with the default prefix for options.
An OptionPrefixes object with the default prefix for options. This is used if for a parse operation no explicit functions to recognize options and extract their keys are specified.
Reserved key of a parameter that collects the input strings that are no values of options or switches.
Generates a CliClassifierFunc from the given sequence extracted key classifier functions.
Generates a CliClassifierFunc from the given sequence extracted key classifier functions. The resulting classifier function tries to extract an option or switch key from the current command line parameter using the extractor function provided. If this succeeds, the key is passed to the key classifier functions one by one until one returns a defined result. This result is returned. If extraction of the key fails or none of the classifier functions returns a result, an InputParameterElement is returned.
a list of ExtractedKeyClassifierFunc functions
the key extractor function
a CliClassifierFunc constructed from these parameters
Returns a key classifier function for switches that can extract multiple short alias keys.
Returns a key classifier function for switches that can extract multiple short alias keys. For long keys, the classifier function behaves in the same way as the one returned by switchKeyClassifierFunc(). For short aliases, however, the function assumes that the key passed in consists of multiple single letter key aliases and returns corresponding keys in the resulting SwitchesElement. Note that here no checks for the parameter type are done. So to work correctly, the function should be executed after a check for option elements.
the model context
function to resolve alias keys
the key classifier function for multiple switches
Returns a FileOptionFunc that detects the given parameter keys as file options.
Returns a FileOptionFunc that detects the given parameter keys as file options. During file option processing, the command line elements are classified. If an element is an option with a key in the given list, the value of this option is returned as name of a parameter file.
a sequence with options referencing parameter files
the FileOptionFunc detecting these keys
Returns a key classifier func for options.
Returns a key classifier func for options. The function checks whether the passed in key references an option in the model context. If so, a corresponding result is returned.
the model context
function to resolve alias keys
the key classifier function for options
Parses the command line arguments and converts them into a map keyed by options.
Parses the command line arguments and converts them into a map keyed by options. The parsing operation can be customized by specifying some properties, especially a CliClassifierFunc. This function is invoked for each argument, and - based on its result - the parameter is added to the result produced by this function. Note that the parsing operation always succeeds, even if invalid parameters are passed in; this is detected and handled later in the extraction phase.
the sequence with command line arguments
a function to classify parameters
a function to resolve aliases
a Try with the parsed map of arguments
Processes the passed in sequence of parameters and resolves all parameter files detected by the given FileOptionFunc.
Processes the passed in sequence of parameters and resolves all parameter files detected by the given FileOptionFunc. The files are read, and their content is added to the command line, replacing the original file options. If successful, result is the full sequence of command line parameters with all parameter files included.
As I/O operations may fail, this function returns a Try. In case of a failure, the exception is of type ParameterFileException and contains further information about the failed read operation.
the sequence with command line arguments
a function to classify parameters
a function to detect file options
the final sequence of parameters including all parameter files
Returns a key classifier function for switches.
Returns a key classifier function for switches. The function checks whether the passed in key references a switch in the model context. If so, a corresponding result is returned.
the model context
function to resolve alias keys
the key classifier function for switches
(Since version ) see corresponding Javadoc for more information.
A module for parsing command line arguments into options and input values.
This module provides a function that expects a sequence of command line arguments as input and tries to generate a map with parameters from it. This function groups the single strings on the command line into option names, option values, and other input parameters. The resulting representation of parameters can then serve as input for the further processing of the command line, e.g. to extract configuration objects out of it.