Peter M. Groen / cxxopts

Fixes 323. Adds a function to retrieve the program name.

Fixes #312.

Fixes #204.

* Support option value being attached after the option without a space in between. e.g. -j5

* Cmake Revamp

I needed to do a variety of things to ensure cxxopts worked well in my own project.

I created a new cmake module to abstract a lot of the logic in the main CMakelists.txt, I think it really assists in the readability of the project. Consequently a lot of logic is now written in functions.

I made a lot of the project options off by default unless the project is being built standalone. As a frequent consumer of cmake libraries this is a huge issue. Since examples, tests, installation, etc. aren't things I expect/desired by default when using libraries.

Co-authored-by: Juan Ramos <juanr0911@gmail.com>

…ic flags are set (#238)

Makes some fixes to satisfy various strict warnings.

Fixes #257. The input array is not modified, so we can declare this as
`char const* const*`.

Major refactor of the parsing code organisation to improve encapsulation
and not modify the input arguments. The returned result no longer has
pointers into the original option specification.

`cxxopts` doesn't modify the contents of the argv strings. This changes
the parse function to take a reference to a `const char**`.

* Fixes #245:

* Added a new exception type: `option_has_no_value_exception`; throwing it when an option has no value we can cast with `as()`, instead of an `std::domain_error`.
* The `OptionValue` type now holds a pointer to the long option name (in its corresponding key within ParseResults's `m_results` field.

Fixes #197. Don't parse default options twice when there is a short and
long option.

Allow adding options with a single initializer list.

Improve parsing into std::vector so that a single argument can take a list.

* Parse 1 as "true" and 0 as "false" for boolean options.

Fixes #171. Allows invalid syntax for short options to be ignored.

Fixes #169. It seems reasonable to throw an exception when an attempt is
made to parse into positional parameters that don't exist.

g++ 8.2.0 refuses to compile the test suite because of polymorphic types
that are caught by value. They shall be caught by reference instead.

Fixes #124.

Fixes #101. Allows leading zeroes in the integer parser.

Allows unrecognised options to be left alone by the parser without throwing an exception.

This reverts commit 0f819a5cabb611ada4c41a5208c6bf1178f804be.

* Added const to argv type for better interoperability.

Fixes #93. This adds C++17 only support for `std::optional` values for
command line parameters.

Fixes #96. Default values of options not specified on the command line
had a `count` of 1. It would be better if they had a count of 0 because
they were not actually specified, so that count is only for options
given by the user.

* Add default "default" value of "false" to boolean options, therefore allowing to call result["boolOpt"].as<bool>() without throwing an exception.

Fixes #83.

Adds an overload for positional arguments taking a
`std::initializer_list`. When using an `initializer_list` with one
argument, the function call is ambiguous matching both `std::string`
and `std::vector<std::string>`.

Fixes #84. Implicit values are not handled very well. For example:

    --foo false true
    --foo --bar

In the first, `false` is an argument to `--foo`, and then `true` is a
positional argument. In the second, because of the hyphen in `--bar`, `--foo`
is parsed with its implicit value. This seems inconsistent and unintuitive.

Better is that implicit values *never* consume the next parameter to be
completely consistent. This means that values with an implicit parameter
*must* be specified using the `--option=value` form.

The parsing for boolean options was broken by 6c9bae4a07 which added implicit
and default values, and the ability to parse boolean strings. Having an option
after the boolean tried to parse that into the boolean instead of as a
positional parameter.

See #84 for the bug report.

Fixes #54. Allow default and implicit values for booleans with multiple
boolean strings matched as values.

Fixes #74.

* Prevent malformed numbers from being parsed as correct numbers.

Fixes #78. If you passed a string for example "test" it would get parsed to 1400.
The problem was that the parser did not throw an exception when an incorrect char was encountered.
Also a number without 0x in front with hexadecimal digits in it got parsed.
The number was treated as a hexadecimal number but it was still calculated with base 10.
So now before the current char is used, it is checked if it is valid in the current base.
Furthermore the number 0x0 was not a valid number, it now is a special case in the `integer_pattern`.

* Fixed `integer_pattern` so it works correctly under clang. Added testcase for invalid integers and for 0x0 being a valid number.