RhodeCode

  // Initialize the argument parser

  ArgParser ap(argc, argv);

  double d = 1.0;

  bool b, nh;

  bool g1, g2, g3;

  // Add a mandatory integer option with storage reference

  ap.refOption("n", "An integer input.", i, true);

  // Add a double option with storage reference (the default value is 1.0)

  ap.refOption("val", "A double input.", d);

  // Add a double option without storage reference (the default value is 3.14)

  ap.doubleOption("val2", "A double input.", 3.14);

  // Set synonym for -val option

  ap.synonym("vals", "val");

  // Add a string option

  ap.refOption("name", "A string input.", s);

  // Add bool options

  ap.refOption("f", "A switch.", b)

    .refOption("nohelp", "", nh)

    .refOption("gra", "Choice A", g1)

    .refOption("grb", "Choice B", g2)

    .refOption("grc", "Choice C", g3);

  // Bundle -gr* options into a group

  ap.optionGroup("gr", "gra")

    .optionGroup("gr", "grb")

    .optionGroup("gr", "grc");

  // Set the group mandatory

  ap.mandatoryGroup("gr");

  // Set the options of the group exclusive (only one option can be given)

  ap.onlyOneGroup("gr");

  // Add non-parsed arguments (e.g. input files)

  ap.other("infile", "The input file.")

  // Perform the parsing process

  // (in case of any error it terminates the program)

  // Check each option if it has been given and print its value

  std::cout << "  Value of -n: " << i << std::endl;

  if(ap.given("val2")) {

    d = ap["val2"];

    std::cout << "  Value of -val2: " << d << std::endl;

  }

  if(ap.given("nohelp")) std::cout << "  Value of -nohelp: " << nh << std::endl;

  return 0;

    ///Constructor

    ///\name Options

    ///

    ///@{

    ///Add a new integer type option.

    ///Add a new floating point type option.

    ///Add a new bool type option.

    ///Add a new string type option.

    ///Give help string for non-parsed arguments.

    ///With this function you can give help string for non-parsed arguments.

    ///The parameter \c name will be printed in the short usage line, while

    ///\c help gives a more detailed description.

    ArgParser &other(const std::string &name,

		     const std::string &help="");

    ///@}

    ///\name Options with External Storage

    ///Add a new integer type option with a storage reference.

    ///Add a new floating type option with a storage reference.

    ///Add a new bool type option with a storage reference.

    ///Add a new string type option with a storage reference.

    ///Bundle some options into a group

    ///given at the same time.

    ///Give back the command name (the 0th argument)

    const std::string &commandName() { return _command_name; }

    ///Give back the non-option type arguments.

    ///Give back a reference to a vector consisting of the program arguments

    ///not starting with a '-' character.

    std::vector<std::string> &files() { return _file_args; }

#endif // LEMON_ARG_PARSER