Package org.snmp4j.util

Class ArgumentParser

java.lang.Object
org.snmp4j.util.ArgumentParser
public class ArgumentParser extends Object
The ArgumentParser parsers a command line array into Java objects and associates each object with the corresponding command line option according to predefined schemes for options and parameters.

The format specification for options is:

 [-<option>\[<type>[\<<regex>\>]{<parameter>[=<default>]}\]] ...
where
  • '-' indicates a mandatory option ('+' would indicate an optional option)
  • <option> is the name of the option, for example 'h' for 'help'
  • <type> is one of 'i' (integer), 'l' (long), 'o' (octet string), and 's' (string)
  • <regex> is a regular expression pattern that describes valid values
  • <default> is a default value. If a default value is given, then a mandatory option is in fact optional

The format specification for parameters is:

 [-<parameter>[<type>[<<regex>>]{[=<default>]}]]... [+<optionalParameter>[<type>[<<regex>>]{[=<default>]}]]... [<..>]
where
  • '-' indicates a mandatory parameter whereas '+' would indicate an optional parameter which must not be followed by a mandatory parameter
  • <parameter> is the name of the parameter, for example 'port'
  • <type> is one of 'i' (integer), 'l' (long), and 's' (string)
  • <regex> is a regular expression pattern that describes valid values
  • <default> is a default value
  • <..> (two consecutive dots after a space at the end of the pattern) indicate that the last parameter may occur more than once
Since:
1.9
Version:
1.10
Author:
Frank Fock

  • Field Details

  • Constructor Details

    • ArgumentParser

      public ArgumentParser(String optionFormat, String parameterFormat)
      Creates an argument parser with the specified option and parameter formats.
      Parameters:
      optionFormat - the option format pattern to parse (see ArgumentParser).
      parameterFormat - the parameter format pattern to parse (see ArgumentParser).

  • Method Details

    • getOptionFormat

      public Map<String,ArgumentParser.ArgumentFormat> getOptionFormat()

    • getParameterFormat

      public Map<? extends String,? extends ArgumentParser.ArgumentFormat> getParameterFormat()

    • parseFormat

      protected static Map<String,ArgumentParser.ArgumentFormat> parseFormat(String format, boolean parameterFormat)

    • parse

      public Map<String,List<?>> parse(String[] args) throws ParseException
      Parses the given command line and returns a map of parameter/option names to a List of values. Each value may be of type Integer, Long, and String.
      Parameters:
      args - the command line argument list.
      Returns:
      Map a map that returns options and parameters in the order they have been parsed, where each map entry has the option/parameter name as key and the value as value.
      Throws:
      ParseException - if the command line does not match the patterns for options and parameters.

    • addValues2Option

      protected void addValues2Option(String option, List values, Map<String,List<?>> options)

    • parseValues

      protected List<?> parseValues(String[] args, int offset, ArgumentParser.ArgumentFormat format) throws ParseException
      Throws:
      ParseException

    • parseParameterValue

      protected Object parseParameterValue(ArgumentParser.ArgumentParameter type, String value, ArgumentParser.ArgumentFormat format, int pos) throws ArgumentParser.ArgumentParseException
      Throws:
      ArgumentParser.ArgumentParseException

    • getFirstValue

      public static Object getFirstValue(List<? extends Object> optionValues)
      Gets the first option value of a list of values - if available.
      Parameters:
      optionValues - a probably empty list of values - could be null.
      Returns:
      the first option value in optionValues if it exists, null otherwise.
      Since:
      1.9.2

    • getValue

      public static Object getValue(Map args, String name, int index)
      Gets the n-th option value of a list of values - if available.
      Parameters:
      args - a parameter and options list.
      name - the option or parameter name to return
      index - the index (zero based) of the option/parameter value to return.
      Returns:
      the n-th (zero based) option value in args.get(name) if it exists, null otherwise.
      Since:
      1.10

    • main

      public static void main(String[] args)
      Test application to try out patterns and command line parameters. The default option and parameter patterns can be overridden by setting the system properties org.snmp4j.OptionFormat and org.snmp4j.ParameterFormat respectively.

      The given command line is parsed using the specified patterns and the parsed values are returned on the console output.

      The default option pattern is -o1[i{parameter1}] -o2[s,l] and the default parameter pattern is -param1[i] -param2[s<(udp|tcp):.*[/[0-9]+]?>] +optParam1[l{=-100}] ..

      Parameters:
      args - the command line arguments to match with the specified format patterns.

    • selectCommand

      public static String[] selectCommand(String[] args, String optionFormat, String[][] commandSets) throws ParseException
      Select a argument/parameter set from a given selection of sets by the command contained in the supplied argument list. The command is the first argument not starting with "-".
      Parameters:
      args - the argument list to scan.
      optionFormat - the option format which is common to all commands (or their super set)
      commandSets - the possible command sets, where each set is identified by its command string in the first element of the command set.
      Returns:
      the command set matching the command in the argument list.
      Throws:
      ParseException - if the command found in args cannot be found in the commandSets, or null if args does not contain any command.
      Since:
      1.10