object Parser

Low-level parsing functionality. See ArgumentParser for a user-friendly API.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Parser
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. case class ParamDef(names: Seq[String], parseAndSet: (String, Option[String]) => ParamResult, missing: () => Unit, isFlag: Boolean, repeatPositional: Boolean, endOfNamed: Boolean) extends Product with Serializable

    A parameter definition is the low-level building block to define the grammar of a command-line and its functionality.

    A parameter definition is the low-level building block to define the grammar of a command-line and its functionality.

    ParamDefs associate parameter names to actions that are invoked by Parser.parse().

    names

    All names that may be used by this parameter. If a name starts with -, it is considered a "named" parameter, otherwise it is considered a "positional" parameter. Arguments associated to named parameters may appear in any order on the command line, as long as they are prefixed by the parameter's name. Positional parameters are given arguments in the order they appear in. Special case for single-letter named parameters: one argument may specify multiple named parameters of a single letter. In this case, letters are read left to right, and the first non-flag parameter will consume the remaining letters. E.g. assume -i and -t are flags, and -I takes an argument, then -itIhello sets -i and -t and assigns hello to -I.

    parseAndSet

    A function that is invoked anytime this parameter is encountered on the command line. In case of a named param, the first element is the actual name used, and the second element is the argument or None if no argument followed. In case of a positional param, the parameter's first name is given and the argument value is always defined. This function must return either a Continue or Stop. The former will instruct the parser to continue parsing, whereas the latter will prevent any further argument parsing.

    missing

    A function that is invoked if this parameter has not been encountered at all.

    isFlag

    Indicates if this named parameter is a flag, i.e. one that never accepts an argument. In case its name is encountered, its value is set to "true". Has no effect on positional parameters.

    repeatPositional

    If this is a positional parameter, the parser will repeat it indefinitely.

    endOfNamed

    Treat all subsequent parameters as positionals, regardless of their name. This can be useful for constructing nested commands.

  2. sealed trait ParamResult extends AnyRef

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  8. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  9. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  10. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  12. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  14. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  15. def parse(params: Seq[ParamDef], args: Iterable[String], reportUnknown: (String) => Unit): Boolean

    Parse command line arguments according to some parameter definitions.

    Parse command line arguments according to some parameter definitions.

    The parser works in two passes.

    1. the first pass goes over all actual arguments and groups them into positional and named ones (and also detects any unknown arguments)

    2. the second pass then iterates over all parameter definitions, looks up the corresponding value from the previous pass, and calls the relevant functions of the parameter definition

    Delegating parameter invocation to a second pass allows for them to be evaluated in order of definition, rather than order of appearance on the command line. This is important to allow "breaking" parameters such as --help to be on a command line with other "side-effecting" params, but yet avoid executing part of the command line (of course this example assumes that the --help parameter was defined before any others).

    params

    the sequence of parameter definitions

    args

    the actual command-line arguments

    reportUnknown

    a function invoked when an extranous argument is encountered. An extranous argument can be either an unknown named argument, or a superfluous positional argument

    returns

    true if all arguments were parsed, false otherwise. In other words, returns true if no Stop was encountered while calling parameters' parseAndSet functions.

  16. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  17. def toString(): String
    Definition Classes
    AnyRef → Any
  18. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  19. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  20. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  21. case object Continue extends ParamResult with Product with Serializable

    Continue parsing of the next argument.

  22. case object Stop extends ParamResult with Product with Serializable

    Stops parsing in its track.

    Stops parsing in its track. No further arguments will not be parsed.

Inherited from AnyRef

Inherited from Any

Ungrouped