ArgumentParser (Apache OpenNLP :: API 3.0.0-M4 API)
Description: declaration: package: opennlp.tools.cmdline, class: ArgumentParser

Package opennlp.tools.cmdline

# Class ArgumentParser

java.lang.Object
opennlp.tools.cmdline.ArgumentParser

@Internal public class ArgumentParser extends Object
Parser for command line arguments. The parser creates a dynamic proxy which can be access via a command line argument interface.

The command line argument proxy interface must follow these conventions:
- Methods do not define arguments
- Method names must start with get
- Allowed return types are Integer, Long, Boolean, String, File and Charset.

Note: Do not use this class, internal use only!

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static @interface`
  `ArgumentParser.OptionalParameter`
  `static @interface`
  `ArgumentParser.ParameterDescription`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static List<opennlp.tools.cmdline.ArgumentParser.Argument>`
  `createArguments(Class<?>... argProxyInterfaces)`
  Outputs the arguments as a data structure, so it can be used to create documentation.
  `static String`
  `createUsage(Class<?>... argProxyInterfaces)`
  Creates a usage string which can be printed in case the user did specify the arguments incorrectly.
  `static <T> String`
  `createUsage(Class<T> argProxyInterface)`
  Creates a usage string which can be printed in case the user did specify the arguments incorrectly.
  `static <T> String[]`
  `filter(String[] args, Class<T> argProxyInterface)`
  Filters arguments leaving only those pertaining to `argProxyInterface`.
  `static <T> T`
  `parse(String[] args, Class<T> argProxyInterface)`
  Parses the passed arguments and creates an instance of the proxy interface.
  `static boolean`
  `validateArguments(String[] args, Class<?>... argProxyInterfaces)`
  Tests if the argument are correct or incorrect.
  `static <T> boolean`
  `validateArguments(String[] args, Class<T> argProxyInterface)`
  Tests if the argument are correct or incorrect.
  `static String`
  `validateArgumentsLoudly(String[] args, Class<?> argProxyInterface)`
  Tests if the arguments are correct or incorrect.
  `static String`
  `validateArgumentsLoudly(String[] args, Class<?>... argProxyInterfaces)`
  Tests if the arguments are correct or incorrect.

  ### Methods inherited from class java.lang.Object

  `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Method Details

  - ### createUsage

    public static <T> String createUsage(Class<T> argProxyInterface)
    Creates a usage string which can be printed in case the user did specify the arguments incorrectly. Incorrectly is defined as `validateArguments(String[], Class)` returns `false`.
    Parameters:
      `argProxyInterface` - interface with parameter descriptions
    Returns:
      the help message usage string

  - ### createArguments

    public static List<opennlp.tools.cmdline.ArgumentParser.Argument> createArguments(Class<?>... argProxyInterfaces)
    Outputs the arguments as a data structure, so it can be used to create documentation.
    Parameters:
      `argProxyInterfaces` - interfaces with parameter descriptions
    Returns:
      the help message usage string

  - ### createUsage

    public static String createUsage(Class<?>... argProxyInterfaces)
    Creates a usage string which can be printed in case the user did specify the arguments incorrectly. Incorrectly is defined as `validateArguments(String[], Class[])` returns `false`.
    Parameters:
      `argProxyInterfaces` - interfaces with parameter descriptions
    Returns:
      the help message usage string

  - ### validateArguments

    public static <T> boolean validateArguments(String[] args, Class<T> argProxyInterface)
    Tests if the argument are correct or incorrect. Incorrect means, that mandatory arguments are missing or there are unknown arguments. The argument value itself can also be incorrect, but this is checked by the `parse(String[], Class)` method and reported accordingly.
    Parameters:
      `args` - command line arguments
      `argProxyInterface` - interface with parameters description
    Returns:
      `true` if arguments are valid, `false otherwise`

  - ### validateArguments

    public static boolean validateArguments(String[] args, Class<?>... argProxyInterfaces)
    Tests if the argument are correct or incorrect. Incorrect means, that mandatory arguments are missing or there are unknown arguments. The argument value itself can also be incorrect, but this is checked by the `parse(String[], Class)` method and reported accordingly.
    Parameters:
      `args` - command line arguments
      `argProxyInterfaces` - interfaces with parameters description
    Returns:
      `true` if arguments are valid, `false otherwise`

  - ### validateArgumentsLoudly

    public static String validateArgumentsLoudly(String[] args, Class<?> argProxyInterface)
    Tests if the arguments are correct or incorrect.
    Parameters:
      `args` - command line arguments
      `argProxyInterface` - interface with parameters description
    Returns:
      `null`, if arguments are valid or error message otherwise

  - ### validateArgumentsLoudly

    public static String validateArgumentsLoudly(String[] args, Class<?>... argProxyInterfaces)
    Tests if the arguments are correct or incorrect.
    Parameters:
      `args` - command line arguments
      `argProxyInterfaces` - interfaces with parameters description
    Returns:
      `null`, if arguments are valid or error message otherwise

  - ### parse

    public static <T> T parse(String[] args, Class<T> argProxyInterface)
    Parses the passed arguments and creates an instance of the proxy interface.

    In case an argument value cannot be parsed a `TerminateToolException` is thrown which contains an error message which explains the problems.

    Parameters:
      `args` - arguments
      `argProxyInterface` - interface with parameters description
    Returns:
      parsed parameters
    Throws:
      `TerminateToolException` - if an argument value cannot be parsed.
      `IllegalArgumentException` - if validateArguments returns `false`, if the proxy interface is not compatible.

  - ### filter

    public static <T> String[] filter(String[] args, Class<T> argProxyInterface)
    Filters arguments leaving only those pertaining to `argProxyInterface`.
    Type Parameters:
      `T` - T
    Parameters:
      `args` - arguments
      `argProxyInterface` - interface with parameters description
    Returns:
      arguments pertaining to `argProxyInterface`