Moving tutorial docs (#304)

Henry Schreiner · GitHub
1 parent cf4933db
Showing 24 changed files with 5853 additions and 1 deletions
.travis.yml
book/.gitignore
book/README.md
book/SUMMARY.md
book/book.json
book/chapters/advanced-topics.md
book/chapters/an-advanced-example.md
book/chapters/basics.md
book/chapters/config.md
book/chapters/flags.md
book/chapters/formatting.md
book/chapters/installation.md
book/chapters/internals.md
book/chapters/options.md
book/chapters/subcommands.md
book/chapters/toolkits.md
book/chapters/validators.md
book/code/CLI11.hpp
book/code/CMakeLists.txt
book/code/flags.cpp
@@ -25,6 +25,8 @@ matrix:
  
     # Docs and clang 3.5
   - compiler: clang
+    language: node_js
+    node_js: "7.4.0"
     env:
     - DEPLOY_MAT=yes
     addons:
@@ -34,6 +36,9 @@ matrix:
     install:
     - export CC=clang-3.5
     - export CXX=clang++-3.5
+    - npm install gitbook-cli -g
+    - gitbook fetch 3.2.3
+    - (cd book && gitbook install)
     script:
     - .ci/make_and_test.sh 11
     after_success:
@@ -45,6 +50,7 @@ matrix:
         . .ci/build_doxygen.sh
         .ci/build_docs.sh
       fi
+    - (cd book && gitbook build . ../docs/html/book)
  
     # GCC 7 and coverage (8 does not support lcov, wait till 9 and new lcov)
   - compiler: gcc
+# Node rules:
+## Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+## Dependency directory
+## Commenting this out is preferred by some people, see
+## https://docs.npmjs.com/misc/faq#should-i-check-my-node_modules-folder-into-git
+node_modules
+
+# Book build output
+_book
+
+# eBook build output
+*.epub
+*.mobi
+*.pdf
+
+a.out
+
+*build*
+# CLI11: An introduction
+
+This gitbook is designed to provide an introduction to using the CLI11 library to write your own command line programs. The library is designed to be clean, intuitive, but powerful. There are no requirements beyond C++11 support (and even `<regex>` support not required). It works on Mac, Linux, and Windows, and has 100% test coverage on all three systems. You can simply drop in a single header file (`CLI11.hpp` available in [releases]) to use CLI11 in your own application. Other ways to integrate it into a build system are listed in the [README].
+
+The library was inspired the Python libraries [Plumbum] and [Click], and incorporates many of their user friendly features. The library is extensively documented, with a [friendly introduction][README], this tutorial book, and more technical [API docs].
+
+> Feel free to contribute to [this documentation here][CLI11Tutorial] if something can be improved!
+
+The syntax is simple and scales from a basic application to a massive physics analysis with multiple models and many parameters and switches. For example, this is a simple program that has an optional parameter that defaults to 1:
+
+```term
+gitbook $ ./a.out
+Parameter value: 0
+
+gitbook $ ./a.out -p 4
+Parameter value: 4
+
+gitbook $ ./a.out --help
+App description
+Usage: ./a.out [OPTIONS]
+
+Options:
+  -h,--help                   Print this help message and exit
+  -p INT                      Parameter
+```
+
+Like any good command line application, help is provided. This program can be implemented in 10 lines:
+
+[include](code/intro.cpp)
+
+[Source code](https://gitlab.com/CLIUtils/CLI11Tutorial/blob/master/code/intro.cpp)
+
+Unlike some other libraries, this is enough to exit correctly and cleanly if help is requested or if incorrect arguments are passed. You can try this example out for yourself. To compile with GCC:
+
+```term
+gitbook:examples $ c++ -std=c++11 intro.cpp
+```
+
+Much more complicated options are handled elegantly:
+
+```cpp
+std::string req_real_file;
+app.add_option("-f,--file", file, "Require an existing file")
+  ->required()
+  ->check(CLI::ExistingFile);
+```
+
+You can use any valid type; the above example could have used a `boost::file_system` file instead of a `std::string`. The value is a real value and does not require any special lookups to access. You do not have to risk typos by repeating the values after parsing like some libraries require. The library also handles positional arguments, flags, fixed or unlimited repeating options, interdependent options, flags, custom validators, help groups, and more.
+
+You can use subcommands, as well. Subcommands support callback lambda functions when parsed, or they can be checked later. You can infinitely nest subcommands, and each is a full `App` instance, supporting everything listed above.
+
+Reading/producing `.ini` files for configuration is also supported, as is using environment variables as input. The base `App` can be subclassed and customized for use in a toolkit (like [GooFit]). All the standard shell idioms, like `--`, work as well.
+
+CLI11 was developed at the [University of Cincinnati] in support of the [GooFit] library under [NSF Award 1414736][NSF 1414736]. It was featured in a [DIANA/HEP] meeting at CERN. Please give it a try! Feedback is always welcome.
+
+This guide was based on CLI11 1.7.
+
+[GooFit]: https://github.com/GooFit/GooFit
+[DIANA/HEP]: http://diana-hep.org
+[CLI11]: https://github.com/CLIUtils/CLI11
+[CLI11Tutorial]: https://gitlab.com/CLIUtils/CLI11Tutorial
+[releases]: https://github.com/CLIUtils/CLI11/releases
+[API docs]: https://cliutils.github.io/CLI11
+[README]: https://github.com/CLIUtils/CLI11/blob/master/README.md
+[NSF 1414736]: https://nsf.gov/awardsearch/showAward?AWD_ID=1414736
+[University of Cincinnati]: http://www.uc.edu
+[Plumbum]: http://plumbum.readthedocs.io/en/latest/
+[Click]: http://click.pocoo.org/5/
+
+
+
+# Summary
+
+* [Introduction](/README.md)
+* [Installation](/chapters/installation.md)
+* [Basics](/chapters/basics.md)
+* [Flags](/chapters/flags.md)
+* [Options](/chapters/options.md)
+* [Validators](/chapters/validators.md)
+* [Subcommands and the App](/chapters/subcommands.md)
+* [An advanced example](/chapters/an-advanced-example.md)
+* [Configuration files](/chapters/config.md)
+* [Formatting help output](/chapters/formatting.md)
+* [Toolkits](/chapters/toolkits.md)
+* [Advanced topics](/chapters/advanced-topics.md)
+* [Internals](/chapters/internals.md)
+
+{
+"title": "CLI11 Tutorial",
+"description": "A set of examples and detailed information about CLI11",
+"author": "Henry Schreiner",
+"plugins": [
+        "include-codeblock",
+        "term",
+        "hints"
+    ],
+"pluginsConfig": {
+        "include-codeblock": {
+            "unindent": true,
+            "fixlang": true
+        }
+    }
+}
+# Advanced topics
+
+
+## Environment variables
+
+Environment variables can be used to fill in the value of an option:
+
+```cpp
+std::string opt;
+app.add_option("--my_option", opt)->envname("MY_OPTION");
+```
+If not given on the command line, the environment variable will be checked and read from if it exists. All the standard tools, like default and required, work as expected.
+If passed on the command line, this will ignore the environment variable.
+
+## Needs/excludes
+
+You can set a network of requirements. For example, if flag a needs flag b but cannot be given with flag c, that would be:
+
+```cpp
+auto a = app.add_flag("-a");
+auto b = app.add_flag("-b");
+auto c = app.add_flag("-c");
+
+a->needs(b);
+a->excludes(c);
+```
+
+CLI11 will make sure your network of requirements makes sense, and will throw an error immediately if it does not.
+
+## Custom option callbacks
+
+You can make a completely generic option with a custom callback. For example, if you wanted to add a complex number (already exists, so please don't actually do this):
+
+```cpp
+CLI::Option *
+add_option(CLI::App &app, std::string name, cx &variable, std::string description = "", bool defaulted = false) {
+    CLI::callback_t fun = [&variable](CLI::results_t res) {
+        double x, y;
+        bool worked = CLI::detail::lexical_cast(res[0], x) && CLI::detail::lexical_cast(res[1], y);
+        if(worked)
+            variable = cx(x, y);
+        return worked;
+    };
+
+    CLI::Option *opt = app.add_option(name, fun, description, defaulted);
+    opt->set_custom_option("COMPLEX", 2);
+    if(defaulted) {
+        std::stringstream out;
+        out << variable;
+        opt->set_default_str(out.str());
+    }
+    return opt;
+}
+```
+
+Then you could use it like this:
+
+```
+std::complex<double> comp{0, 0};
+add_option(app, "-c,--complex", comp);
+```
+
+## Custom converters
+
+You can add your own converters to allow CLI11 to accept more option types in the standard calls. These can only be used for "single" size options (so complex, vector, etc. are a separate topic). If you set up a custom `istringstream& operator <<` overload before include CLI11, you can support different conversions. If you place this in the CLI namespace, you can even keep this from affecting the rest of your code. Here's how you could add `boost::optional` for a compiler that does not have `__has_include`:
+
+```cpp
+// CLI11 already does this if __has_include is defined
+#ifndef __has_include
+
+#include <boost/optional.hpp>
+
+// Use CLI namespace to avoid the conversion leaking into your other code
+namespace CLI {
+
+template <typename T> std::istringstream &operator>>(std::istringstream &in, boost::optional<T> &val) {
+    T v;
+    in >> v;
+    val = v;
+    return in;
+}
+
+}
+
+#endif
+
+#include <CLI11.hpp>
+```
+
+This is an example of how to use the system only; if you are just looking for a way to activate `boost::optional` support on older compilers, you should define `CLI11_BOOST_OPTIONAL` before including a CLI11 file, you'll get the `boost::optional` support.
+
+
+## Custom converters and type names: std::chrono example
+
+An example of adding a custom converter and typename for `std::chrono` follows:
+
+```cpp
+namespace CLI
+{
+	template <typename T, typename R>
+	std::istringstream &operator>>(std::istringstream &in, std::chrono::duration<T,R> &val)
+	{
+		T v;
+		in >> v;
+		val = std::chrono::duration<T,R>(v);
+		return in;
+	}
+
+	template <typename T, typename R>
+	std::stringstream &operator<<(std::stringstream &in, std::chrono::duration<T,R> &val)
+	{
+		in << val.count();
+		return in;
+	}
+ }
+
+#include <CLI/CLI.hpp>
+
+namespace CLI
+{
+	namespace detail
+	{
+		template <>
+		constexpr const char *type_name<std::chrono::hours>()
+		{
+			return "TIME [H]";
+		}
+
+		template <>
+		constexpr const char *type_name<std::chrono::minutes>()
+		{
+			return "TIME [MIN]";
+		}
+        }
+}
+```
+
+Thanks to Olivier Hartmann for the example.
+# Making a git clone
+
+
+
+Let's try our hand at a little `git` clone, called `geet`. It will just print it's intent, rather than running actual code, since it's just a demonstration. Let's start by adding an app and requiring 1 subcommand to run:
+
+[include:"Intro"](../code/geet.cpp)
+
+Now, let's define the first subcommand, `add`, along with a few options:
+
+[include:"Add"](../code/geet.cpp)
+
+Now, let's add `commit`:
+
+[include:"Commit"](../code/geet.cpp)
+
+All that's need now is the parse call. We'll print a little message after the code runs, and then return:
+
+[include:"Parse"](../code/geet.cpp)
+
+[Source code](https://gitlab.com/CLIUtils/CLI11Tutorial/blob/master/code/flags.cpp)
+
+If you compile and run:
+
+```term
+gitbook:examples $ c++ -std=c++11 geet.cpp -o geet
+```
+
+You'll see it behaves pretty much like `git`.
+
+## Multi-file App parse code
+
+This example could be made much nicer if it was split into files, one per subcommand. If you simply use shared pointers instead of raw values in the lambda capture, you can tie the lifetime to the lambda function lifetime.  CLI11 has a multifile example in its example folder.
+# The Basics
+
+The simplest CLI11 program looks like this:
+
+[include](../code/simplest.cpp)
+
+The first line includes the library; this explicitly uses the single file edition (see [Selecting an edition](/chapters/installation)).
+
+After entering the main function, you'll see that a `CLI::App` object is created. This is the basis for all interactions with the library. You could optionally provide a description for your app here.
+
+A normal CLI11 application would define some flags and options next. This is a simplest possible example, so we'll go on.
+
+The macro `CLI11_PARSE` just runs five simple lines. This internally runs `app.parse(argc, argv)`, which takes the command line info from C++ and parses it. If there is an error, it throws a `ParseError`; if you catch it, you can use `app.exit` with  the error as an argument to print a nice message and produce the correct return code for your application.
+
+If you just use `app.parse` directly, your application will still work, but the stack will not be correctly unwound since you have an uncaught exception, and the command line output will be cluttered, especially for help.
+
+For this (and most of the examples in this book) we will assume that we have the `CLI11.hpp` file in the current directory and that we are creating an output executable `a.out` on a macOS or Linux system. The commands to compile and test this example would be:
+
+```term
+gitbook:examples $ g++ -std=c++11 simplest.cpp
+gitbook:examples $ ./a.out -h
+Usage: ./a.out [OPTIONS]
+
+Options:
+  -h,--help                   Print this help message and exit
+```
+
+# Accepting configure files
+
+## Reading a configure file
+
+You can tell your app to allow configure files with `set_config("--config")`. There are arguments: the first is the option name. If empty, it will clear the config flag. The second item is the default file name. If that is specified, the config will try to read that file. The third item is the help string, with a reasonable default, and the final argument is a boolean (default: false) that indicates that the configuration file is required and an error will be thrown if the file
+is not found and this is set to true.
+
+## Configure file format
+
+Here is an example configuration file, in INI format:
+
+```ini
+; Commments are supported, using a ;
+; The default section is [default], case insensitive
+
+value = 1
+str = "A string"
+vector = 1 2 3
+
+; Section map to subcommands
+[subcommand]
+in_subcommand = Wow
+sub.subcommand = true
+```
+
+Spaces before and after the name and argument are ignored. Multiple arguments are separated by spaces. One set of quotes will be removed, preserving spaces (the same way the command line works). Boolean options can be `true`, `on`, `1`, `yes`; or `false`, `off`, `0`, `no` (case insensitive). Sections (and `.` separated names) are treated as subcommands (note: this does not mean that subcommand was passed, it just sets the "defaults".
+
+## Writing out a configure file
+
+To print a configuration file from the passed arguments, use `.config_to_str(default_also=false, prefix="", write_description=false)`, where `default_also` will also show any defaulted arguments, `prefix` will add a prefix, and `write_description` will include option descriptions.
+
+## Custom formats
+
+{% hint style='info' %}
+New in CLI11 1.6
+{% endhint %}
+
+You can invent a custom format and set that instead of the default INI formatter. You need to inherit from `CLI::Config` and implement the following two functions:
+
+```cpp
+std::string to_config(const CLI::App *app, bool default_also, bool, std::string) const;
+std::vector<CLI::ConfigItem> from_config(std::istream &input) const;
+```
+
+The `CLI::ConfigItem`s that you return are simple structures with a name, a vector of parents, and a vector of results. A optionally customizable `to_flag` method on the formatter lets you change what happens when a ConfigItem turns into a flag.
+
+Finally, set your new class as new config formatter: 
+
+```cpp
+app.config_formatter(std::make_shared<NewConfig>());
+```
+
+See [`examples/json.cpp`](https://github.com/CLIUtils/CLI11/blob/master/examples/json.cpp) for a complete JSON config example. 
+# Adding Flags
+
+The most basic addition to a command line program is a flag. This is simply something that does not take any arguments. Adding a flag in CLI11 is done in one of three ways.
+
+## Boolean flags
+
+The simplest way to add a flag is probably a boolean flag:
+
+```cpp
+bool my_flag;
+app.add_flag("-f", my_flag, "Optional description");
+```
+
+This will bind the flag `-f` to the boolean `my_flag`. After the parsing step, `my_flag` will be `false` if the flag was not found on the command line, or `true` if it was. By default, it will be allowed any number of times, but if you explicitly[^1] request `->take_last(false)`, it will only be allowed once; passing something like `./my_app -f -f` or `./my_app -ff` will throw a `ParseError` with a nice help description.
+
+
+## Integer flags
+
+If you want to allow multiple flags, simply use any integer-like instead of a bool:
+
+```cpp
+int my_flag;
+app.add_flag("-f", my_flag, "Optional description");
+```
+
+After the parsing step, `my_flag` will contain the number of times this flag was found on the command line, including 0 if not found.
+
+## Pure flags
+
+Every command that starts with `add_`, such as the flag commands, return a pointer to the internally stored `CLI::Option` that describes your addition. If you prefer, you can capture this pointer and use it, and that allows you to skip adding a variable to bind to entirely:
+
+```cpp
+CLI::Option* my_flag = app.add_flag("-f", "Optional description");
+```
+
+After parsing, you can use `my_flag->count()` to count the number of times this was found. You can also directly use the value (`*my_flag`) as a bool. `CLI::Option` will be discussed in more detail later.
+
+## Callback flags
+
+If you want to define a callback that runs when you make a flag, you can use `add_flag_function` (C++11 or newer) or `add_flag` (C++14 or newer only) to add a callback function. The function should have the signature `void(size_t)`. This could be useful for a version printout, etc.
+
+```
+auto callback = [](int count){std::cout << "This was called " << count << " times";};
+app.add_flag_function("-c", callback, "Optional description");
+```
+
+
+## Aliases
+
+The name string, the first item of every `add_` method, can contain as many short and long names as you want, separated by commas. For example, `"-a,--alpha,-b,--beta"` would allow any of those to be recognized on the command line. If you use the same name twice, or if you use the same name in multiple flags, CLI11 will immediately throw a `CLI::ConstructionError` describing your problem (it will not wait until the parsing step).
+
+If you want to make an option case insensitive, you can use the `->ignore_case()` method on the `CLI::Option` to do that. For example,
+
+```cpp
+bool flag;
+app.add_flag("--flag", flag)
+    ->ignore_case();
+```
+
+would allow the following to count as passing the flag:
+
+```term
+gitbook $ ./my_app --fLaG
+```
+
+## Example
+
+The following program will take several flags:
+
+[include:"define"](../code/flags.cpp)
+
+The values would be used like this:
+
+[include:"usage"](../code/flags.cpp)
+
+[Source code](https://gitlab.com/CLIUtils/CLI11Tutorial/blob/master/code/flags.cpp) 
+
+If you compile and run:
+
+```term
+gitbook:examples $ g++ -std=c++11 flags.cpp
+gitbook:examples $ ./a.out -h
+Flag example program
+Usage: ./a.out [OPTIONS]
+
+Options:
+  -h,--help                   Print this help message and exit
+  -b,--bool                   This is a bool flag
+  -i,--int                    This is an int flag
+  -p,--plain                  This is a plain flag
+
+gitbook:examples $ ./a.out -bii --plain -i
+The flags program
+Bool flag passed
+Flag int: 3
+Flag plain: 1
+```
+
+
+[^1] It will not inherit this from the parent defaults, since this is often useful even if you don't want all options to allow multiple passed options.
+# Formatting help output
+
+{% hint style='info' %}
+New in CLI11 1.6
+{% endhint %}
+
+##  Customizing an existing formatter
+
+In CLI11, you can control the output of the help printout in full or in part. The default formatter was written in such a way as to be customizable. You can use `app.get_formatter()` to get the current formatter. The formatter you set will be inherited by subcommands that are created after you set the formatter.
+
+There are several configuration options that you can set:
+
+
+| Set method | Description | Availability |
+|------------|-------------|--------------|
+| `column_width(width)` | The width of the columns | Both |
+| `label(key, value)` | Set a label to a different value | Both |
+
+Labels will map the built in names and type names from key to value if present. For example, if you wanted to change the width of the columns to 40 and the `REQUIRED` label from `(REQUIRED)` to `(MUST HAVE)`:
+
+```cpp
+app.get_formatter()->column_width(40);
+app.get_formatter()->label("REQUIRED", "(MUST HAVE)");
+```
+
+## Subclassing
+
+You can further configure pieces of the code while still keeping most of the formatting intact by subclassing either formatter and replacing any of the methods with your own. The formatters use virtual functions most places, so you are free to add or change anything about them. For example, if you wanted to remove the info that shows up between the option name and the description:
+
+```cpp
+class MyFormatter : public CLI::Formatter {
+  public:
+    std::string make_opts(const CLI::Option *) const override {return "";}
+};
+app.formatter(std::make_shared<MyFormatter>());
+```
+
+Look at the class definitions in `FormatterFwd.hpp` or the method definitions in `Formatter.hpp` to see what methods you have access to and how they are put together.
+
+## Anatomy of a help message
+
+This is a normal printout, with `<>` indicating the methods used to produce each line.
+
+```
+<make_description(app)>
+<make_usage(app)>
+<make_positionals(app)>
+  <make_group(app, "Positionals", true, filter>
+<make_groups(app, mode)>
+  <make_group(app, "Option Group 1"), false, filter>
+  <make_group(app, "Option Group 2"), false, filter>
+  ...
+<make_subcommands(app)>
+  <make_subcommand(sub1, Mode::Normal)> 
+  <make_subcommand(sub2, Mode::Normal)>
+<make_footer(app)>
+```
+
+`make_usage` calls `make_option_usage(opt)` on all the positionals to build that part of the line. `make_subcommand` passes the subcommand as the app pointer.
+
+The `make_groups` print the group name then call `make_option(o)` on the options listed in that group. The normal printout for an option looks like this:
+
+```
+        make_option_opts(o) 
+            ┌───┴────┐  
+ -n,--name  (REQUIRED)      This is a description 
+└────┬────┘                └──────────┬──────────┘ 
+make_option_name(o,p)        make_option_desc(o)
+```
+
+Notes:
+
+* `*1`: This signature depends on whether the call is from a positional or optional.
+* `o` is opt pointer, `p` is true if positional.
+
+
+
+
+# Installation 
+
+## Single file edition
+
+```cpp
+#include <CLI11.hpp>
+```
+
+This example uses the single file edition of CLI11. You can download `CLI11.hpp` from the latest release and put it into the same folder as your source code, then compile this with C++ enabled. For a larger project, you can just put this in an include folder and you are set.
+
+## Full edition
+
+```cpp
+#include <CLI/CLI.hpp>
+```
+
+If you want to use CLI11 in its full form, you can also use the original multiple file edition. This has an extra utility (`Timer`), and is does not require that you use a release. The only change to your code would be the include shown above.
+
+### CMake support for the full edition
+
+If you use CMake 3.4+ for your project (highly recommended), CLI11 comes with a powerful CMakeLists.txt file that was designed to also be used with `add_subproject`. You can add the repository to your code (preferably as a git submodule), then add the following line to your project (assuming your folder is called CLI11):
+
+```cmake
+add_subdirectory(CLI11)
+```
+
+Then, you will have a target `CLI11::CLI11` that you can link to with `target_link_libraries`. It will provide the include paths you need for the library. This is the way [GooFit](https://github.com/GooFit/GooFit) uses CLI11, for example.
+
+You can also configure and optionally install CLI11, and CMake will create the necessary `lib/cmake/CLI11/CLI11Config.cmake` files, so `find_package(CLI11 CONFIG REQUIRED)` also works.
+
+If you use conan.io, CLI11 supports that too.
+
+### Running tests on the full edition
+
+CLI11 has examples and tests that can be accessed using a CMake build on any platform. Simply build and run ctest to run the 200+ tests to ensure CLI11 works on your system.
+
+As an example of the build system, the following code will download and test CLI11 in a simple Alpine Linux docker container [^1]:
+
+```term
+gitbook:~ $ docker run -it alpine
+root:/ # apk add --no-cache g++ cmake make git
+fetch ...
+root:/ # git clone https://github.com/CLIUtils/CLI11.git
+Cloning into 'CLI11' ...
+root:/ # cd CLI11
+root:CLI11 # mkdir build
+root:CLI11 # cd build
+root:build # cmake ..
+-- The CXX compiler identification is GNU 6.3.0 ...
+root:build # make
+Scanning dependencies ...
+root:build # make test
+[warning]Running tests... 
+Test project /CLI11/build
+      Start  1: HelpersTest
+ 1/10 Test  #1: HelpersTest ......................   Passed    0.01 sec
+      Start  2: IniTest
+ 2/10 Test  #2: IniTest ..........................   Passed    0.01 sec
+      Start  3: SimpleTest
+ 3/10 Test  #3: SimpleTest .......................   Passed    0.01 sec
+      Start  4: AppTest
+ 4/10 Test  #4: AppTest ..........................   Passed    0.02 sec
+      Start  5: CreationTest
+ 5/10 Test  #5: CreationTest .....................   Passed    0.01 sec
+      Start  6: SubcommandTest
+ 6/10 Test  #6: SubcommandTest ...................   Passed    0.01 sec
+      Start  7: HelpTest
+ 7/10 Test  #7: HelpTest .........................   Passed    0.01 sec
+      Start  8: NewParseTest
+ 8/10 Test  #8: NewParseTest .....................   Passed    0.01 sec
+      Start  9: TimerTest
+ 9/10 Test  #9: TimerTest ........................   Passed    0.24 sec
+      Start 10: link_test_2
+10/10 Test #10: link_test_2 ......................   Passed    0.00 sec
+
+100% tests passed, 0 tests failed out of 10
+
+Total Test time (real) =   0.34 sec
+```
+
+For the curious, the CMake options and defaults are listed below. Most options default to off if CLI11 is used as a subdirectory in another project.
+
+| Option | Description |
+|--------|-------------|
+| `CLI11_SINGLE_FILE=ON` | Build the `CLI11.hpp` file from the sources. Requires Python (version 3 or 2.7). |
+| `CLI11_SINGLE_FILE_TESTS=OFF` | Run the tests on the generated single file version as well |
+| `CLI11_EXAMPLES=ON` | Build the example programs. |
+| `CLI11_TESTING=ON` | Build the tests. |
+| `CLANG_TIDY_FIX=OFF` | Run `clang-tidy` on the examples and headers and apply fixes. (Changes source code!) Requires LLVM and CMake 3.6+. |
+
+[^1]: Docker is being used to create a pristine disposable environment; there is nothing special about this container. Alpine is being used because it is small, modern, and fast. Commands are similar on any other platform.
+# CLI11 Internals
+
+## Callbacks
+
+The library was designed to bind to existing variables without requiring typed classes or inheritance. This is accomplished through lambda functions.
+
+This looks like:
+
+```cpp
+Option* add_option(string name, T item) {
+    this->function = [&item](string value){
+        item = detail::lexical_cast<T>(value);
+    }
+}
+```
+
+Obviously, you can't access `T` after the `add_` method is over, so it stores the string representation of the default value if it receives the special `true` value as the final argument (not shown above).
+
+## Parsing
+
+Parsing follows the following procedure:
+
+1. `_validate`: Make sure the defined options are self consistent.
+2. `_parse`: Main parsing routine. See below.
+3. `_run_callback`: Run an App callback if present.
+
+The parsing phase is the most interesting:
+
+1. `_parse_single`: Run on each entry on the command line and fill the options/subcommands.
+2. `_process`: Run the procedure listed below.
+3. `_process_extra`: This throws an error if needed on extra arguments that didn't fit in the parse.
+
+The `_process` procedure runs the following steps; each step is recursive and completes all subcommands before moving to the next step (new in 1.7). This ensures that interactions between options and subcommand options is consistent.
+
+1. `_process_ini`: This reads an INI file and fills/changes options as needed.
+2. `_process_env`: Look for environment variables.
+3. `_process_callbacks`: Run the callback functions - this fills out the variables.
+4. `_process_help_flags`: Run help flags if present (and quit).
+5. `_process_requirements`: Make sure needs/excludes, required number of options present.
+
+## Exceptions
+
+The library immediately returns a C++ exception when it detects a problem, such as an incorrect construction or a malformed command line.
+
+
+# Options
+
+## Simple options
+The most versatile addition to a command line program is a option. This is like a flag, but it takes an argument. CLI11 handles all the details for many types of options for you, based on their type. To add an option:
+
+
+```cpp
+int int_option;
+app.add_option("-i", int_option, "Optional description");
+```
+
+This will bind the option `-i` to the integer `int_option`. On the command line, a single value that can be converted to an integer will be expected. Non-integer results will fail. If that option is not given, CLI11 will not touch the initial value. This allows you to set up defaults by simply setting your value beforehand. If you want CLI11 to display your default value, you can add the optional final argument `true` when you add the option. If you do not add this, you do not even need your option value to be printable[^1].
+
+```cpp
+int int_option = 0;
+app.add_option("-i", int_option, "Optional description", true);
+```
+
+You can use any C++ int-like type, not just `int`. CLI11 understands the following categories of types:
+
+| Type        | CLI11 |
+|-------------|-------|
+| int-like    | Integer conversion up to 64-bit, can be unsigned | 
+| float-like  | Floating point conversions |
+| string-like | Anything else that can be shifted into a StringStream |
+| vector-like | A vector of the above three types (see below) |
+| function | A function that takes an array of strings and returns a string that describes the conversion failure or empty for success. May be the empty function. (`{}`) |
+
+By default, CLI11 will assume that an option is optional, and one value is expected if you do not use a vector. You can change this on a specific option using option modifiers.
+
+## Positional options and aliases
+
+When you give an option on the command line without a name, that is a positional option. Positional options are accepted in the same order they are defined. So, for example:
+
+```term
+gitbook:examples $ ./a.out one --two three four
+```
+
+The string `one` would have to be the first positional option. If `--two` is a flag, then the remaining two strings are positional. If `--two` is a one-argument option, then `four` is the second positional. If `--two` accepts two or more arguments, then there are no more positionals.
+
+To make a positional option, you simply give CLI11 one name that does not start with a dash. You can have as many (non-overlapping) names as you want for an option, but only one positional name. So the following name string is valid:
+
+```cpp
+"-a,-b,--alpha,--beta,mypos"
+```
+
+This would make two short option aliases, two long option alias, and the option would be also be accepted as a positional.
+
+## Vectors of options
+
+If you use a vector instead of a plain option, you can accept more than one value on the command line. By default, a vector accepts as many options as possible, until the next value that could be a valid option name. You can specify a set number using an option modifier `->expected(N)`. (The default unlimited behavior on vectors is restore with `N=-1`) CLI11 does not differentiate between these two methods for unlimited acceptance options:[^2]
+
+| Separate names    | Combined names  |
+|-------------------|-----------------|
+| `--vec 1 --vec 2` | `--vec 1 2`     |
+
+The original version did allow the option system to access information on the grouping of options received, but was removed for simplicity. 
+
+An example of setting up a vector option:
+
+```cpp
+std::vector<int> int_vec;
+app.add_option("--vec", int_vec, "My vector option");
+```
+
+Vectors will be replaced by the parsed content if the option is given on the command line.
+
+
+## Option modifiers
+
+When you call `add_option`, you get a pointer to the added option. You can use that to add option modifiers. A full listing of the option modifiers:
+
+| Modifier | Description |
+|----------|-------------|
+| `->required()`| The program will quit if this option is not present. This is `mandatory` in Plumbum, but required options seems to be a more standard term. For compatibility, `->mandatory()` also works. |
+| `->expected(N)`| Take `N` values instead of as many as possible, only for vector args.|
+| `->needs(opt)`| This option requires another option to also be present, opt is an `Option` pointer.|
+| `->excludes(opt)`| This option cannot be given with `opt` present, opt is an `Option` pointer.|
+| `->envname(name)`| Gets the value from the environment if present and not passed on the command line.|
+| `->group(name)`| The help group to put the option in. No effect for positional options. Defaults to `"Options"`. `"Hidden"` will not show up in the help print.|
+| `->ignore_case()`| Ignore the case on the command line (also works on subcommands, does not affect arguments).|
+| `->ignore_underscore()`| Ignore any underscores on the command line (also works on subcommands, does not affect arguments, new in CLI11 1.7).|
+| `->multi_option_policy(CLI::MultiOptionPolicy::Throw)` | Sets the policy if 1 argument expected but this was received on the command line several times. `Throw`ing an error is the default, but `TakeLast`, `TakeFirst`, and `Join` are also available. See the next three lines for shortcuts to set this more easily. |
+| `->take_last()` | Only use the last option if passed several times. This is always true by default for bool options, regardless of the app default, but can be set to false explicitly with `->multi_option_policy()`.|
+| `->take_first()` | sets `->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst)` |
+| `->join()` | sets `->multi_option_policy(CLI::MultiOptionPolicy::Join)`, which uses newlines to join all arguments into a single string output. |
+| `->check(CLI::ExistingFile)`| Requires that the file exists if given.|
+| `->check(CLI::ExistingDirectory)`| Requires that the directory exists.|
+| `->check(CLI::NonexistentPath)`| Requires that the path does not exist.|
+| `->check(CLI::Range(min,max))`| Requires that the option be between min and max (make sure to use floating point if needed). Min defaults to 0.|
+| `->each(void(std::string))` | Run a function on each parsed value, *in order*.|
+
+The `->check(...)` modifiers adds a callback function of the form `bool function(std::string)` that runs on every value that the option receives, and returns a value that tells CLI11 whether the check passed or failed.
+
+## Using the `CLI::Option` pointer
+
+Each of the option creation mechanisms returns a pointer to the internally stored option. If you save that pointer, you can continue to access the option, and change setting on it later. The Option object can also be converted to a bool to see if it was passed, or `->count()` can be used to see how many times the option was passed. Since flags are also options, the same methods work on them.
+
+```cpp
+CLI::Option* opt = app.add_flag("--opt");
+
+CLI11_PARSE(app, argv, argc);
+
+if(*opt)
+    std::cout << "Flag recieved " << opt->count() << " times." << std::endl;
+```
+
+## Inheritance of defaults
+
+One of CLI11's systems to allow customizability without high levels of verbosity is the inheritance system. You can set default values on the parent `App`, and all options and subcommands created from it remember the default values at the point of creation. The default value for Options, specifically, are accessible through the `option_defaults()` method. There are four settings that can be set and inherited:
+
+* `group`: The group name starts as "Options"
+* `required`: If the option must be given. Defaults to `false`. Is ignored for flags.
+* `multi_option_policy`: What to do if several copies of an option are passed and one value is expected. Defaults to `CLI::MultiOptionPolicy::Throw`. This is also used for bool flags, but they always are created with the value `CLI::MultiOptionPolicy::TakeLast` regardless of the default, so that multiple bool flags does not cause an error. But you can override that flag by flag.
+* `ignore_case`: Allow any mixture of cases for the option or flag name
+
+An example of usage:
+
+```
+app.option_defauts()->ignore_case()->group("Required");
+
+app.add_flag("--CaSeLeSs");
+app.get_group() // is "Required"
+```
+
+Groups are mostly for visual organisation, but an empty string for a group name will hide the option.
+
+
+## Listing of specialty options:
+
+Besides `add_option` and `add_flag`, there are several special ways to create options for sets and complex numbers.
+
+### Sets
+
+You can add a set with `add_set`, where you give a variable to set and a `std::set` of choices to pick from. There also is a `add_set_ignore_case` version which ignores case when set matching. If you use an existing set instead of an inline one, you can edit the set after adding it and changes will be reflected in the set checking and help message.
+
+```cpp
+int val;
+app.add_set("--even", val, {0,2,4,6,8});
+```
+
+### Complex numbers
+
+You can also add a complex number. This type just needs to support a `(T x, T y)` constructor and be printable. You can also pass one extra argument that will set the label of the type; by default it is "COMPLEX".
+
+```cpp
+std::complex<float> val;
+app.add_complex("--cplx", val);
+```
+
+### Optionals (New in CLI11 1.5)
+
+If you have a compiler with `__has_include`, you can use `std::optional`, `std::experimental::optional`, and `boost::optional` in `add_option`. You can manually enforce support for one of these by defining the corresponding macro before including CLI11 (or in your build system). For example:
+
+```cpp
+#define CLI11_BOOST_OPTIONAL
+#include <CLI/CLI.hpp>
+
+...
+
+boost::optional<int> x;
+app.add_option("-x", x);
+
+CLI11_PARSE(app, argc, argv);
+
+if(x)
+    std::cout << *x << std::endl;
+```
+
+### Windows style options (New in CLI11 1.7)
+
+You can also set the app setting `app->allow_windows_style_options()` to allow windows style options to also be recognized on the command line:
+
+* `/a` (flag)
+* `/f filename` (option)
+* `/long` (long flag)
+* `/file filename` (space)
+* `/file:filename` (colon)
+
+Windows style options do not allow combining short options or values not separated from the short option like with `-` options. You still specify option names in the same manor as on Linux with single and double dashes when you use the `add_*` functions, and the Linux style on the command line will still work. If a long and a short option share the same name, the option will match on the first one defined.
+
+[^1]: For example, enums are not printable to `std::cout`.
+[^2]: There is a small difference. An combined unlimited option will not prioritize over a positional that could still accept values.
+# Subcommands and the App
+
+Subcommands are keyword that invoke a new set of options and features. For example, the `git`
+command has a long series of subcommands, like `add` and `commit`. Each can have its own options
+and implementations. This chapter will focus on implementations that are contained in the same
+C++ application, though the system git uses to extend the main command by calling other commands
+in separate executables is supported too; that's called "Prefix commands" and is included at the
+end of this chapter.
+
+
+## The parent App
+
+We'll start by discussing the parent `App`. You've already used it quite a bit, to create
+options and set option defaults. There are several other things you can do with an `App`, however.
+
+You are given a lot of control the help output. You can set a footer with `app.footer("My Footer")`.
+You can replace the default help print when a `ParseError` is thrown with `app.set_failure_message(CLI::FailureMessage::help)`.
+The default is `CLI:::FailureMessage::simple`, and you can easily define a new one. Just make a (lambda) function that takes an App pointer
+and a reference to an error code (even if you don't use them), and returns a string.
+
+
+## Adding a subcommand
+
+Subcommands can be added just like an option:
+
+```cpp
+CLI::App* sub = app.add_subcommand("sub", "This is a subcommand");
+```
+
+The subcommand should have a name as the first argument, and a little description for the
+second argument. A pointer to the internally stored subcommand is provided; you usually will
+be capturing that pointer and using it later (though you can use callbacks if you prefer). As
+always, feel free to use `auto sub = ...` instead of naming the type.
+
+You can check to see if the subcommand was received on the command line several ways:
+
+```cpp
+if(*sub) ...
+if(sub->parsed()) ...
+if(app.got_subcommand(sub)) ...
+if(app.got_subcommand("sub")) ...
+```
+
+You can also get a list of subcommands with `get_subcommands()`, and they will be in parsing order.
+
+There are a lot of options that you can set on a subcommand; in fact,
+subcommands have exactly the same options as your main app, since they are actually
+the same class of object (as you may have guessed from the type above). This has the
+pleasant side affect of making subcommands infinitely nestable.
+
+## Required subcommands
+
+Each App has controls to set the number of subcommands you expect. This is controlled by:
+
+```cpp
+app.require_subcommand(/* min */ 0, /* max */ 1);
+```
+If you set the max to 0, CLI11 will allow an unlimited number of subcommands. After the (non-unlimited) maximum
+is reached, CLI11 will stop trying to match subcommands. So the if you pass "`one two`" to a command, and both `one`
+and `two` are subcommands, it will depend on the maximum number as to whether the "`two`" is a subcommand or an argument to the
+"`one`" subcommand.
+
+As a shortcut, you can also call the `require_subcommand` method with one argument; that will be the fixed number of subcommands if positive, it
+will be the maximum number if negative. Calling it without an argument will set the required subcommands to 1 or more.
+
+The maximum number of subcommands is inherited by subcommands. This allows you to set the maximum to 1 once at the beginning on the parent app if you only want single subcommands throughout your app. You should keep this in mind, if you are dealing with lots of nested subcommands.
+
+## Using callbacks
+
+You've already seen how to check to see what subcommands were given. It's often much easier, however, to just define the code you want to run when you are making your parser, and not run a bunch of code after `CLI11_PARSE` to analyse the state (Procedural! Yuck!). You can do that with lambda functions. A `std::function<void()>` callback `.callback()` is provided, and CLI11 ensures that all options are prepared and usable by reference capture before entering the callback. An
+example is shown below in the `geet` program.
+
+## Inheritance of defaults
+
+The following values are inherited when you add a new subcommand. This happens at the point the subcommand is created:
+
+* The name and description for the help flag
+* The footer
+* The failure message printer function
+* Option defaults
+* Allow extras
+* Prefix command
+* Ignore case
+* Ignore underscore
+* Allow Windows style options
+* Fallthrough
+* Group name
+* Max required subcommands
+
+## Special modes
+
+There are several special modes for Apps and Subcommands.
+
+### Allow extras
+
+Normally CLI11 throws an error if you don't match all items given on the command line. However, you can enable `allow_extras()`
+to instead store the extra values in `.remaining()`. You can get all remaining options including those in contained subcommands recursively in the original order with `.remaining(true)`.
+`.remaining_size()` is also provided; this counts the size but ignores the `--` special separator if present.
+
+### Fallthrough
+
+Fallthrough allows an option that does not match in a subcommand to "fall through" to the parent command; if that parent
+allows that option, it matches there instead. This was added to allow CLI11 to represent models:
+
+```term
+gitbook:code $ ./my_program my_model_1 --model_flag --shared_flag
+```
+
+Here, `--shared_option` was set on the main app, and on the command line it "falls through" `my_model_1` to match on the main app.
+
+### Prefix command
+
+This is a special mode that allows "prefix" commands, where the parsing completely stops when it gets to an unknown option. Further unknown options are ignored, even if they could match. Git is the traditional example for prefix commands; if you run git with an unknown subcommand, like "`git thing`", it then calls another command called "`git-thing`" with the remaining options intact.
+
+# Using CLI11 in a Toolkit
+
+CLI11 was designed to be integrate into a toolkit, providing a native experience for users. This was used in GooFit to provide `GooFit::Application`, an class designed to make ROOT users feel at home.
+
+# Custom namespace
+
+If you want to provide CLI11 in a custom namespace, you'll want to at least put `using CLI::App` in your namespace. You can also include Option, some errors, and validators. You can also put `using namespace CLI` inside your namespace to import everything.
+
+You may also want to make your own copy of the `CLI11_PARSE` macro. Something like:
+
+```cpp
+ #define MYPACKAGE_PARSE(app, argv, argc)    \
+     try {                                   \
+         app.parse(argv, argc);              \
+     } catch(const CLI::ParseError &e) {     \
+         return app.exit(e);                 \
+     }
+```
+
+
+# Subclassing App
+
+If you subclass `App`, you'll just need to do a few things. You'll need a constructor; calling the base `App` constructor is a good idea, but not necessary (it just sets a description and adds a help flag.
+
+You can call anything you would like to configure in the constructor, like `option_defaults()->take_last()` or `fallthrough()`, and it will be set on all user instances. You can add flags and options, as well.
+
+
+# Virtual functions provided
+
+You are given a few virtual functions that you can change (only on the main App). `pre_callback` runs right before the callbacks run, letting you print out custom messages at the top of your app. 
+# Validators
+
+{% hint style='info' %}
+Improved in CLI11 1.6
+{% endhint %}
+
+There are two forms of validators:
+
+* `transform` validators: mutating
+* `check` validators: non-mutating (recommended unless the parsed string must be mutated)
+
+A transform validator comes in one form, a function with the signature `std::string(std::string)`.
+The function will take a string and return the modified version of the string. If there is an error,
+the function should throw a `CLI::ValidationError` with the appropriate reason as a message.
+
+However, `check` validators come in two forms; either a simple function with the const version of the
+above signature, `std::string(const std::string &)`, or a subclass of `struct CLI::Validator`. This
+structure has two members that a user should set; one (`func`) is the function to add to the Option
+(exactly matching the above function signature, since it will become that function), and the other is
+`tname`, and is the type name to set on the Option (unless empty, in which case the typename will be
+left unchanged).
+
+Validators can be combined with `&` and `|`, and they have an `operator()` so that you can call them
+as if they were a function. In CLI11, const static versions of the validators are provided so that
+the user does not have to call a constructor also.
+
+An example of a custom validator:
+
+```cpp
+struct LowerCaseValidator : public Validator {
+    LowerCaseValidator() {
+        tname = "LOWER";
+        func = [](const std::string &str) {
+            if(CLI::detail::to_lower(str) != str)
+                return std::string("String is not lower case");
+            else
+                return std::string();
+        };
+    }
+};
+const static LowerCaseValidator Lowercase;
+```
+
+If you were not interested in the extra features of Validator, you could simply pass the lambda function above to the `->check()` method of `Option`.
+
+The built-in validators for CLI11 are:
+
+| Validator           | Description |
+|---------------------|-------------|
+| `ExistingFile`      | Check for existing file (returns error message if check fails) |
+| `ExistingDirectory` | Check for an existing directory (returns error message if check fails) |
+| `ExistingPath`      | Check for an existing path |
+| `NonexistentPath`   | Check for an non-existing path |
+| `Range(min=0, max)` |  Produce a range (factory). Min and max are inclusive. |
+
+
+#pragma once
+
+// CLI11: Version 1.7.1
+// Originally designed by Henry Schreiner
+// https://github.com/CLIUtils/CLI11
+//
+// This is a standalone header file generated by MakeSingleHeader.py in CLI11/scripts
+// from: v1.7.1
+//
+// From LICENSE:
+//
+// CLI11 1.7 Copyright (c) 2017-2019 University of Cincinnati, developed by Henry
+// Schreiner under NSF AWARD 1414736. All rights reserved.
+//
+// Redistribution and use in source and binary forms of CLI11, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+// 3. Neither the name of the copyright holder nor the names of its contributors
+//    may be used to endorse or promote products derived from this software without
+//    specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Standard combined includes:
+
+#include <algorithm>
+#include <deque>
+#include <exception>
+#include <fstream>
+#include <functional>
+#include <iomanip>
+#include <iostream>
+#include <istream>
+#include <iterator>
+#include <locale>
+#include <map>
+#include <memory>
+#include <numeric>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// Verbatim copy from CLI/Version.hpp:
+
+#define CLI11_VERSION_MAJOR 1
+#define CLI11_VERSION_MINOR 7
+#define CLI11_VERSION_PATCH 1
+#define CLI11_VERSION "1.7.1"
+
+// Verbatim copy from CLI/Macros.hpp:
+
+// The following version macro is very similar to the one in PyBind11
+#if !(defined(_MSC_VER) && __cplusplus == 199711L) && !defined(__INTEL_COMPILER)
+#if __cplusplus >= 201402L
+#define CLI11_CPP14
+#if __cplusplus >= 201703L
+#define CLI11_CPP17
+#if __cplusplus > 201703L
+#define CLI11_CPP20
+#endif
+#endif
+#endif
+#elif defined(_MSC_VER) && __cplusplus == 199711L
+// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented)
+// Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3 or newer
+#if _MSVC_LANG >= 201402L
+#define CLI11_CPP14
+#if _MSVC_LANG > 201402L && _MSC_VER >= 1910
+#define CLI11_CPP17
+#if __MSVC_LANG > 201703L && _MSC_VER >= 1910
+#define CLI11_CPP20
+#endif
+#endif
+#endif
+#endif
+
+#if defined(CLI11_CPP14)
+#define CLI11_DEPRECATED(reason) [[deprecated(reason)]]
+#elif defined(_MSC_VER)
+#define CLI11_DEPRECATED(reason) __declspec(deprecated(reason))
+#else
+#define CLI11_DEPRECATED(reason) __attribute__((deprecated(reason)))
+#endif
+
+// Verbatim copy from CLI/Optional.hpp:
+
+#ifdef __has_include
+
+// You can explicitly enable or disable support
+// by defining these to 1 or 0.
+#if defined(CLI11_CPP17) && __has_include(<optional>) && \
+     !defined(CLI11_STD_OPTIONAL)
+#define CLI11_STD_OPTIONAL 1
+#elif !defined(CLI11_STD_OPTIONAL)
+#define CLI11_STD_OPTIONAL 0
+#endif
+
+#if defined(CLI11_CPP14) && __has_include(<experimental/optional>) && \
+    !defined(CLI11_EXPERIMENTAL_OPTIONAL) \
+    && (!defined(CLI11_STD_OPTIONAL) || CLI11_STD_OPTIONAL == 0)
+#define CLI11_EXPERIMENTAL_OPTIONAL 1
+#elif !defined(CLI11_EXPERIMENTAL_OPTIONAL)
+#define CLI11_EXPERIMENTAL_OPTIONAL 0
+#endif
+
+#if __has_include(<boost/optional.hpp>) && !defined(CLI11_BOOST_OPTIONAL)
+#include <boost/version.hpp>
+#if BOOST_VERSION >= 105800
+#define CLI11_BOOST_OPTIONAL 1
+#endif
+#elif !defined(CLI11_BOOST_OPTIONAL)
+#define CLI11_BOOST_OPTIONAL 0
+#endif
+
+#endif
+
+#if CLI11_STD_OPTIONAL
+#include <optional>
+#endif
+#if CLI11_EXPERIMENTAL_OPTIONAL
+#include <experimental/optional>
+#endif
+#if CLI11_BOOST_OPTIONAL
+#include <boost/optional.hpp>
+#endif
+
+// From CLI/Version.hpp:
+
+// From CLI/Macros.hpp:
+
+// From CLI/Optional.hpp:
+
+namespace CLI {
+
+#if CLI11_STD_OPTIONAL
+template <typename T> std::istream &operator>>(std::istream &in, std::optional<T> &val) {
+    T v;
+    in >> v;
+    val = v;
+    return in;
+}
+#endif
+
+#if CLI11_EXPERIMENTAL_OPTIONAL
+template <typename T> std::istream &operator>>(std::istream &in, std::experimental::optional<T> &val) {
+    T v;
+    in >> v;
+    val = v;
+    return in;
+}
+#endif
+
+#if CLI11_BOOST_OPTIONAL
+template <typename T> std::istream &operator>>(std::istream &in, boost::optional<T> &val) {
+    T v;
+    in >> v;
+    val = v;
+    return in;
+}
+#endif
+
+// Export the best optional to the CLI namespace
+#if CLI11_STD_OPTIONAL
+using std::optional;
+#elif CLI11_EXPERIMENTAL_OPTIONAL
+using std::experimental::optional;
+#elif CLI11_BOOST_OPTIONAL
+using boost::optional;
+#endif
+
+// This is true if any optional is found
+#if CLI11_STD_OPTIONAL || CLI11_EXPERIMENTAL_OPTIONAL || CLI11_BOOST_OPTIONAL
+#define CLI11_OPTIONAL 1
+#endif
+
+} // namespace CLI
+
+// From CLI/StringTools.hpp:
+
+namespace CLI {
+namespace detail {
+
+// Based on http://stackoverflow.com/questions/236129/split-a-string-in-c
+/// Split a string by a delim
+inline std::vector<std::string> split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    // Check to see if empty string, give consistent result
+    if(s.empty())
+        elems.emplace_back("");
+    else {
+        std::stringstream ss;
+        ss.str(s);
+        std::string item;
+        while(std::getline(ss, item, delim)) {
+            elems.push_back(item);
+        }
+    }
+    return elems;
+}
+
+/// Simple function to join a string
+template <typename T> std::string join(const T &v, std::string delim = ",") {
+    std::ostringstream s;
+    size_t start = 0;
+    for(const auto &i : v) {
+        if(start++ > 0)
+            s << delim;
+        s << i;
+    }
+    return s.str();
+}
+
+/// Join a string in reverse order
+template <typename T> std::string rjoin(const T &v, std::string delim = ",") {
+    std::ostringstream s;
+    for(size_t start = 0; start < v.size(); start++) {
+        if(start > 0)
+            s << delim;
+        s << v[v.size() - start - 1];
+    }
+    return s.str();
+}
+
+// Based roughly on http://stackoverflow.com/questions/25829143/c-trim-whitespace-from-a-string
+
+/// Trim whitespace from left of string
+inline std::string &ltrim(std::string &str) {
+    auto it = std::find_if(str.begin(), str.end(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
+    str.erase(str.begin(), it);
+    return str;
+}
+
+/// Trim anything from left of string
+inline std::string &ltrim(std::string &str, const std::string &filter) {
+    auto it = std::find_if(str.begin(), str.end(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
+    str.erase(str.begin(), it);
+    return str;
+}
+
+/// Trim whitespace from right of string
+inline std::string &rtrim(std::string &str) {
+    auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
+    str.erase(it.base(), str.end());
+    return str;
+}
+
+/// Trim anything from right of string
+inline std::string &rtrim(std::string &str, const std::string &filter) {
+    auto it =
+        std::find_if(str.rbegin(), str.rend(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
+    str.erase(it.base(), str.end());
+    return str;
+}
+
+/// Trim whitespace from string
+inline std::string &trim(std::string &str) { return ltrim(rtrim(str)); }
+
+/// Trim anything from string
+inline std::string &trim(std::string &str, const std::string filter) { return ltrim(rtrim(str, filter), filter); }
+
+/// Make a copy of the string and then trim it
+inline std::string trim_copy(const std::string &str) {
+    std::string s = str;
+    return trim(s);
+}
+
+/// Make a copy of the string and then trim it, any filter string can be used (any char in string is filtered)
+inline std::string trim_copy(const std::string &str, const std::string &filter) {
+    std::string s = str;
+    return trim(s, filter);
+}
+/// Print a two part "help" string
+inline std::ostream &format_help(std::ostream &out, std::string name, std::string description, size_t wid) {
+    name = "  " + name;
+    out << std::setw(static_cast<int>(wid)) << std::left << name;
+    if(!description.empty()) {
+        if(name.length() >= wid)
+            out << "\n" << std::setw(static_cast<int>(wid)) << "";
+        out << description;
+    }
+    out << "\n";
+    return out;
+}
+
+/// Verify the first character of an option
+template <typename T> bool valid_first_char(T c) { return std::isalpha(c, std::locale()) || c == '_'; }
+
+/// Verify following characters of an option
+template <typename T> bool valid_later_char(T c) {
+    return std::isalnum(c, std::locale()) || c == '_' || c == '.' || c == '-';
+}
+
+/// Verify an option name
+inline bool valid_name_string(const std::string &str) {
+    if(str.empty() || !valid_first_char(str[0]))
+        return false;
+    for(auto c : str.substr(1))
+        if(!valid_later_char(c))
+            return false;
+    return true;
+}
+
+/// Return a lower case version of a string
+inline std::string to_lower(std::string str) {
+    std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
+        return std::tolower(x, std::locale());
+    });
+    return str;
+}
+
+/// remove underscores from a string
+inline std::string remove_underscore(std::string str) {
+    str.erase(std::remove(std::begin(str), std::end(str), '_'), std::end(str));
+    return str;
+}
+
+/// Find and replace a substring with another substring
+inline std::string find_and_replace(std::string str, std::string from, std::string to) {
+
+    size_t start_pos = 0;
+
+    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
+        str.replace(start_pos, from.length(), to);
+        start_pos += to.length();
+    }
+
+    return str;
+}
+
+/// Find a trigger string and call a modify callable function that takes the current string and starting position of the
+/// trigger and returns the position in the string to search for the next trigger string
+template <typename Callable> inline std::string find_and_modify(std::string str, std::string trigger, Callable modify) {
+    size_t start_pos = 0;
+    while((start_pos = str.find(trigger, start_pos)) != std::string::npos) {
+        start_pos = modify(str, start_pos);
+    }
+    return str;
+}
+
+/// Split a string '"one two" "three"' into 'one two', 'three'
+/// Quote characters can be ` ' or "
+inline std::vector<std::string> split_up(std::string str) {
+
+    const std::string delims("\'\"`");
+    auto find_ws = [](char ch) { return std::isspace<char>(ch, std::locale()); };
+    trim(str);
+
+    std::vector<std::string> output;
+    bool embeddedQuote = false;
+    char keyChar = ' ';
+    while(!str.empty()) {
+        if(delims.find_first_of(str[0]) != std::string::npos) {
+            keyChar = str[0];
+            auto end = str.find_first_of(keyChar, 1);
+            while((end != std::string::npos) && (str[end - 1] == '\\')) { // deal with escaped quotes
+                end = str.find_first_of(keyChar, end + 1);
+                embeddedQuote = true;
+            }
+            if(end != std::string::npos) {
+                output.push_back(str.substr(1, end - 1));
+                str = str.substr(end + 1);
+            } else {
+                output.push_back(str.substr(1));
+                str = "";
+            }
+        } else {
+            auto it = std::find_if(std::begin(str), std::end(str), find_ws);
+            if(it != std::end(str)) {
+                std::string value = std::string(str.begin(), it);
+                output.push_back(value);
+                str = std::string(it, str.end());
+            } else {
+                output.push_back(str);
+                str = "";
+            }
+        }
+        // transform any embedded quotes into the regular character
+        if(embeddedQuote) {
+            output.back() = find_and_replace(output.back(), std::string("\\") + keyChar, std::string(1, keyChar));
+            embeddedQuote = false;
+        }
+        trim(str);
+    }
+    return output;
+}
+
+/// Add a leader to the beginning of all new lines (nothing is added
+/// at the start of the first line). `"; "` would be for ini files
+///
+/// Can't use Regex, or this would be a subs.
+inline std::string fix_newlines(std::string leader, std::string input) {
+    std::string::size_type n = 0;
+    while(n != std::string::npos && n < input.size()) {
+        n = input.find('\n', n);
+        if(n != std::string::npos) {
+            input = input.substr(0, n + 1) + leader + input.substr(n + 1);
+            n += leader.size();
+        }
+    }
+    return input;
+}
+
+/// This function detects an equal or colon followed by an escaped quote after an argument
+/// then modifies the string to replace the equality with a space.  This is needed
+/// to allow the split up function to work properly and is intended to be used with the find_and_modify function
+/// the return value is the offset+1 which is required by the find_and_modify function.
+inline size_t escape_detect(std::string &str, size_t offset) {
+    auto next = str[offset + 1];
+    if((next == '\"') || (next == '\'') || (next == '`')) {
+        auto astart = str.find_last_of("-/ \"\'`", offset - 1);
+        if(astart != std::string::npos) {
+            if(str[astart] == ((str[offset] == '=') ? '-' : '/'))
+                str[offset] = ' '; // interpret this as a space so the split_up works properly
+        }
+    }
+    return offset + 1;
+}
+
+/// Add quotes if the string contains spaces
+inline std::string &add_quotes_if_needed(std::string &str) {
+    if((str.front() != '"' && str.front() != '\'') || str.front() != str.back()) {
+        char quote = str.find('"') < str.find('\'') ? '\'' : '"';
+        if(str.find(' ') != std::string::npos) {
+            str.insert(0, 1, quote);
+            str.append(1, quote);
+        }
+    }
+    return str;
+}
+
+} // namespace detail
+} // namespace CLI
+
+// From CLI/Error.hpp:
+
+namespace CLI {
+
+// Use one of these on all error classes.
+// These are temporary and are undef'd at the end of this file.
+#define CLI11_ERROR_DEF(parent, name)                                                                                  \
+  protected:                                                                                                           \
+    name(std::string ename, std::string msg, int exit_code) : parent(std::move(ename), std::move(msg), exit_code) {}   \
+    name(std::string ename, std::string msg, ExitCodes exit_code)                                                      \
+        : parent(std::move(ename), std::move(msg), exit_code) {}                                                       \
+                                                                                                                       \
+  public:                                                                                                              \
+    name(std::string msg, ExitCodes exit_code) : parent(#name, std::move(msg), exit_code) {}                           \
+    name(std::string msg, int exit_code) : parent(#name, std::move(msg), exit_code) {}
+
+// This is added after the one above if a class is used directly and builds its own message
+#define CLI11_ERROR_SIMPLE(name)                                                                                       \
+    explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}
+
+/// These codes are part of every error in CLI. They can be obtained from e using e.exit_code or as a quick shortcut,
+/// int values from e.get_error_code().
+enum class ExitCodes {
+    Success = 0,
+    IncorrectConstruction = 100,
+    BadNameString,
+    OptionAlreadyAdded,
+    FileError,
+    ConversionError,
+    ValidationError,
+    RequiredError,
+    RequiresError,
+    ExcludesError,
+    ExtrasError,
+    ConfigError,
+    InvalidError,
+    HorribleError,
+    OptionNotFound,
+    ArgumentMismatch,
+    BaseClass = 127
+};
+
+// Error definitions
+
+/// @defgroup error_group Errors
+/// @brief Errors thrown by CLI11
+///
+/// These are the errors that can be thrown. Some of them, like CLI::Success, are not really errors.
+/// @{
+
+/// All errors derive from this one
+class Error : public std::runtime_error {
+    int actual_exit_code;
+    std::string error_name{"Error"};
+
+  public:
+    int get_exit_code() const { return actual_exit_code; }
+
+    std::string get_name() const { return error_name; }
+
+    Error(std::string name, std::string msg, int exit_code = static_cast<int>(ExitCodes::BaseClass))
+        : runtime_error(msg), actual_exit_code(exit_code), error_name(std::move(name)) {}
+
+    Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast<int>(exit_code)) {}
+};
+
+// Note: Using Error::Error constructors does not work on GCC 4.7
+
+/// Construction errors (not in parsing)
+class ConstructionError : public Error {
+    CLI11_ERROR_DEF(Error, ConstructionError)
+};
+
+/// Thrown when an option is set to conflicting values (non-vector and multi args, for example)
+class IncorrectConstruction : public ConstructionError {
+    CLI11_ERROR_DEF(ConstructionError, IncorrectConstruction)
+    CLI11_ERROR_SIMPLE(IncorrectConstruction)
+    static IncorrectConstruction PositionalFlag(std::string name) {
+        return IncorrectConstruction(name + ": Flags cannot be positional");
+    }
+    static IncorrectConstruction Set0Opt(std::string name) {
+        return IncorrectConstruction(name + ": Cannot set 0 expected, use a flag instead");
+    }
+    static IncorrectConstruction SetFlag(std::string name) {
+        return IncorrectConstruction(name + ": Cannot set an expected number for flags");
+    }
+    static IncorrectConstruction ChangeNotVector(std::string name) {
+        return IncorrectConstruction(name + ": You can only change the expected arguments for vectors");
+    }
+    static IncorrectConstruction AfterMultiOpt(std::string name) {
+        return IncorrectConstruction(
+            name + ": You can't change expected arguments after you've changed the multi option policy!");
+    }
+    static IncorrectConstruction MissingOption(std::string name) {
+        return IncorrectConstruction("Option " + name + " is not defined");
+    }
+    static IncorrectConstruction MultiOptionPolicy(std::string name) {
+        return IncorrectConstruction(name + ": multi_option_policy only works for flags and exact value options");
+    }
+};
+
+/// Thrown on construction of a bad name
+class BadNameString : public ConstructionError {
+    CLI11_ERROR_DEF(ConstructionError, BadNameString)
+    CLI11_ERROR_SIMPLE(BadNameString)
+    static BadNameString OneCharName(std::string name) { return BadNameString("Invalid one char name: " + name); }
+    static BadNameString BadLongName(std::string name) { return BadNameString("Bad long name: " + name); }
+    static BadNameString DashesOnly(std::string name) {
+        return BadNameString("Must have a name, not just dashes: " + name);
+    }
+    static BadNameString MultiPositionalNames(std::string name) {
+        return BadNameString("Only one positional name allowed, remove: " + name);
+    }
+};
+
+/// Thrown when an option already exists
+class OptionAlreadyAdded : public ConstructionError {
+    CLI11_ERROR_DEF(ConstructionError, OptionAlreadyAdded)
+    explicit OptionAlreadyAdded(std::string name)
+        : OptionAlreadyAdded(name + " is already added", ExitCodes::OptionAlreadyAdded) {}
+    static OptionAlreadyAdded Requires(std::string name, std::string other) {
+        return OptionAlreadyAdded(name + " requires " + other, ExitCodes::OptionAlreadyAdded);
+    }
+    static OptionAlreadyAdded Excludes(std::string name, std::string other) {
+        return OptionAlreadyAdded(name + " excludes " + other, ExitCodes::OptionAlreadyAdded);
+    }
+};
+
+// Parsing errors
+
+/// Anything that can error in Parse
+class ParseError : public Error {
+    CLI11_ERROR_DEF(Error, ParseError)
+};
+
+// Not really "errors"
+
+/// This is a successful completion on parsing, supposed to exit
+class Success : public ParseError {
+    CLI11_ERROR_DEF(ParseError, Success)
+    Success() : Success("Successfully completed, should be caught and quit", ExitCodes::Success) {}
+};
+
+/// -h or --help on command line
+class CallForHelp : public ParseError {
+    CLI11_ERROR_DEF(ParseError, CallForHelp)
+    CallForHelp() : CallForHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
+};
+
+/// Usually something like --help-all on command line
+class CallForAllHelp : public ParseError {
+    CLI11_ERROR_DEF(ParseError, CallForAllHelp)
+    CallForAllHelp()
+        : CallForAllHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
+};
+
+/// Does not output a diagnostic in CLI11_PARSE, but allows to return from main() with a specific error code.
+class RuntimeError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, RuntimeError)
+    explicit RuntimeError(int exit_code = 1) : RuntimeError("Runtime error", exit_code) {}
+};
+
+/// Thrown when parsing an INI file and it is missing
+class FileError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, FileError)
+    CLI11_ERROR_SIMPLE(FileError)
+    static FileError Missing(std::string name) { return FileError(name + " was not readable (missing?)"); }
+};
+
+/// Thrown when conversion call back fails, such as when an int fails to coerce to a string
+class ConversionError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ConversionError)
+    CLI11_ERROR_SIMPLE(ConversionError)
+    ConversionError(std::string member, std::string name)
+        : ConversionError("The value " + member + " is not an allowed value for " + name) {}
+    ConversionError(std::string name, std::vector<std::string> results)
+        : ConversionError("Could not convert: " + name + " = " + detail::join(results)) {}
+    static ConversionError TooManyInputsFlag(std::string name) {
+        return ConversionError(name + ": too many inputs for a flag");
+    }
+    static ConversionError TrueFalse(std::string name) {
+        return ConversionError(name + ": Should be true/false or a number");
+    }
+};
+
+/// Thrown when validation of results fails
+class ValidationError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ValidationError)
+    CLI11_ERROR_SIMPLE(ValidationError)
+    explicit ValidationError(std::string name, std::string msg) : ValidationError(name + ": " + msg) {}
+};
+
+/// Thrown when a required option is missing
+class RequiredError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, RequiredError)
+    explicit RequiredError(std::string name) : RequiredError(name + " is required", ExitCodes::RequiredError) {}
+    static RequiredError Subcommand(size_t min_subcom) {
+        if(min_subcom == 1)
+            return RequiredError("A subcommand");
+        else
+            return RequiredError("Requires at least " + std::to_string(min_subcom) + " subcommands",
+                                 ExitCodes::RequiredError);
+    }
+};
+
+/// Thrown when the wrong number of arguments has been received
+class ArgumentMismatch : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ArgumentMismatch)
+    CLI11_ERROR_SIMPLE(ArgumentMismatch)
+    ArgumentMismatch(std::string name, int expected, size_t recieved)
+        : ArgumentMismatch(expected > 0 ? ("Expected exactly " + std::to_string(expected) + " arguments to " + name +
+                                           ", got " + std::to_string(recieved))
+                                        : ("Expected at least " + std::to_string(-expected) + " arguments to " + name +
+                                           ", got " + std::to_string(recieved)),
+                           ExitCodes::ArgumentMismatch) {}
+
+    static ArgumentMismatch AtLeast(std::string name, int num) {
+        return ArgumentMismatch(name + ": At least " + std::to_string(num) + " required");
+    }
+    static ArgumentMismatch TypedAtLeast(std::string name, int num, std::string type) {
+        return ArgumentMismatch(name + ": " + std::to_string(num) + " required " + type + " missing");
+    }
+};
+
+/// Thrown when a requires option is missing
+class RequiresError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, RequiresError)
+    RequiresError(std::string curname, std::string subname)
+        : RequiresError(curname + " requires " + subname, ExitCodes::RequiresError) {}
+};
+
+/// Thrown when an excludes option is present
+class ExcludesError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ExcludesError)
+    ExcludesError(std::string curname, std::string subname)
+        : ExcludesError(curname + " excludes " + subname, ExitCodes::ExcludesError) {}
+};
+
+/// Thrown when too many positionals or options are found
+class ExtrasError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ExtrasError)
+    explicit ExtrasError(std::vector<std::string> args)
+        : ExtrasError((args.size() > 1 ? "The following arguments were not expected: "
+                                       : "The following argument was not expected: ") +
+                          detail::rjoin(args, " "),
+                      ExitCodes::ExtrasError) {}
+};
+
+/// Thrown when extra values are found in an INI file
+class ConfigError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ConfigError)
+    CLI11_ERROR_SIMPLE(ConfigError)
+    static ConfigError Extras(std::string item) { return ConfigError("INI was not able to parse " + item); }
+    static ConfigError NotConfigurable(std::string item) {
+        return ConfigError(item + ": This option is not allowed in a configuration file");
+    }
+};
+
+/// Thrown when validation fails before parsing
+class InvalidError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, InvalidError)
+    explicit InvalidError(std::string name)
+        : InvalidError(name + ": Too many positional arguments with unlimited expected args", ExitCodes::InvalidError) {
+    }
+};
+
+/// This is just a safety check to verify selection and parsing match - you should not ever see it
+/// Strings are directly added to this error, but again, it should never be seen.
+class HorribleError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, HorribleError)
+    CLI11_ERROR_SIMPLE(HorribleError)
+};
+
+// After parsing
+
+/// Thrown when counting a non-existent option
+class OptionNotFound : public Error {
+    CLI11_ERROR_DEF(Error, OptionNotFound)
+    explicit OptionNotFound(std::string name) : OptionNotFound(name + " not found", ExitCodes::OptionNotFound) {}
+};
+
+#undef CLI11_ERROR_DEF
+#undef CLI11_ERROR_SIMPLE
+
+/// @}
+
+} // namespace CLI
+
+// From CLI/TypeTools.hpp:
+
+namespace CLI {
+
+// Type tools
+
+/// A copy of enable_if_t from C++14, compatible with C++11.
+///
+/// We could check to see if C++14 is being used, but it does not hurt to redefine this
+/// (even Google does this: https://github.com/google/skia/blob/master/include/private/SkTLogic.h)
+/// It is not in the std namespace anyway, so no harm done.
+
+template <bool B, class T = void> using enable_if_t = typename std::enable_if<B, T>::type;
+
+/// Check to see if something is a vector (fail check by default)
+template <typename T> struct is_vector { static const bool value = false; };
+
+/// Check to see if something is a vector (true if actually a vector)
+template <class T, class A> struct is_vector<std::vector<T, A>> { static bool const value = true; };
+
+/// Check to see if something is bool (fail check by default)
+template <typename T> struct is_bool { static const bool value = false; };
+
+/// Check to see if something is bool (true if actually a bool)
+template <> struct is_bool<bool> { static bool const value = true; };
+
+namespace detail {
+// Based generally on https://rmf.io/cxx11/almost-static-if
+/// Simple empty scoped class
+enum class enabler {};
+
+/// An instance to use in EnableIf
+constexpr enabler dummy = {};
+
+// Type name print
+
+/// Was going to be based on
+///  http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template
+/// But this is cleaner and works better in this case
+
+template <typename T,
+          enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "INT";
+}
+
+template <typename T,
+          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "UINT";
+}
+
+template <typename T, enable_if_t<std::is_floating_point<T>::value, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "FLOAT";
+}
+
+/// This one should not be used, since vector types print the internal type
+template <typename T, enable_if_t<is_vector<T>::value, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "VECTOR";
+}
+
+template <typename T,
+          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value && !is_vector<T>::value,
+                      detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "TEXT";
+}
+
+// Lexical cast
+
+/// Signed integers / enums
+template <typename T,
+          enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), detail::enabler> = detail::dummy>
+bool lexical_cast(std::string input, T &output) {
+    try {
+        size_t n = 0;
+        long long output_ll = std::stoll(input, &n, 0);
+        output = static_cast<T>(output_ll);
+        return n == input.size() && static_cast<long long>(output) == output_ll;
+    } catch(const std::invalid_argument &) {
+        return false;
+    } catch(const std::out_of_range &) {
+        return false;
+    }
+}
+
+/// Unsigned integers
+template <typename T,
+          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+bool lexical_cast(std::string input, T &output) {
+    if(!input.empty() && input.front() == '-')
+        return false; // std::stoull happily converts negative values to junk without any errors.
+
+    try {
+        size_t n = 0;
+        unsigned long long output_ll = std::stoull(input, &n, 0);
+        output = static_cast<T>(output_ll);
+        return n == input.size() && static_cast<unsigned long long>(output) == output_ll;
+    } catch(const std::invalid_argument &) {
+        return false;
+    } catch(const std::out_of_range &) {
+        return false;
+    }
+}
+
+/// Floats
+template <typename T, enable_if_t<std::is_floating_point<T>::value, detail::enabler> = detail::dummy>
+bool lexical_cast(std::string input, T &output) {
+    try {
+        size_t n = 0;
+        output = static_cast<T>(std::stold(input, &n));
+        return n == input.size();
+    } catch(const std::invalid_argument &) {
+        return false;
+    } catch(const std::out_of_range &) {
+        return false;
+    }
+}
+
+/// String and similar
+template <typename T,
+          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
+                          std::is_assignable<T &, std::string>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(std::string input, T &output) {
+    output = input;
+    return true;
+}
+
+/// Non-string parsable
+template <typename T,
+          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
+                          !std::is_assignable<T &, std::string>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(std::string input, T &output) {
+    std::istringstream is;
+
+    is.str(input);
+    is >> output;
+    return !is.fail() && !is.rdbuf()->in_avail();
+}
+
+} // namespace detail
+} // namespace CLI
+
+// From CLI/Split.hpp:
+
+namespace CLI {
+namespace detail {
+
+// Returns false if not a short option. Otherwise, sets opt name and rest and returns true
+inline bool split_short(const std::string &current, std::string &name, std::string &rest) {
+    if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {
+        name = current.substr(1, 1);
+        rest = current.substr(2);
+        return true;
+    } else
+        return false;
+}
+
+// Returns false if not a long option. Otherwise, sets opt name and other side of = and returns true
+inline bool split_long(const std::string &current, std::string &name, std::string &value) {
+    if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
+        auto loc = current.find_first_of('=');
+        if(loc != std::string::npos) {
+            name = current.substr(2, loc - 2);
+            value = current.substr(loc + 1);
+        } else {
+            name = current.substr(2);
+            value = "";
+        }
+        return true;
+    } else
+        return false;
+}
+
+// Returns false if not a windows style option. Otherwise, sets opt name and value and returns true
+inline bool split_windows(const std::string &current, std::string &name, std::string &value) {
+    if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {
+        auto loc = current.find_first_of(':');
+        if(loc != std::string::npos) {
+            name = current.substr(1, loc - 1);
+            value = current.substr(loc + 1);
+        } else {
+            name = current.substr(1);
+            value = "";
+        }
+        return true;
+    } else
+        return false;
+}
+
+// Splits a string into multiple long and short names
+inline std::vector<std::string> split_names(std::string current) {
+    std::vector<std::string> output;
+    size_t val;
+    while((val = current.find(",")) != std::string::npos) {
+        output.push_back(trim_copy(current.substr(0, val)));
+        current = current.substr(val + 1);
+    }
+    output.push_back(trim_copy(current));
+    return output;
+}
+
+/// Get a vector of short names, one of long names, and a single name
+inline std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>
+get_names(const std::vector<std::string> &input) {
+
+    std::vector<std::string> short_names;
+    std::vector<std::string> long_names;
+    std::string pos_name;
+
+    for(std::string name : input) {
+        if(name.length() == 0)
+            continue;
+        else if(name.length() > 1 && name[0] == '-' && name[1] != '-') {
+            if(name.length() == 2 && valid_first_char(name[1]))
+                short_names.emplace_back(1, name[1]);
+            else
+                throw BadNameString::OneCharName(name);
+        } else if(name.length() > 2 && name.substr(0, 2) == "--") {
+            name = name.substr(2);
+            if(valid_name_string(name))
+                long_names.push_back(name);
+            else
+                throw BadNameString::BadLongName(name);
+        } else if(name == "-" || name == "--") {
+            throw BadNameString::DashesOnly(name);
+        } else {
+            if(pos_name.length() > 0)
+                throw BadNameString::MultiPositionalNames(name);
+            pos_name = name;
+        }
+    }
+
+    return std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>(
+        short_names, long_names, pos_name);
+}
+
+} // namespace detail
+} // namespace CLI
+
+// From CLI/ConfigFwd.hpp:
+
+namespace CLI {
+
+class App;
+
+namespace detail {
+
+/// Comma separated join, adds quotes if needed
+inline std::string ini_join(std::vector<std::string> args) {
+    std::ostringstream s;
+    size_t start = 0;
+    for(const auto &arg : args) {
+        if(start++ > 0)
+            s << " ";
+
+        auto it = std::find_if(arg.begin(), arg.end(), [](char ch) { return std::isspace<char>(ch, std::locale()); });
+        if(it == arg.end())
+            s << arg;
+        else if(arg.find(R"(")") == std::string::npos)
+            s << R"(")" << arg << R"(")";
+        else
+            s << R"(')" << arg << R"(')";
+    }
+
+    return s.str();
+}
+
+} // namespace detail
+
+/// Holds values to load into Options
+struct ConfigItem {
+    /// This is the list of parents
+    std::vector<std::string> parents;
+
+    /// This is the name
+    std::string name;
+
+    /// Listing of inputs
+    std::vector<std::string> inputs;
+
+    /// The list of parents and name joined by "."
+    std::string fullname() const {
+        std::vector<std::string> tmp = parents;
+        tmp.emplace_back(name);
+        return detail::join(tmp, ".");
+    }
+};
+
+/// This class provides a converter for configuration files.
+class Config {
+  protected:
+    std::vector<ConfigItem> items;
+
+  public:
+    /// Convert an app into a configuration
+    virtual std::string to_config(const App *, bool, bool, std::string) const = 0;
+
+    /// Convert a configuration into an app
+    virtual std::vector<ConfigItem> from_config(std::istream &) const = 0;
+
+    /// Convert a flag to a bool
+    virtual std::vector<std::string> to_flag(const ConfigItem &item) const {
+        if(item.inputs.size() == 1) {
+            std::string val = item.inputs.at(0);
+            val = detail::to_lower(val);
+
+            if(val == "true" || val == "on" || val == "yes") {
+                return std::vector<std::string>(1);
+            } else if(val == "false" || val == "off" || val == "no") {
+                return std::vector<std::string>();
+            } else {
+                try {
+                    size_t ui = std::stoul(val);
+                    return std::vector<std::string>(ui);
+                } catch(const std::invalid_argument &) {
+                    throw ConversionError::TrueFalse(item.fullname());
+                }
+            }
+        } else {
+            throw ConversionError::TooManyInputsFlag(item.fullname());
+        }
+    }
+
+    /// Parse a config file, throw an error (ParseError:ConfigParseError or FileError) on failure
+    std::vector<ConfigItem> from_file(const std::string &name) {
+        std::ifstream input{name};
+        if(!input.good())
+            throw FileError::Missing(name);
+
+        return from_config(input);
+    }
+
+    /// virtual destructor
+    virtual ~Config() = default;
+};
+
+/// This converter works with INI files
+class ConfigINI : public Config {
+  public:
+    std::string to_config(const App *, bool default_also, bool write_description, std::string prefix) const override;
+
+    std::vector<ConfigItem> from_config(std::istream &input) const override {
+        std::string line;
+        std::string section = "default";
+
+        std::vector<ConfigItem> output;
+
+        while(getline(input, line)) {
+            std::vector<std::string> items_buffer;
+
+            detail::trim(line);
+            size_t len = line.length();
+            if(len > 1 && line[0] == '[' && line[len - 1] == ']') {
+                section = line.substr(1, len - 2);
+            } else if(len > 0 && line[0] != ';') {
+                output.emplace_back();
+                ConfigItem &out = output.back();
+
+                // Find = in string, split and recombine
+                auto pos = line.find('=');
+                if(pos != std::string::npos) {
+                    out.name = detail::trim_copy(line.substr(0, pos));
+                    std::string item = detail::trim_copy(line.substr(pos + 1));
+                    items_buffer = detail::split_up(item);
+                } else {
+                    out.name = detail::trim_copy(line);
+                    items_buffer = {"ON"};
+                }
+
+                if(detail::to_lower(section) != "default") {
+                    out.parents = {section};
+                }
+
+                if(out.name.find('.') != std::string::npos) {
+                    std::vector<std::string> plist = detail::split(out.name, '.');
+                    out.name = plist.back();
+                    plist.pop_back();
+                    out.parents.insert(out.parents.end(), plist.begin(), plist.end());
+                }
+
+                out.inputs.insert(std::end(out.inputs), std::begin(items_buffer), std::end(items_buffer));
+            }
+        }
+        return output;
+    }
+};
+
+} // namespace CLI
+
+// From CLI/Validators.hpp:
+
+namespace CLI {
+
+/// @defgroup validator_group Validators
+
+/// @brief Some validators that are provided
+///
+/// These are simple `std::string(const std::string&)` validators that are useful. They return
+/// a string if the validation fails. A custom struct is provided, as well, with the same user
+/// semantics, but with the ability to provide a new type name.
+/// @{
+
+///
+struct Validator {
+    /// This is the type name, if empty the type name will not be changed
+    std::string tname;
+
+    /// This it the base function that is to be called.
+    /// Returns a string error message if validation fails.
+    std::function<std::string(const std::string &)> func;
+
+    /// This is the required operator for a validator - provided to help
+    /// users (CLI11 uses the member `func` directly)
+    std::string operator()(const std::string &str) const { return func(str); };
+
+    /// Combining validators is a new validator
+    Validator operator&(const Validator &other) const {
+        Validator newval;
+        newval.tname = (tname == other.tname ? tname : "");
+
+        // Give references (will make a copy in lambda function)
+        const std::function<std::string(const std::string &filename)> &f1 = func;
+        const std::function<std::string(const std::string &filename)> &f2 = other.func;
+
+        newval.func = [f1, f2](const std::string &filename) {
+            std::string s1 = f1(filename);
+            std::string s2 = f2(filename);
+            if(!s1.empty() && !s2.empty())
+                return s1 + " & " + s2;
+            else
+                return s1 + s2;
+        };
+        return newval;
+    }
+
+    /// Combining validators is a new validator
+    Validator operator|(const Validator &other) const {
+        Validator newval;
+        newval.tname = (tname == other.tname ? tname : "");
+
+        // Give references (will make a copy in lambda function)
+        const std::function<std::string(const std::string &filename)> &f1 = func;
+        const std::function<std::string(const std::string &filename)> &f2 = other.func;
+
+        newval.func = [f1, f2](const std::string &filename) {
+            std::string s1 = f1(filename);
+            std::string s2 = f2(filename);
+            if(s1.empty() || s2.empty())
+                return std::string();
+            else
+                return s1 + " & " + s2;
+        };
+        return newval;
+    }
+};
+
+// The implementation of the built in validators is using the Validator class;
+// the user is only expected to use the const (static) versions (since there's no setup).
+// Therefore, this is in detail.
+namespace detail {
+
+/// Check for an existing file (returns error message if check fails)
+struct ExistingFileValidator : public Validator {
+    ExistingFileValidator() {
+        tname = "FILE";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool exist = stat(filename.c_str(), &buffer) == 0;
+            bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
+            if(!exist) {
+                return "File does not exist: " + filename;
+            } else if(is_dir) {
+                return "File is actually a directory: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Check for an existing directory (returns error message if check fails)
+struct ExistingDirectoryValidator : public Validator {
+    ExistingDirectoryValidator() {
+        tname = "DIR";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool exist = stat(filename.c_str(), &buffer) == 0;
+            bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
+            if(!exist) {
+                return "Directory does not exist: " + filename;
+            } else if(!is_dir) {
+                return "Directory is actually a file: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Check for an existing path
+struct ExistingPathValidator : public Validator {
+    ExistingPathValidator() {
+        tname = "PATH";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool const exist = stat(filename.c_str(), &buffer) == 0;
+            if(!exist) {
+                return "Path does not exist: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Check for an non-existing path
+struct NonexistentPathValidator : public Validator {
+    NonexistentPathValidator() {
+        tname = "PATH";
+        func = [](const std::string &filename) {
+            struct stat buffer;
+            bool exist = stat(filename.c_str(), &buffer) == 0;
+            if(exist) {
+                return "Path already exists: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+} // namespace detail
+
+// Static is not needed here, because global const implies static.
+
+/// Check for existing file (returns error message if check fails)
+const detail::ExistingFileValidator ExistingFile;
+
+/// Check for an existing directory (returns error message if check fails)
+const detail::ExistingDirectoryValidator ExistingDirectory;
+
+/// Check for an existing path
+const detail::ExistingPathValidator ExistingPath;
+
+/// Check for an non-existing path
+const detail::NonexistentPathValidator NonexistentPath;
+
+///  Produce a range (factory). Min and max are inclusive.
+struct Range : public Validator {
+    /// This produces a range with min and max inclusive.
+    ///
+    /// Note that the constructor is templated, but the struct is not, so C++17 is not
+    /// needed to provide nice syntax for Range(a,b).
+    template <typename T> Range(T min, T max) {
+        std::stringstream out;
+        out << detail::type_name<T>() << " in [" << min << " - " << max << "]";
+
+        tname = out.str();
+        func = [min, max](std::string input) {
+            T val;
+            detail::lexical_cast(input, val);
+            if(val < min || val > max)
+                return "Value " + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);
+
+            return std::string();
+        };
+    }
+
+    /// Range of one value is 0 to value
+    template <typename T> explicit Range(T max) : Range(static_cast<T>(0), max) {}
+};
+
+namespace detail {
+/// split a string into a program name and command line arguments
+/// the string is assumed to contain a file name followed by other arguments
+/// the return value contains is a pair with the first argument containing the program name and the second everything
+/// else
+inline std::pair<std::string, std::string> split_program_name(std::string commandline) {
+    // try to determine the programName
+    std::pair<std::string, std::string> vals;
+    trim(commandline);
+    auto esp = commandline.find_first_of(' ', 1);
+    while(!ExistingFile(commandline.substr(0, esp)).empty()) {
+        esp = commandline.find_first_of(' ', esp + 1);
+        if(esp == std::string::npos) {
+            // if we have reached the end and haven't found a valid file just assume the first argument is the
+            // program name
+            esp = commandline.find_first_of(' ', 1);
+            break;
+        }
+    }
+    vals.first = commandline.substr(0, esp);
+    rtrim(vals.first);
+    // strip the program name
+    vals.second = (esp != std::string::npos) ? commandline.substr(esp + 1) : std::string{};
+    ltrim(vals.second);
+    return vals;
+}
+} // namespace detail
+/// @}
+
+} // namespace CLI
+
+// From CLI/FormatterFwd.hpp:
+
+namespace CLI {
+
+class Option;
+class App;
+
+/// This enum signifies the type of help requested
+///
+/// This is passed in by App; all user classes must accept this as
+/// the second argument.
+
+enum class AppFormatMode {
+    Normal, //< The normal, detailed help
+    All,    //< A fully expanded help
+    Sub,    //< Used when printed as part of expanded subcommand
+};
+
+/// This is the minimum requirements to run a formatter.
+///
+/// A user can subclass this is if they do not care at all
+/// about the structure in CLI::Formatter.
+class FormatterBase {
+  protected:
+    /// @name Options
+    ///@{
+
+    /// The width of the first column
+    size_t column_width_{30};
+
+    /// @brief The required help printout labels (user changeable)
+    /// Values are Needs, Excludes, etc.
+    std::map<std::string, std::string> labels_;
+
+    ///@}
+    /// @name Basic
+    ///@{
+
+  public:
+    FormatterBase() = default;
+    FormatterBase(const FormatterBase &) = default;
+    FormatterBase(FormatterBase &&) = default;
+    virtual ~FormatterBase() = default;
+
+    /// This is the key method that puts together help
+    virtual std::string make_help(const App *, std::string, AppFormatMode) const = 0;
+
+    ///@}
+    /// @name Setters
+    ///@{
+
+    /// Set the "REQUIRED" label
+    void label(std::string key, std::string val) { labels_[key] = val; }
+
+    /// Set the column width
+    void column_width(size_t val) { column_width_ = val; }
+
+    ///@}
+    /// @name Getters
+    ///@{
+
+    /// Get the current value of a name (REQUIRED, etc.)
+    std::string get_label(std::string key) const {
+        if(labels_.find(key) == labels_.end())
+            return key;
+        else
+            return labels_.at(key);
+    }
+
+    /// Get the current column width
+    size_t get_column_width() const { return column_width_; }
+
+    ///@}
+};
+
+/// This is a specialty override for lambda functions
+class FormatterLambda final : public FormatterBase {
+    using funct_t = std::function<std::string(const App *, std::string, AppFormatMode)>;
+
+    /// The lambda to hold and run
+    funct_t lambda_;
+
+  public:
+    /// Create a FormatterLambda with a lambda function
+    explicit FormatterLambda(funct_t funct) : lambda_(std::move(funct)) {}
+
+    /// This will simply call the lambda function
+    std::string make_help(const App *app, std::string name, AppFormatMode mode) const override {
+        return lambda_(app, name, mode);
+    }
+};
+
+/// This is the default Formatter for CLI11. It pretty prints help output, and is broken into quite a few
+/// overridable methods, to be highly customizable with minimal effort.
+class Formatter : public FormatterBase {
+  public:
+    Formatter() = default;
+    Formatter(const Formatter &) = default;
+    Formatter(Formatter &&) = default;
+
+    /// @name Overridables
+    ///@{
+
+    /// This prints out a group of options with title
+    ///
+    virtual std::string make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const;
+
+    /// This prints out just the positionals "group"
+    virtual std::string make_positionals(const App *app) const;
+
+    /// This prints out all the groups of options
+    std::string make_groups(const App *app, AppFormatMode mode) const;
+
+    /// This prints out all the subcommands
+    virtual std::string make_subcommands(const App *app, AppFormatMode mode) const;
+
+    /// This prints out a subcommand
+    virtual std::string make_subcommand(const App *sub) const;
+
+    /// This prints out a subcommand in help-all
+    virtual std::string make_expanded(const App *sub) const;
+
+    /// This prints out all the groups of options
+    virtual std::string make_footer(const App *app) const;
+
+    /// This displays the description line
+    virtual std::string make_description(const App *app) const;
+
+    /// This displays the usage line
+    virtual std::string make_usage(const App *app, std::string name) const;
+
+    /// This puts everything together
+    std::string make_help(const App *, std::string, AppFormatMode) const override;
+
+    ///@}
+    /// @name Options
+    ///@{
+
+    /// This prints out an option help line, either positional or optional form
+    virtual std::string make_option(const Option *opt, bool is_positional) const {
+        std::stringstream out;
+        detail::format_help(
+            out, make_option_name(opt, is_positional) + make_option_opts(opt), make_option_desc(opt), column_width_);
+        return out.str();
+    }
+
+    /// @brief This is the name part of an option, Default: left column
+    virtual std::string make_option_name(const Option *, bool) const;
+
+    /// @brief This is the options part of the name, Default: combined into left column
+    virtual std::string make_option_opts(const Option *) const;
+
+    /// @brief This is the description. Default: Right column, on new line if left column too large
+    virtual std::string make_option_desc(const Option *) const;
+
+    /// @brief This is used to print the name on the USAGE line
+    virtual std::string make_option_usage(const Option *opt) const;
+
+    ///@}
+};
+
+} // namespace CLI
+
+// From CLI/Option.hpp:
+
+namespace CLI {
+
+using results_t = std::vector<std::string>;
+using callback_t = std::function<bool(results_t)>;
+
+class Option;
+class App;
+
+using Option_p = std::unique_ptr<Option>;
+
+enum class MultiOptionPolicy { Throw, TakeLast, TakeFirst, Join };
+
+/// This is the CRTP base class for Option and OptionDefaults. It was designed this way
+/// to share parts of the class; an OptionDefaults can copy to an Option.
+template <typename CRTP> class OptionBase {
+    friend App;
+
+  protected:
+    /// The group membership
+    std::string group_ = std::string("Options");
+
+    /// True if this is a required option
+    bool required_{false};
+
+    /// Ignore the case when matching (option, not value)
+    bool ignore_case_{false};
+
+    /// Ignore underscores when matching (option, not value)
+    bool ignore_underscore_{false};
+
+    /// Allow this option to be given in a configuration file
+    bool configurable_{true};
+
+    /// Policy for multiple arguments when `expected_ == 1`  (can be set on bool flags, too)
+    MultiOptionPolicy multi_option_policy_{MultiOptionPolicy::Throw};
+
+    /// Copy the contents to another similar class (one based on OptionBase)
+    template <typename T> void copy_to(T *other) const {
+        other->group(group_);
+        other->required(required_);
+        other->ignore_case(ignore_case_);
+        other->ignore_underscore(ignore_underscore_);
+        other->configurable(configurable_);
+        other->multi_option_policy(multi_option_policy_);
+    }
+
+  public:
+    // setters
+
+    /// Changes the group membership
+    CRTP *group(std::string name) {
+        group_ = name;
+        return static_cast<CRTP *>(this);
+        ;
+    }
+
+    /// Set the option as required
+    CRTP *required(bool value = true) {
+        required_ = value;
+        return static_cast<CRTP *>(this);
+    }
+
+    /// Support Plumbum term
+    CRTP *mandatory(bool value = true) { return required(value); }
+
+    // Getters
+
+    /// Get the group of this option
+    const std::string &get_group() const { return group_; }
+
+    /// True if this is a required option
+    bool get_required() const { return required_; }
+
+    /// The status of ignore case
+    bool get_ignore_case() const { return ignore_case_; }
+
+    /// The status of ignore_underscore
+    bool get_ignore_underscore() const { return ignore_underscore_; }
+
+    /// The status of configurable
+    bool get_configurable() const { return configurable_; }
+
+    /// The status of the multi option policy
+    MultiOptionPolicy get_multi_option_policy() const { return multi_option_policy_; }
+
+    // Shortcuts for multi option policy
+
+    /// Set the multi option policy to take last
+    CRTP *take_last() {
+        auto self = static_cast<CRTP *>(this);
+        self->multi_option_policy(MultiOptionPolicy::TakeLast);
+        return self;
+    }
+
+    /// Set the multi option policy to take last
+    CRTP *take_first() {
+        auto self = static_cast<CRTP *>(this);
+        self->multi_option_policy(MultiOptionPolicy::TakeFirst);
+        return self;
+    }
+
+    /// Set the multi option policy to take last
+    CRTP *join() {
+        auto self = static_cast<CRTP *>(this);
+        self->multi_option_policy(MultiOptionPolicy::Join);
+        return self;
+    }
+
+    /// Allow in a configuration file
+    CRTP *configurable(bool value = true) {
+        configurable_ = value;
+        return static_cast<CRTP *>(this);
+    }
+};
+
+/// This is a version of OptionBase that only supports setting values,
+/// for defaults. It is stored as the default option in an App.
+class OptionDefaults : public OptionBase<OptionDefaults> {
+  public:
+    OptionDefaults() = default;
+
+    // Methods here need a different implementation if they are Option vs. OptionDefault
+
+    /// Take the last argument if given multiple times
+    OptionDefaults *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
+        multi_option_policy_ = value;
+        return this;
+    }
+
+    /// Ignore the case of the option name
+    OptionDefaults *ignore_case(bool value = true) {
+        ignore_case_ = value;
+        return this;
+    }
+
+    /// Ignore underscores in the option name
+    OptionDefaults *ignore_underscore(bool value = true) {
+        ignore_underscore_ = value;
+        return this;
+    }
+};
+
+class Option : public OptionBase<Option> {
+    friend App;
+
+  protected:
+    /// @name Names
+    ///@{
+
+    /// A list of the short names (`-a`) without the leading dashes
+    std::vector<std::string> snames_;
+
+    /// A list of the long names (`--a`) without the leading dashes
+    std::vector<std::string> lnames_;
+
+    /// A positional name
+    std::string pname_;
+
+    /// If given, check the environment for this option
+    std::string envname_;
+
+    ///@}
+    /// @name Help
+    ///@{
+
+    /// The description for help strings
+    std::string description_;
+
+    /// A human readable default value, usually only set if default is true in creation
+    std::string defaultval_;
+
+    /// A human readable type value, set when App creates this
+    ///
+    /// This is a lambda function so "types" can be dynamic, such as when a set prints its contents.
+    std::function<std::string()> type_name_{[]() { return std::string(); }};
+
+    /// True if this option has a default
+    bool default_{false};
+
+    ///@}
+    /// @name Configuration
+    ///@{
+
+    /// The number of arguments that make up one option. -1=unlimited (vector-like), 0=flag, 1=normal option,
+    /// 2=complex/pair, etc. Set only when the option is created; this is intrinsic to the type. Eventually, -2 may mean
+    /// vector of pairs.
+    int type_size_{1};
+
+    /// The number of expected values, type_size_ must be < 0. Ignored for flag. N < 0 means at least -N values.
+    int expected_{1};
+
+    /// A list of validators to run on each value parsed
+    std::vector<std::function<std::string(std::string &)>> validators_;
+
+    /// A list of options that are required with this option
+    std::set<Option *> needs_;
+
+    /// A list of options that are excluded with this option
+    std::set<Option *> excludes_;
+
+    ///@}
+    /// @name Other
+    ///@{
+
+    /// Remember the parent app
+    App *parent_;
+
+    /// Options store a callback to do all the work
+    callback_t callback_;
+
+    ///@}
+    /// @name Parsing results
+    ///@{
+
+    /// Results of parsing
+    results_t results_;
+
+    /// Whether the callback has run (needed for INI parsing)
+    bool callback_run_{false};
+
+    ///@}
+
+    /// Making an option by hand is not defined, it must be made by the App class
+    Option(std::string option_name,
+           std::string description,
+           std::function<bool(results_t)> callback,
+           bool defaulted,
+           App *parent)
+        : description_(std::move(description)), default_(defaulted), parent_(parent),
+          callback_(callback ? std::move(callback) : [](results_t) { return true; }) {
+        std::tie(snames_, lnames_, pname_) = detail::get_names(detail::split_names(option_name));
+    }
+
+  public:
+    /// @name Basic
+    ///@{
+
+    /// Count the total number of times an option was passed
+    size_t count() const { return results_.size(); }
+
+    /// True if the option was not passed
+    size_t empty() const { return results_.empty(); }
+
+    /// This class is true if option is passed.
+    operator bool() const { return !empty(); }
+
+    /// Clear the parsed results (mostly for testing)
+    void clear() { results_.clear(); }
+
+    ///@}
+    /// @name Setting options
+    ///@{
+
+    /// Set the number of expected arguments (Flags don't use this)
+    Option *expected(int value) {
+        // Break if this is a flag
+        if(type_size_ == 0)
+            throw IncorrectConstruction::SetFlag(get_name(true, true));
+
+        // Setting 0 is not allowed
+        else if(value == 0)
+            throw IncorrectConstruction::Set0Opt(get_name());
+
+        // No change is okay, quit now
+        else if(expected_ == value)
+            return this;
+
+        // Type must be a vector
+        else if(type_size_ >= 0)
+            throw IncorrectConstruction::ChangeNotVector(get_name());
+
+        // TODO: Can support multioption for non-1 values (except for join)
+        else if(value != 1 && multi_option_policy_ != MultiOptionPolicy::Throw)
+            throw IncorrectConstruction::AfterMultiOpt(get_name());
+
+        expected_ = value;
+        return this;
+    }
+
+    /// Adds a validator with a built in type name
+    Option *check(const Validator &validator) {
+        validators_.emplace_back(validator.func);
+        if(!validator.tname.empty())
+            type_name(validator.tname);
+        return this;
+    }
+
+    /// Adds a validator. Takes a const string& and returns an error message (empty if conversion/check is okay).
+    Option *check(std::function<std::string(const std::string &)> validator) {
+        validators_.emplace_back(validator);
+        return this;
+    }
+
+    /// Adds a validator-like function that can change result
+    Option *transform(std::function<std::string(std::string)> func) {
+        validators_.emplace_back([func](std::string &inout) {
+            try {
+                inout = func(inout);
+            } catch(const ValidationError &e) {
+                return std::string(e.what());
+            }
+            return std::string();
+        });
+        return this;
+    }
+
+    /// Adds a user supplied function to run on each item passed in (communicate though lambda capture)
+    Option *each(std::function<void(std::string)> func) {
+        validators_.emplace_back([func](std::string &inout) {
+            func(inout);
+            return std::string();
+        });
+        return this;
+    }
+
+    /// Sets required options
+    Option *needs(Option *opt) {
+        auto tup = needs_.insert(opt);
+        if(!tup.second)
+            throw OptionAlreadyAdded::Requires(get_name(), opt->get_name());
+        return this;
+    }
+
+    /// Can find a string if needed
+    template <typename T = App> Option *needs(std::string opt_name) {
+        for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
+            if(opt.get() != this && opt->check_name(opt_name))
+                return needs(opt.get());
+        throw IncorrectConstruction::MissingOption(opt_name);
+    }
+
+    /// Any number supported, any mix of string and Opt
+    template <typename A, typename B, typename... ARG> Option *needs(A opt, B opt1, ARG... args) {
+        needs(opt);
+        return needs(opt1, args...);
+    }
+
+    /// Remove needs link from an option. Returns true if the option really was in the needs list.
+    bool remove_needs(Option *opt) {
+        auto iterator = std::find(std::begin(needs_), std::end(needs_), opt);
+
+        if(iterator != std::end(needs_)) {
+            needs_.erase(iterator);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /// Sets excluded options
+    Option *excludes(Option *opt) {
+        excludes_.insert(opt);
+
+        // Help text should be symmetric - excluding a should exclude b
+        opt->excludes_.insert(this);
+
+        // Ignoring the insert return value, excluding twice is now allowed.
+        // (Mostly to allow both directions to be excluded by user, even though the library does it for you.)
+
+        return this;
+    }
+
+    /// Can find a string if needed
+    template <typename T = App> Option *excludes(std::string opt_name) {
+        for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
+            if(opt.get() != this && opt->check_name(opt_name))
+                return excludes(opt.get());
+        throw IncorrectConstruction::MissingOption(opt_name);
+    }
+
+    /// Any number supported, any mix of string and Opt
+    template <typename A, typename B, typename... ARG> Option *excludes(A opt, B opt1, ARG... args) {
+        excludes(opt);
+        return excludes(opt1, args...);
+    }
+
+    /// Remove needs link from an option. Returns true if the option really was in the needs list.
+    bool remove_excludes(Option *opt) {
+        auto iterator = std::find(std::begin(excludes_), std::end(excludes_), opt);
+
+        if(iterator != std::end(excludes_)) {
+            excludes_.erase(iterator);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /// Sets environment variable to read if no option given
+    Option *envname(std::string name) {
+        envname_ = name;
+        return this;
+    }
+
+    /// Ignore case
+    ///
+    /// The template hides the fact that we don't have the definition of App yet.
+    /// You are never expected to add an argument to the template here.
+    template <typename T = App> Option *ignore_case(bool value = true) {
+        ignore_case_ = value;
+        auto *parent = dynamic_cast<T *>(parent_);
+
+        for(const Option_p &opt : parent->options_)
+            if(opt.get() != this && *opt == *this)
+                throw OptionAlreadyAdded(opt->get_name(true, true));
+
+        return this;
+    }
+
+    /// Ignore underscores in the option names
+    ///
+    /// The template hides the fact that we don't have the definition of App yet.
+    /// You are never expected to add an argument to the template here.
+    template <typename T = App> Option *ignore_underscore(bool value = true) {
+        ignore_underscore_ = value;
+        auto *parent = dynamic_cast<T *>(parent_);
+        for(const Option_p &opt : parent->options_)
+            if(opt.get() != this && *opt == *this)
+                throw OptionAlreadyAdded(opt->get_name(true, true));
+
+        return this;
+    }
+
+    /// Take the last argument if given multiple times (or another policy)
+    Option *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
+
+        if(get_items_expected() < 0)
+            throw IncorrectConstruction::MultiOptionPolicy(get_name());
+        multi_option_policy_ = value;
+        return this;
+    }
+
+    ///@}
+    /// @name Accessors
+    ///@{
+
+    /// The number of arguments the option expects
+    int get_type_size() const { return type_size_; }
+
+    /// The environment variable associated to this value
+    std::string get_envname() const { return envname_; }
+
+    /// The set of options needed
+    std::set<Option *> get_needs() const { return needs_; }
+
+    /// The set of options excluded
+    std::set<Option *> get_excludes() const { return excludes_; }
+
+    /// The default value (for help printing)
+    std::string get_defaultval() const { return defaultval_; }
+
+    /// Get the callback function
+    callback_t get_callback() const { return callback_; }
+
+    /// Get the long names
+    const std::vector<std::string> get_lnames() const { return lnames_; }
+
+    /// Get the short names
+    const std::vector<std::string> get_snames() const { return snames_; }
+
+    /// The number of times the option expects to be included
+    int get_expected() const { return expected_; }
+
+    /// \brief The total number of expected values (including the type)
+    /// This is positive if exactly this number is expected, and negative for at least N values
+    ///
+    /// v = fabs(size_type*expected)
+    /// !MultiOptionPolicy::Throw
+    ///           | Expected < 0  | Expected == 0 | Expected > 0
+    /// Size < 0  |      -v       |       0       |     -v
+    /// Size == 0 |       0       |       0       |      0
+    /// Size > 0  |      -v       |       0       |     -v       // Expected must be 1
+    ///
+    /// MultiOptionPolicy::Throw
+    ///           | Expected < 0  | Expected == 0 | Expected > 0
+    /// Size < 0  |      -v       |       0       |      v
+    /// Size == 0 |       0       |       0       |      0
+    /// Size > 0  |       v       |       0       |      v      // Expected must be 1
+    ///
+    int get_items_expected() const {
+        return std::abs(type_size_ * expected_) *
+               ((multi_option_policy_ != MultiOptionPolicy::Throw || (expected_ < 0 && type_size_ < 0) ? -1 : 1));
+    }
+
+    /// True if this has a default value
+    int get_default() const { return default_; }
+
+    /// True if the argument can be given directly
+    bool get_positional() const { return pname_.length() > 0; }
+
+    /// True if option has at least one non-positional name
+    bool nonpositional() const { return (snames_.size() + lnames_.size()) > 0; }
+
+    /// True if option has description
+    bool has_description() const { return description_.length() > 0; }
+
+    /// Get the description
+    const std::string &get_description() const { return description_; }
+
+    /// Set the description
+    Option *description(const std::string &description) {
+        description_ = description;
+        return this;
+    }
+
+    ///@}
+    /// @name Help tools
+    ///@{
+
+    /// \brief Gets a comma separated list of names.
+    /// Will include / prefer the positional name if positional is true.
+    /// If all_options is false, pick just the most descriptive name to show.
+    /// Use `get_name(true)` to get the positional name (replaces `get_pname`)
+    std::string get_name(bool positional = false, //<[input] Show the positional name
+                         bool all_options = false //<[input] Show every option
+                         ) const {
+
+        if(all_options) {
+
+            std::vector<std::string> name_list;
+
+            /// The all list will never include a positional unless asked or that's the only name.
+            if((positional && pname_.length()) || (snames_.empty() && lnames_.empty()))
+                name_list.push_back(pname_);
+
+            for(const std::string &sname : snames_)
+                name_list.push_back("-" + sname);
+
+            for(const std::string &lname : lnames_)
+                name_list.push_back("--" + lname);
+
+            return detail::join(name_list);
+
+        } else {
+
+            // This returns the positional name no matter what
+            if(positional)
+                return pname_;
+
+            // Prefer long name
+            else if(!lnames_.empty())
+                return std::string("--") + lnames_[0];
+
+            // Or short name if no long name
+            else if(!snames_.empty())
+                return std::string("-") + snames_[0];
+
+            // If positional is the only name, it's okay to use that
+            else
+                return pname_;
+        }
+    }
+
+    ///@}
+    /// @name Parser tools
+    ///@{
+
+    /// Process the callback
+    void run_callback() {
+
+        callback_run_ = true;
+
+        // Run the validators (can change the string)
+        if(!validators_.empty()) {
+            for(std::string &result : results_)
+                for(const std::function<std::string(std::string &)> &vali : validators_) {
+                    std::string err_msg = vali(result);
+                    if(!err_msg.empty())
+                        throw ValidationError(get_name(), err_msg);
+                }
+        }
+
+        bool local_result;
+
+        // Num items expected or length of vector, always at least 1
+        // Only valid for a trimming policy
+        int trim_size =
+            std::min<int>(std::max<int>(std::abs(get_items_expected()), 1), static_cast<int>(results_.size()));
+
+        // Operation depends on the policy setting
+        if(multi_option_policy_ == MultiOptionPolicy::TakeLast) {
+            // Allow multi-option sizes (including 0)
+            results_t partial_result{results_.end() - trim_size, results_.end()};
+            local_result = !callback_(partial_result);
+
+        } else if(multi_option_policy_ == MultiOptionPolicy::TakeFirst) {
+            results_t partial_result{results_.begin(), results_.begin() + trim_size};
+            local_result = !callback_(partial_result);
+
+        } else if(multi_option_policy_ == MultiOptionPolicy::Join) {
+            results_t partial_result = {detail::join(results_, "\n")};
+            local_result = !callback_(partial_result);
+
+        } else {
+            // Exact number required
+            if(get_items_expected() > 0) {
+                if(results_.size() != static_cast<size_t>(get_items_expected()))
+                    throw ArgumentMismatch(get_name(), get_items_expected(), results_.size());
+                // Variable length list
+            } else if(get_items_expected() < 0) {
+                // Require that this be a multiple of expected size and at least as many as expected
+                if(results_.size() < static_cast<size_t>(-get_items_expected()) ||
+                   results_.size() % static_cast<size_t>(std::abs(get_type_size())) != 0)
+                    throw ArgumentMismatch(get_name(), get_items_expected(), results_.size());
+            }
+            local_result = !callback_(results_);
+        }
+
+        if(local_result)
+            throw ConversionError(get_name(), results_);
+    }
+
+    /// If options share any of the same names, they are equal (not counting positional)
+    bool operator==(const Option &other) const {
+        for(const std::string &sname : snames_)
+            if(other.check_sname(sname))
+                return true;
+        for(const std::string &lname : lnames_)
+            if(other.check_lname(lname))
+                return true;
+        // We need to do the inverse, just in case we are ignore_case or ignore underscore
+        for(const std::string &sname : other.snames_)
+            if(check_sname(sname))
+                return true;
+        for(const std::string &lname : other.lnames_)
+            if(check_lname(lname))
+                return true;
+        return false;
+    }
+
+    /// Check a name. Requires "-" or "--" for short / long, supports positional name
+    bool check_name(std::string name) const {
+
+        if(name.length() > 2 && name.substr(0, 2) == "--")
+            return check_lname(name.substr(2));
+        else if(name.length() > 1 && name.substr(0, 1) == "-")
+            return check_sname(name.substr(1));
+        else {
+            std::string local_pname = pname_;
+            if(ignore_case_) {
+                local_pname = detail::to_lower(local_pname);
+                name = detail::to_lower(name);
+            }
+            if(ignore_underscore_) {
+                local_pname = detail::remove_underscore(local_pname);
+                name = detail::remove_underscore(name);
+            }
+            return name == local_pname;
+        }
+    }
+
+    /// Requires "-" to be removed from string
+    bool check_sname(std::string name) const {
+        if(ignore_case_) { // there can be no extra underscores in check_sname
+            name = detail::to_lower(name);
+            return std::find_if(std::begin(snames_), std::end(snames_), [&name](std::string local_sname) {
+                       return detail::to_lower(local_sname) == name;
+                   }) != std::end(snames_);
+        } else
+            return std::find(std::begin(snames_), std::end(snames_), name) != std::end(snames_);
+    }
+
+    /// Requires "--" to be removed from string
+    bool check_lname(std::string name) const {
+        if(ignore_case_) {
+            if(ignore_underscore_) {
+                name = detail::to_lower(detail::remove_underscore(name));
+                return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
+                           return detail::to_lower(detail::remove_underscore(local_sname)) == name;
+                       }) != std::end(lnames_);
+            } else {
+                name = detail::to_lower(name);
+                return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
+                           return detail::to_lower(local_sname) == name;
+                       }) != std::end(lnames_);
+            }
+
+        } else if(ignore_underscore_) {
+            name = detail::remove_underscore(name);
+            return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
+                       return detail::remove_underscore(local_sname) == name;
+                   }) != std::end(lnames_);
+        } else
+            return std::find(std::begin(lnames_), std::end(lnames_), name) != std::end(lnames_);
+    }
+
+    /// Puts a result at the end
+    Option *add_result(std::string s) {
+        results_.push_back(s);
+        callback_run_ = false;
+        return this;
+    }
+
+    /// Set the results vector all at once
+    Option *set_results(std::vector<std::string> result_vector) {
+        results_ = std::move(result_vector);
+        callback_run_ = false;
+        return this;
+    }
+
+    /// Get a copy of the results
+    std::vector<std::string> results() const { return results_; }
+
+    /// See if the callback has been run already
+    bool get_callback_run() const { return callback_run_; }
+
+    ///@}
+    /// @name Custom options
+    ///@{
+
+    /// Set the type function to run when displayed on this option
+    Option *type_name_fn(std::function<std::string()> typefun) {
+        type_name_ = typefun;
+        return this;
+    }
+
+    /// Set a custom option typestring
+    Option *type_name(std::string typeval) {
+        type_name_fn([typeval]() { return typeval; });
+        return this;
+    }
+
+    /// Set a custom option size
+    Option *type_size(int option_type_size) {
+        type_size_ = option_type_size;
+        if(type_size_ == 0)
+            required_ = false;
+        if(option_type_size < 0)
+            expected_ = -1;
+        return this;
+    }
+
+    /// Set the default value string representation
+    Option *default_str(std::string val) {
+        defaultval_ = val;
+        return this;
+    }
+
+    /// Set the default value string representation and evaluate
+    Option *default_val(std::string val) {
+        default_str(val);
+        auto old_results = results_;
+        results_ = {val};
+        run_callback();
+        results_ = std::move(old_results);
+        return this;
+    }
+
+    /// Get the typename for this option
+    std::string get_type_name() const { return type_name_(); }
+};
+
+} // namespace CLI
+
+// From CLI/App.hpp:
+
+namespace CLI {
+
+#ifndef CLI11_PARSE
+#define CLI11_PARSE(app, argc, argv)                                                                                   \
+    try {                                                                                                              \
+        (app).parse((argc), (argv));                                                                                   \
+    } catch(const CLI::ParseError &e) {                                                                                \
+        return (app).exit(e);                                                                                          \
+    }
+#endif
+
+namespace detail {
+enum class Classifier { NONE, POSITIONAL_MARK, SHORT, LONG, WINDOWS, SUBCOMMAND };
+struct AppFriend;
+} // namespace detail
+
+namespace FailureMessage {
+std::string simple(const App *app, const Error &e);
+std::string help(const App *app, const Error &e);
+} // namespace FailureMessage
+
+class App;
+
+using App_p = std::unique_ptr<App>;
+
+/// Creates a command line program, with very few defaults.
+/** To use, create a new `Program()` instance with `argc`, `argv`, and a help description. The templated
+ *  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
+ * program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
+class App {
+    friend Option;
+    friend detail::AppFriend;
+
+  protected:
+    // This library follows the Google style guide for member names ending in underscores
+
+    /// @name Basics
+    ///@{
+
+    /// Subcommand name or program name (from parser if name is empty)
+    std::string name_;
+
+    /// Description of the current program/subcommand
+    std::string description_;
+
+    /// If true, allow extra arguments (ie, don't throw an error). INHERITABLE
+    bool allow_extras_{false};
+
+    /// If true, allow extra arguments in the ini file (ie, don't throw an error). INHERITABLE
+    bool allow_config_extras_{false};
+
+    ///  If true, return immediately on an unrecognised option (implies allow_extras) INHERITABLE
+    bool prefix_command_{false};
+
+    /// This is a function that runs when complete. Great for subcommands. Can throw.
+    std::function<void()> callback_;
+
+    ///@}
+    /// @name Options
+    ///@{
+
+    /// The default values for options, customizable and changeable INHERITABLE
+    OptionDefaults option_defaults_;
+
+    /// The list of options, stored locally
+    std::vector<Option_p> options_;
+
+    ///@}
+    /// @name Help
+    ///@{
+
+    /// Footer to put after all options in the help output INHERITABLE
+    std::string footer_;
+
+    /// A pointer to the help flag if there is one INHERITABLE
+    Option *help_ptr_{nullptr};
+
+    /// A pointer to the help all flag if there is one INHERITABLE
+    Option *help_all_ptr_{nullptr};
+
+    /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
+    std::shared_ptr<FormatterBase> formatter_{new Formatter()};
+
+    /// The error message printing function INHERITABLE
+    std::function<std::string(const App *, const Error &e)> failure_message_ = FailureMessage::simple;
+
+    ///@}
+    /// @name Parsing
+    ///@{
+
+    using missing_t = std::vector<std::pair<detail::Classifier, std::string>>;
+
+    /// Pair of classifier, string for missing options. (extra detail is removed on returning from parse)
+    ///
+    /// This is faster and cleaner than storing just a list of strings and reparsing. This may contain the -- separator.
+    missing_t missing_;
+
+    /// This is a list of pointers to options with the original parse order
+    std::vector<Option *> parse_order_;
+
+    /// This is a list of the subcommands collected, in order
+    std::vector<App *> parsed_subcommands_;
+
+    ///@}
+    /// @name Subcommands
+    ///@{
+
+    /// Storage for subcommand list
+    std::vector<App_p> subcommands_;
+
+    /// If true, the program name is not case sensitive INHERITABLE
+    bool ignore_case_{false};
+
+    /// If true, the program should ignore underscores INHERITABLE
+    bool ignore_underscore_{false};
+
+    /// Allow subcommand fallthrough, so that parent commands can collect commands after subcommand.  INHERITABLE
+    bool fallthrough_{false};
+
+    /// Allow '/' for options for Windows like options. Defaults to true on Windows, false otherwise. INHERITABLE
+    bool allow_windows_style_options_{
+#ifdef _WIN32
+        true
+#else
+        false
+#endif
+    };
+
+    /// A pointer to the parent if this is a subcommand
+    App *parent_{nullptr};
+
+    /// Counts the number of times this command/subcommand was parsed
+    size_t parsed_ = 0;
+
+    /// Minimum required subcommands (not inheritable!)
+    size_t require_subcommand_min_ = 0;
+
+    /// Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE
+    size_t require_subcommand_max_ = 0;
+
+    /// The group membership INHERITABLE
+    std::string group_{"Subcommands"};
+
+    ///@}
+    /// @name Config
+    ///@{
+
+    /// The name of the connected config file
+    std::string config_name_;
+
+    /// True if ini is required (throws if not present), if false simply keep going.
+    bool config_required_{false};
+
+    /// Pointer to the config option
+    Option *config_ptr_{nullptr};
+
+    /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
+    std::shared_ptr<Config> config_formatter_{new ConfigINI()};
+
+    ///@}
+
+    /// Special private constructor for subcommand
+    App(std::string description, std::string app_name, App *parent)
+        : name_(std::move(app_name)), description_(std::move(description)), parent_(parent) {
+        // Inherit if not from a nullptr
+        if(parent_ != nullptr) {
+            if(parent_->help_ptr_ != nullptr)
+                set_help_flag(parent_->help_ptr_->get_name(false, true), parent_->help_ptr_->get_description());
+            if(parent_->help_all_ptr_ != nullptr)
+                set_help_all_flag(parent_->help_all_ptr_->get_name(false, true),
+                                  parent_->help_all_ptr_->get_description());
+
+            /// OptionDefaults
+            option_defaults_ = parent_->option_defaults_;
+
+            // INHERITABLE
+            failure_message_ = parent_->failure_message_;
+            allow_extras_ = parent_->allow_extras_;
+            allow_config_extras_ = parent_->allow_config_extras_;
+            prefix_command_ = parent_->prefix_command_;
+            ignore_case_ = parent_->ignore_case_;
+            ignore_underscore_ = parent_->ignore_underscore_;
+            fallthrough_ = parent_->fallthrough_;
+            allow_windows_style_options_ = parent_->allow_windows_style_options_;
+            group_ = parent_->group_;
+            footer_ = parent_->footer_;
+            formatter_ = parent_->formatter_;
+            config_formatter_ = parent_->config_formatter_;
+            require_subcommand_max_ = parent_->require_subcommand_max_;
+        }
+    }
+
+  public:
+    /// @name Basic
+    ///@{
+
+    /// Create a new program. Pass in the same arguments as main(), along with a help string.
+    explicit App(std::string description = "", std::string app_name = "") : App(description, app_name, nullptr) {
+        set_help_flag("-h,--help", "Print this help message and exit");
+    }
+
+    /// virtual destructor
+    virtual ~App() = default;
+
+    /// Set a callback for the end of parsing.
+    ///
+    /// Due to a bug in c++11,
+    /// it is not possible to overload on std::function (fixed in c++14
+    /// and backported to c++11 on newer compilers). Use capture by reference
+    /// to get a pointer to App if needed.
+    App *callback(std::function<void()> app_callback) {
+        callback_ = std::move(app_callback);
+        return this;
+    }
+
+    /// Set a name for the app (empty will use parser to set the name)
+    App *name(std::string app_name = "") {
+        name_ = app_name;
+        return this;
+    }
+
+    /// Remove the error when extras are left over on the command line.
+    App *allow_extras(bool allow = true) {
+        allow_extras_ = allow;
+        return this;
+    }
+
+    /// Remove the error when extras are left over on the command line.
+    /// Will also call App::allow_extras().
+    App *allow_config_extras(bool allow = true) {
+        allow_extras(allow);
+        allow_config_extras_ = allow;
+        return this;
+    }
+
+    /// Do not parse anything after the first unrecognized option and return
+    App *prefix_command(bool allow = true) {
+        prefix_command_ = allow;
+        return this;
+    }
+
+    /// Ignore case. Subcommands inherit value.
+    App *ignore_case(bool value = true) {
+        ignore_case_ = value;
+        if(parent_ != nullptr) {
+            for(const auto &subc : parent_->subcommands_) {
+                if(subc.get() != this && (this->check_name(subc->name_) || subc->check_name(this->name_)))
+                    throw OptionAlreadyAdded(subc->name_);
+            }
+        }
+        return this;
+    }
+
+    /// Allow windows style options, such as `/opt`. First matching short or long name used. Subcommands inherit value.
+    App *allow_windows_style_options(bool value = true) {
+        allow_windows_style_options_ = value;
+        return this;
+    }
+
+    /// Ignore underscore. Subcommands inherit value.
+    App *ignore_underscore(bool value = true) {
+        ignore_underscore_ = value;
+        if(parent_ != nullptr) {
+            for(const auto &subc : parent_->subcommands_) {
+                if(subc.get() != this && (this->check_name(subc->name_) || subc->check_name(this->name_)))
+                    throw OptionAlreadyAdded(subc->name_);
+            }
+        }
+        return this;
+    }
+
+    /// Set the help formatter
+    App *formatter(std::shared_ptr<FormatterBase> fmt) {
+        formatter_ = fmt;
+        return this;
+    }
+
+    /// Set the help formatter
+    App *formatter_fn(std::function<std::string(const App *, std::string, AppFormatMode)> fmt) {
+        formatter_ = std::make_shared<FormatterLambda>(fmt);
+        return this;
+    }
+
+    /// Set the config formatter
+    App *config_formatter(std::shared_ptr<Config> fmt) {
+        config_formatter_ = fmt;
+        return this;
+    }
+
+    /// Check to see if this subcommand was parsed, true only if received on command line.
+    bool parsed() const { return parsed_ > 0; }
+
+    /// Get the OptionDefault object, to set option defaults
+    OptionDefaults *option_defaults() { return &option_defaults_; }
+
+    ///@}
+    /// @name Adding options
+    ///@{
+
+    /// Add an option, will automatically understand the type for common types.
+    ///
+    /// To use, create a variable with the expected type, and pass it in after the name.
+    /// After start is called, you can use count to see if the value was passed, and
+    /// the value will be initialized properly. Numbers, vectors, and strings are supported.
+    ///
+    /// ->required(), ->default, and the validators are options,
+    /// The positional options take an optional number of arguments.
+    ///
+    /// For example,
+    ///
+    ///     std::string filename;
+    ///     program.add_option("filename", filename, "description of filename");
+    ///
+    Option *add_option(std::string option_name,
+                       callback_t option_callback,
+                       std::string description = "",
+                       bool defaulted = false) {
+        Option myopt{option_name, description, option_callback, defaulted, this};
+
+        if(std::find_if(std::begin(options_), std::end(options_), [&myopt](const Option_p &v) {
+               return *v == myopt;
+           }) == std::end(options_)) {
+            options_.emplace_back();
+            Option_p &option = options_.back();
+            option.reset(new Option(option_name, description, option_callback, defaulted, this));
+            option_defaults_.copy_to(option.get());
+            return option.get();
+        } else
+            throw OptionAlreadyAdded(myopt.get_name());
+    }
+
+    /// Add option for non-vectors (duplicate copy needed without defaulted to avoid `iostream << value`)
+    template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
+    Option *add_option(std::string option_name,
+                       T &variable, ///< The variable to set
+                       std::string description = "") {
+
+        CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name(detail::type_name<T>());
+        return opt;
+    }
+
+    /// Add option for non-vectors with a default print
+    template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
+    Option *add_option(std::string option_name,
+                       T &variable, ///< The variable to set
+                       std::string description,
+                       bool defaulted) {
+
+        CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name(detail::type_name<T>());
+        if(defaulted) {
+            std::stringstream out;
+            out << variable;
+            opt->default_str(out.str());
+        }
+        return opt;
+    }
+
+    /// Add option for vectors (no default)
+    template <typename T>
+    Option *add_option(std::string option_name,
+                       std::vector<T> &variable, ///< The variable vector to set
+                       std::string description = "") {
+
+        CLI::callback_t fun = [&variable](CLI::results_t res) {
+            bool retval = true;
+            variable.clear();
+            for(const auto &a : res) {
+                variable.emplace_back();
+                retval &= detail::lexical_cast(a, variable.back());
+            }
+            return (!variable.empty()) && retval;
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name(detail::type_name<T>())->type_size(-1);
+        return opt;
+    }
+
+    /// Add option for vectors
+    template <typename T>
+    Option *add_option(std::string option_name,
+                       std::vector<T> &variable, ///< The variable vector to set
+                       std::string description,
+                       bool defaulted) {
+
+        CLI::callback_t fun = [&variable](CLI::results_t res) {
+            bool retval = true;
+            variable.clear();
+            for(const auto &a : res) {
+                variable.emplace_back();
+                retval &= detail::lexical_cast(a, variable.back());
+            }
+            return (!variable.empty()) && retval;
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name(detail::type_name<T>())->type_size(-1);
+        if(defaulted)
+            opt->default_str("[" + detail::join(variable) + "]");
+        return opt;
+    }
+
+    /// Set a help flag, replace the existing one if present
+    Option *set_help_flag(std::string flag_name = "", std::string description = "") {
+        if(help_ptr_ != nullptr) {
+            remove_option(help_ptr_);
+            help_ptr_ = nullptr;
+        }
+
+        // Empty name will simply remove the help flag
+        if(!flag_name.empty()) {
+            help_ptr_ = add_flag(flag_name, description);
+            help_ptr_->configurable(false);
+        }
+
+        return help_ptr_;
+    }
+
+    /// Set a help all flag, replaced the existing one if present
+    Option *set_help_all_flag(std::string help_name = "", std::string description = "") {
+        if(help_all_ptr_ != nullptr) {
+            remove_option(help_all_ptr_);
+            help_all_ptr_ = nullptr;
+        }
+
+        // Empty name will simply remove the help all flag
+        if(!help_name.empty()) {
+            help_all_ptr_ = add_flag(help_name, description);
+            help_all_ptr_->configurable(false);
+        }
+
+        return help_all_ptr_;
+    }
+
+    /// Add option for flag
+    Option *add_flag(std::string flag_name, std::string description = "") {
+        CLI::callback_t fun = [](CLI::results_t) { return true; };
+
+        Option *opt = add_option(flag_name, fun, description, false);
+        if(opt->get_positional())
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
+        return opt;
+    }
+
+    /// Add option for flag integer
+    template <typename T,
+              enable_if_t<std::is_integral<T>::value && !is_bool<T>::value, detail::enabler> = detail::dummy>
+    Option *add_flag(std::string flag_name,
+                     T &flag_count, ///< A variable holding the count
+                     std::string description = "") {
+
+        flag_count = 0;
+        CLI::callback_t fun = [&flag_count](CLI::results_t res) {
+            flag_count = static_cast<T>(res.size());
+            return true;
+        };
+
+        Option *opt = add_option(flag_name, fun, description, false);
+        if(opt->get_positional())
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
+        return opt;
+    }
+
+    /// Bool version - defaults to allowing multiple passings, but can be forced to one if
+    /// `multi_option_policy(CLI::MultiOptionPolicy::Throw)` is used.
+    template <typename T, enable_if_t<is_bool<T>::value, detail::enabler> = detail::dummy>
+    Option *add_flag(std::string flag_name,
+                     T &flag_count, ///< A variable holding true if passed
+                     std::string description = "") {
+
+        flag_count = false;
+        CLI::callback_t fun = [&flag_count](CLI::results_t res) {
+            flag_count = true;
+            return res.size() == 1;
+        };
+
+        Option *opt = add_option(flag_name, fun, description, false);
+        if(opt->get_positional())
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
+        opt->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
+        return opt;
+    }
+
+    /// Add option for callback
+    Option *add_flag_function(std::string flag_name,
+                              std::function<void(size_t)> function, ///< A function to call, void(size_t)
+                              std::string description = "") {
+
+        CLI::callback_t fun = [function](CLI::results_t res) {
+            function(res.size());
+            return true;
+        };
+
+        Option *opt = add_option(flag_name, fun, description, false);
+        if(opt->get_positional())
+            throw IncorrectConstruction::PositionalFlag(flag_name);
+        opt->type_size(0);
+        return opt;
+    }
+
+#ifdef CLI11_CPP14
+    /// Add option for callback (C++14 or better only)
+    Option *add_flag(std::string flag_name,
+                     std::function<void(size_t)> function, ///< A function to call, void(size_t)
+                     std::string description = "") {
+        return add_flag_function(flag_name, std::move(function), description);
+    }
+#endif
+
+    /// Add set of options (No default, temp reference, such as an inline set)
+    template <typename T>
+    Option *add_set(std::string option_name,
+                    T &member,           ///< The selected member of the set
+                    std::set<T> options, ///< The set of possibilities
+                    std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            bool retval = detail::lexical_cast(res[0], member);
+            if(!retval)
+                throw ConversionError(res[0], simple_name);
+            return std::find(std::begin(options), std::end(options), member) != std::end(options);
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        std::string typeval = detail::type_name<T>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+        return opt;
+    }
+
+    /// Add set of options (No default, set can be changed afterwords - do not destroy the set)
+    template <typename T>
+    Option *add_mutable_set(std::string option_name,
+                            T &member,                  ///< The selected member of the set
+                            const std::set<T> &options, ///< The set of possibilities
+                            std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            bool retval = detail::lexical_cast(res[0], member);
+            if(!retval)
+                throw ConversionError(res[0], simple_name);
+            return std::find(std::begin(options), std::end(options), member) != std::end(options);
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn(
+            [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
+
+        return opt;
+    }
+
+    /// Add set of options (with default, static set, such as an inline set)
+    template <typename T>
+    Option *add_set(std::string option_name,
+                    T &member,           ///< The selected member of the set
+                    std::set<T> options, ///< The set of possibilities
+                    std::string description,
+                    bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            bool retval = detail::lexical_cast(res[0], member);
+            if(!retval)
+                throw ConversionError(res[0], simple_name);
+            return std::find(std::begin(options), std::end(options), member) != std::end(options);
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        std::string typeval = detail::type_name<T>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+        if(defaulted) {
+            std::stringstream out;
+            out << member;
+            opt->default_str(out.str());
+        }
+        return opt;
+    }
+
+    /// Add set of options (with default, set can be changed afterwards - do not destroy the set)
+    template <typename T>
+    Option *add_mutable_set(std::string option_name,
+                            T &member,                  ///< The selected member of the set
+                            const std::set<T> &options, ///< The set of possibilities
+                            std::string description,
+                            bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            bool retval = detail::lexical_cast(res[0], member);
+            if(!retval)
+                throw ConversionError(res[0], simple_name);
+            return std::find(std::begin(options), std::end(options), member) != std::end(options);
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn(
+            [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
+        if(defaulted) {
+            std::stringstream out;
+            out << member;
+            opt->default_str(out.str());
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore case (no default, static set)
+    Option *add_set_ignore_case(std::string option_name,
+                                std::string &member,           ///< The selected member of the set
+                                std::set<std::string> options, ///< The set of possibilities
+                                std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore case (no default, set can be changed afterwards - do not destroy the
+    /// set)
+    Option *add_mutable_set_ignore_case(std::string option_name,
+                                        std::string &member,                  ///< The selected member of the set
+                                        const std::set<std::string> &options, ///< The set of possibilities
+                                        std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore case (default, static set)
+    Option *add_set_ignore_case(std::string option_name,
+                                std::string &member,           ///< The selected member of the set
+                                std::set<std::string> options, ///< The set of possibilities
+                                std::string description,
+                                bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore case (default, set can be changed afterwards - do not destroy the set)
+    Option *add_mutable_set_ignore_case(std::string option_name,
+                                        std::string &member,                  ///< The selected member of the set
+                                        const std::set<std::string> &options, ///< The set of possibilities
+                                        std::string description,
+                                        bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore (no default, static set)
+    Option *add_set_ignore_underscore(std::string option_name,
+                                      std::string &member,           ///< The selected member of the set
+                                      std::set<std::string> options, ///< The set of possibilities
+                                      std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore (no default, set can be changed afterwards - do not destroy
+    /// the set)
+    Option *add_mutable_set_ignore_underscore(std::string option_name,
+                                              std::string &member,                  ///< The selected member of the set
+                                              const std::set<std::string> &options, ///< The set of possibilities
+                                              std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore (default, static set)
+    Option *add_set_ignore_underscore(std::string option_name,
+                                      std::string &member,           ///< The selected member of the set
+                                      std::set<std::string> options, ///< The set of possibilities
+                                      std::string description,
+                                      bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore (default, set can be changed afterwards - do not destroy the
+    /// set)
+    Option *add_mutable_set_ignore_underscore(std::string option_name,
+                                              std::string &member,                  ///< The selected member of the set
+                                              const std::set<std::string> &options, ///< The set of possibilities
+                                              std::string description,
+                                              bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::remove_underscore(res[0]);
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::remove_underscore(val) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (no default, static set)
+    Option *add_set_ignore_case_underscore(std::string option_name,
+                                           std::string &member,           ///< The selected member of the set
+                                           std::set<std::string> options, ///< The set of possibilities
+                                           std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (no default, set can be changed afterwards - do not
+    /// destroy the set)
+    Option *add_mutable_set_ignore_case_underscore(std::string option_name,
+                                                   std::string &member, ///< The selected member of the set
+                                                   const std::set<std::string> &options, ///< The set of possibilities
+                                                   std::string description = "") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, false);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (default, static set)
+    Option *add_set_ignore_case_underscore(std::string option_name,
+                                           std::string &member,           ///< The selected member of the set
+                                           std::set<std::string> options, ///< The set of possibilities
+                                           std::string description,
+                                           bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        std::string typeval = detail::type_name<std::string>();
+        typeval += " in {" + detail::join(options) + "}";
+        opt->type_name(typeval);
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add set of options, string only, ignore underscore and case (default, set can be changed afterwards - do not
+    /// destroy the set)
+    Option *add_mutable_set_ignore_case_underscore(std::string option_name,
+                                                   std::string &member, ///< The selected member of the set
+                                                   const std::set<std::string> &options, ///< The set of possibilities
+                                                   std::string description,
+                                                   bool defaulted) {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
+            member = detail::to_lower(detail::remove_underscore(res[0]));
+            auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
+                return detail::to_lower(detail::remove_underscore(val)) == member;
+            });
+            if(iter == std::end(options))
+                throw ConversionError(member, simple_name);
+            else {
+                member = *iter;
+                return true;
+            }
+        };
+
+        Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name_fn([&options]() {
+            return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
+        });
+        if(defaulted) {
+            opt->default_str(member);
+        }
+        return opt;
+    }
+
+    /// Add a complex number
+    template <typename T>
+    Option *add_complex(std::string option_name,
+                        T &variable,
+                        std::string description = "",
+                        bool defaulted = false,
+                        std::string label = "COMPLEX") {
+
+        std::string simple_name = CLI::detail::split(option_name, ',').at(0);
+        CLI::callback_t fun = [&variable, simple_name, label](results_t res) {
+            if(res[1].back() == 'i')
+                res[1].pop_back();
+            double x, y;
+            bool worked = detail::lexical_cast(res[0], x) && detail::lexical_cast(res[1], y);
+            if(worked)
+                variable = T(x, y);
+            return worked;
+        };
+
+        CLI::Option *opt = add_option(option_name, fun, description, defaulted);
+        opt->type_name(label)->type_size(2);
+        if(defaulted) {
+            std::stringstream out;
+            out << variable;
+            opt->default_str(out.str());
+        }
+        return opt;
+    }
+
+    /// Set a configuration ini file option, or clear it if no name passed
+    Option *set_config(std::string option_name = "",
+                       std::string default_filename = "",
+                       std::string help_message = "Read an ini file",
+                       bool required = false) {
+
+        // Remove existing config if present
+        if(config_ptr_ != nullptr)
+            remove_option(config_ptr_);
+
+        // Only add config if option passed
+        if(!option_name.empty()) {
+            config_name_ = default_filename;
+            config_required_ = required;
+            config_ptr_ = add_option(option_name, config_name_, help_message, !default_filename.empty());
+            config_ptr_->configurable(false);
+        }
+
+        return config_ptr_;
+    }
+
+    /// Removes an option from the App. Takes an option pointer. Returns true if found and removed.
+    bool remove_option(Option *opt) {
+        // Make sure no links exist
+        for(Option_p &op : options_) {
+            op->remove_needs(opt);
+            op->remove_excludes(opt);
+        }
+
+        if(help_ptr_ == opt)
+            help_ptr_ = nullptr;
+        if(help_all_ptr_ == opt)
+            help_all_ptr_ = nullptr;
+
+        auto iterator =
+            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
+        if(iterator != std::end(options_)) {
+            options_.erase(iterator);
+            return true;
+        }
+        return false;
+    }
+
+    ///@}
+    /// @name Subcommmands
+    ///@{
+
+    /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
+    App *add_subcommand(std::string subcommand_name, std::string description = "") {
+        CLI::App_p subcom(new App(description, subcommand_name, this));
+        for(const auto &subc : subcommands_)
+            if(subc->check_name(subcommand_name) || subcom->check_name(subc->name_))
+                throw OptionAlreadyAdded(subc->name_);
+        subcommands_.push_back(std::move(subcom));
+        return subcommands_.back().get();
+    }
+
+    /// Check to see if a subcommand is part of this command (doesn't have to be in command line)
+    App *get_subcommand(App *subcom) const {
+        for(const App_p &subcomptr : subcommands_)
+            if(subcomptr.get() == subcom)
+                return subcom;
+        throw OptionNotFound(subcom->get_name());
+    }
+
+    /// Check to see if a subcommand is part of this command (text version)
+    App *get_subcommand(std::string subcom) const {
+        for(const App_p &subcomptr : subcommands_)
+            if(subcomptr->check_name(subcom))
+                return subcomptr.get();
+        throw OptionNotFound(subcom);
+    }
+
+    /// No argument version of count counts the number of times this subcommand was
+    /// passed in. The main app will return 1.
+    size_t count() const { return parsed_; }
+
+    /// Changes the group membership
+    App *group(std::string group_name) {
+        group_ = group_name;
+        return this;
+    }
+
+    /// The argumentless form of require subcommand requires 1 or more subcommands
+    App *require_subcommand() {
+        require_subcommand_min_ = 1;
+        require_subcommand_max_ = 0;
+        return this;
+    }
+
+    /// Require a subcommand to be given (does not affect help call)
+    /// The number required can be given. Negative values indicate maximum
+    /// number allowed (0 for any number). Max number inheritable.
+    App *require_subcommand(int value) {
+        if(value < 0) {
+            require_subcommand_min_ = 0;
+            require_subcommand_max_ = static_cast<size_t>(-value);
+        } else {
+            require_subcommand_min_ = static_cast<size_t>(value);
+            require_subcommand_max_ = static_cast<size_t>(value);
+        }
+        return this;
+    }
+
+    /// Explicitly control the number of subcommands required. Setting 0
+    /// for the max means unlimited number allowed. Max number inheritable.
+    App *require_subcommand(size_t min, size_t max) {
+        require_subcommand_min_ = min;
+        require_subcommand_max_ = max;
+        return this;
+    }
+
+    /// Stop subcommand fallthrough, so that parent commands cannot collect commands after subcommand.
+    /// Default from parent, usually set on parent.
+    App *fallthrough(bool value = true) {
+        fallthrough_ = value;
+        return this;
+    }
+
+    /// Check to see if this subcommand was parsed, true only if received on command line.
+    /// This allows the subcommand to be directly checked.
+    operator bool() const { return parsed_ > 0; }
+
+    ///@}
+    /// @name Extras for subclassing
+    ///@{
+
+    /// This allows subclasses to inject code before callbacks but after parse.
+    ///
+    /// This does not run if any errors or help is thrown.
+    virtual void pre_callback() {}
+
+    ///@}
+    /// @name Parsing
+    ///@{
+    //
+    /// Reset the parsed data
+    void clear() {
+
+        parsed_ = false;
+        missing_.clear();
+        parsed_subcommands_.clear();
+
+        for(const Option_p &opt : options_) {
+            opt->clear();
+        }
+        for(const App_p &app : subcommands_) {
+            app->clear();
+        }
+    }
+
+    /// Parses the command line - throws errors.
+    /// This must be called after the options are in but before the rest of the program.
+    void parse(int argc, const char *const *argv) {
+        // If the name is not set, read from command line
+        if(name_.empty())
+            name_ = argv[0];
+
+        std::vector<std::string> args;
+        for(int i = argc - 1; i > 0; i--)
+            args.emplace_back(argv[i]);
+        parse(args);
+    }
+
+    /// Parse a single string as if it contained command line arguments.
+    /// This function splits the string into arguments then calls parse(std::vector<std::string> &)
+    /// the function takes an optional boolean argument specifying if the programName is included in the string to
+    /// process
+    void parse(std::string commandline, bool program_name_included = false) {
+
+        if(program_name_included) {
+            auto nstr = detail::split_program_name(commandline);
+            if(name_.empty()) {
+                name_ = nstr.first;
+            }
+            commandline = std::move(nstr.second);
+        } else
+            detail::trim(commandline);
+        // the next section of code is to deal with quoted arguments after an '=' or ':' for windows like operations
+        if(!commandline.empty()) {
+            commandline = detail::find_and_modify(commandline, "=", detail::escape_detect);
+            if(allow_windows_style_options_)
+                commandline = detail::find_and_modify(commandline, ":", detail::escape_detect);
+        }
+
+        auto args = detail::split_up(std::move(commandline));
+        // remove all empty strings
+        args.erase(std::remove(args.begin(), args.end(), std::string()), args.end());
+        std::reverse(args.begin(), args.end());
+
+        parse(args);
+    }
+
+    /// The real work is done here. Expects a reversed vector.
+    /// Changes the vector to the remaining options.
+    void parse(std::vector<std::string> &args) {
+        // Clear if parsed
+        if(parsed_ > 0)
+            clear();
+
+        // _parse is incremented in commands/subcommands,
+        // but placed here to make sure this is cleared when
+        // running parse after an error is thrown, even by _validate.
+        parsed_ = 1;
+        _validate();
+        parsed_ = 0;
+
+        _parse(args);
+        run_callback();
+    }
+
+    /// Provide a function to print a help message. The function gets access to the App pointer and error.
+    void failure_message(std::function<std::string(const App *, const Error &e)> function) {
+        failure_message_ = function;
+    }
+
+    /// Print a nice error message and return the exit code
+    int exit(const Error &e, std::ostream &out = std::cout, std::ostream &err = std::cerr) const {
+
+        /// Avoid printing anything if this is a CLI::RuntimeError
+        if(dynamic_cast<const CLI::RuntimeError *>(&e) != nullptr)
+            return e.get_exit_code();
+
+        if(dynamic_cast<const CLI::CallForHelp *>(&e) != nullptr) {
+            out << help();
+            return e.get_exit_code();
+        }
+
+        if(dynamic_cast<const CLI::CallForAllHelp *>(&e) != nullptr) {
+            out << help("", AppFormatMode::All);
+            return e.get_exit_code();
+        }
+
+        if(e.get_exit_code() != static_cast<int>(ExitCodes::Success)) {
+            if(failure_message_)
+                err << failure_message_(this, e) << std::flush;
+        }
+
+        return e.get_exit_code();
+    }
+
+    ///@}
+    /// @name Post parsing
+    ///@{
+
+    /// Counts the number of times the given option was passed.
+    size_t count(std::string option_name) const {
+        for(const Option_p &opt : options_) {
+            if(opt->check_name(option_name)) {
+                return opt->count();
+            }
+        }
+        throw OptionNotFound(option_name);
+    }
+
+    /// Get a subcommand pointer list to the currently selected subcommands (after parsing by by default, in command
+    /// line order; use parsed = false to get the original definition list.)
+    std::vector<App *> get_subcommands() const { return parsed_subcommands_; }
+
+    /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
+    /// subcommands (const)
+    std::vector<const App *> get_subcommands(const std::function<bool(const App *)> &filter) const {
+        std::vector<const App *> subcomms(subcommands_.size());
+        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
+            return v.get();
+        });
+
+        if(filter) {
+            subcomms.erase(std::remove_if(std::begin(subcomms),
+                                          std::end(subcomms),
+                                          [&filter](const App *app) { return !filter(app); }),
+                           std::end(subcomms));
+        }
+
+        return subcomms;
+    }
+
+    /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
+    /// subcommands
+    std::vector<App *> get_subcommands(const std::function<bool(App *)> &filter) {
+        std::vector<App *> subcomms(subcommands_.size());
+        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
+            return v.get();
+        });
+
+        if(filter) {
+            subcomms.erase(
+                std::remove_if(std::begin(subcomms), std::end(subcomms), [&filter](App *app) { return !filter(app); }),
+                std::end(subcomms));
+        }
+
+        return subcomms;
+    }
+
+    /// Check to see if given subcommand was selected
+    bool got_subcommand(App *subcom) const {
+        // get subcom needed to verify that this was a real subcommand
+        return get_subcommand(subcom)->parsed_ > 0;
+    }
+
+    /// Check with name instead of pointer to see if subcommand was selected
+    bool got_subcommand(std::string subcommand_name) const { return get_subcommand(subcommand_name)->parsed_ > 0; }
+
+    ///@}
+    /// @name Help
+    ///@{
+
+    /// Set footer.
+    App *footer(std::string footer_string) {
+        footer_ = std::move(footer_string);
+        return this;
+    }
+
+    /// Produce a string that could be read in as a config of the current values of the App. Set default_also to
+    /// include default arguments. Prefix will add a string to the beginning of each option.
+    std::string config_to_str(bool default_also = false, bool write_description = false) const {
+        return config_formatter_->to_config(this, default_also, write_description, "");
+    }
+
+    /// Makes a help message, using the currently configured formatter
+    /// Will only do one subcommand at a time
+    std::string help(std::string prev = "", AppFormatMode mode = AppFormatMode::Normal) const {
+        if(prev.empty())
+            prev = get_name();
+        else
+            prev += " " + get_name();
+
+        // Delegate to subcommand if needed
+        auto selected_subcommands = get_subcommands();
+        if(!selected_subcommands.empty())
+            return selected_subcommands.at(0)->help(prev, mode);
+        else
+            return formatter_->make_help(this, prev, mode);
+    }
+
+    ///@}
+    /// @name Getters
+    ///@{
+
+    /// Access the formatter
+    std::shared_ptr<FormatterBase> get_formatter() const { return formatter_; }
+
+    /// Access the config formatter
+    std::shared_ptr<Config> get_config_formatter() const { return config_formatter_; }
+
+    /// Get the app or subcommand description
+    std::string get_description() const { return description_; }
+
+    /// Set the description
+    App *description(const std::string &description) {
+        description_ = description;
+        return this;
+    }
+
+    /// Get the list of options (user facing function, so returns raw pointers), has optional filter function
+    std::vector<const Option *> get_options(const std::function<bool(const Option *)> filter = {}) const {
+        std::vector<const Option *> options(options_.size());
+        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
+            return val.get();
+        });
+
+        if(filter) {
+            options.erase(std::remove_if(std::begin(options),
+                                         std::end(options),
+                                         [&filter](const Option *opt) { return !filter(opt); }),
+                          std::end(options));
+        }
+
+        return options;
+    }
+
+    /// Get an option by name
+    const Option *get_option(std::string option_name) const {
+        for(const Option_p &opt : options_) {
+            if(opt->check_name(option_name)) {
+                return opt.get();
+            }
+        }
+        throw OptionNotFound(option_name);
+    }
+
+    /// Get an option by name (non-const version)
+    Option *get_option(std::string option_name) {
+        for(Option_p &opt : options_) {
+            if(opt->check_name(option_name)) {
+                return opt.get();
+            }
+        }
+        throw OptionNotFound(option_name);
+    }
+
+    /// Check the status of ignore_case
+    bool get_ignore_case() const { return ignore_case_; }
+
+    /// Check the status of ignore_underscore
+    bool get_ignore_underscore() const { return ignore_underscore_; }
+
+    /// Check the status of fallthrough
+    bool get_fallthrough() const { return fallthrough_; }
+
+    /// Check the status of the allow windows style options
+    bool get_allow_windows_style_options() const { return allow_windows_style_options_; }
+
+    /// Get the group of this subcommand
+    const std::string &get_group() const { return group_; }
+
+    /// Get footer.
+    std::string get_footer() const { return footer_; }
+
+    /// Get the required min subcommand value
+    size_t get_require_subcommand_min() const { return require_subcommand_min_; }
+
+    /// Get the required max subcommand value
+    size_t get_require_subcommand_max() const { return require_subcommand_max_; }
+
+    /// Get the prefix command status
+    bool get_prefix_command() const { return prefix_command_; }
+
+    /// Get the status of allow extras
+    bool get_allow_extras() const { return allow_extras_; }
+
+    /// Get the status of allow extras
+    bool get_allow_config_extras() const { return allow_config_extras_; }
+
+    /// Get a pointer to the help flag.
+    Option *get_help_ptr() { return help_ptr_; }
+
+    /// Get a pointer to the help flag. (const)
+    const Option *get_help_ptr() const { return help_ptr_; }
+
+    /// Get a pointer to the help all flag. (const)
+    const Option *get_help_all_ptr() const { return help_all_ptr_; }
+
+    /// Get a pointer to the config option.
+    Option *get_config_ptr() { return config_ptr_; }
+
+    /// Get a pointer to the config option. (const)
+    const Option *get_config_ptr() const { return config_ptr_; }
+
+    /// Get the parent of this subcommand (or nullptr if master app)
+    App *get_parent() { return parent_; }
+
+    /// Get the parent of this subcommand (or nullptr if master app) (const version)
+    const App *get_parent() const { return parent_; }
+
+    /// Get the name of the current app
+    std::string get_name() const { return name_; }
+
+    /// Check the name, case insensitive and underscore insensitive if set
+    bool check_name(std::string name_to_check) const {
+        std::string local_name = name_;
+        if(ignore_underscore_) {
+            local_name = detail::remove_underscore(name_);
+            name_to_check = detail::remove_underscore(name_to_check);
+        }
+        if(ignore_case_) {
+            local_name = detail::to_lower(name_);
+            name_to_check = detail::to_lower(name_to_check);
+        }
+
+        return local_name == name_to_check;
+    }
+
+    /// Get the groups available directly from this option (in order)
+    std::vector<std::string> get_groups() const {
+        std::vector<std::string> groups;
+
+        for(const Option_p &opt : options_) {
+            // Add group if it is not already in there
+            if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
+                groups.push_back(opt->get_group());
+            }
+        }
+
+        return groups;
+    }
+
+    /// This gets a vector of pointers with the original parse order
+    const std::vector<Option *> &parse_order() const { return parse_order_; }
+
+    /// This returns the missing options from the current subcommand
+    std::vector<std::string> remaining(bool recurse = false) const {
+        std::vector<std::string> miss_list;
+        for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
+            miss_list.push_back(std::get<1>(miss));
+        }
+
+        // Recurse into subcommands
+        if(recurse) {
+            for(const App *sub : parsed_subcommands_) {
+                std::vector<std::string> output = sub->remaining(recurse);
+                std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
+            }
+        }
+        return miss_list;
+    }
+
+    /// This returns the number of remaining options, minus the -- separator
+    size_t remaining_size(bool recurse = false) const {
+        auto remaining_options = static_cast<size_t>(std::count_if(
+            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifier, std::string> &val) {
+                return val.first != detail::Classifier::POSITIONAL_MARK;
+            }));
+        if(recurse) {
+            for(const App_p &sub : subcommands_) {
+                remaining_options += sub->remaining_size(recurse);
+            }
+        }
+        return remaining_options;
+    }
+
+    ///@}
+
+  protected:
+    /// Check the options to make sure there are no conflicts.
+    ///
+    /// Currently checks to see if multiple positionals exist with -1 args
+    void _validate() const {
+        auto pcount = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
+            return opt->get_items_expected() < 0 && opt->get_positional();
+        });
+        if(pcount > 1)
+            throw InvalidError(name_);
+        for(const App_p &app : subcommands_)
+            app->_validate();
+    }
+
+    /// Internal function to run (App) callback, top down
+    void run_callback() {
+        pre_callback();
+        if(callback_)
+            callback_();
+        for(App *subc : get_subcommands()) {
+            subc->run_callback();
+        }
+    }
+
+    /// Check to see if a subcommand is valid. Give up immediately if subcommand max has been reached.
+    bool _valid_subcommand(const std::string &current) const {
+        // Don't match if max has been reached - but still check parents
+        if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
+            return parent_ != nullptr && parent_->_valid_subcommand(current);
+        }
+
+        for(const App_p &com : subcommands_)
+            if(com->check_name(current) && !*com)
+                return true;
+
+        // Check parent if exists, else return false
+        return parent_ != nullptr && parent_->_valid_subcommand(current);
+    }
+
+    /// Selects a Classifier enum based on the type of the current argument
+    detail::Classifier _recognize(const std::string &current) const {
+        std::string dummy1, dummy2;
+
+        if(current == "--")
+            return detail::Classifier::POSITIONAL_MARK;
+        if(_valid_subcommand(current))
+            return detail::Classifier::SUBCOMMAND;
+        if(detail::split_long(current, dummy1, dummy2))
+            return detail::Classifier::LONG;
+        if(detail::split_short(current, dummy1, dummy2))
+            return detail::Classifier::SHORT;
+        if((allow_windows_style_options_) && (detail::split_windows(current, dummy1, dummy2)))
+            return detail::Classifier::WINDOWS;
+        return detail::Classifier::NONE;
+    }
+
+    // The parse function is now broken into several parts, and part of process
+
+    /// Read and process an ini file (main app only)
+    void _process_ini() {
+        // Process an INI file
+        if(config_ptr_ != nullptr) {
+            if(*config_ptr_) {
+                config_ptr_->run_callback();
+                config_required_ = true;
+            }
+            if(!config_name_.empty()) {
+                try {
+                    std::vector<ConfigItem> values = config_formatter_->from_file(config_name_);
+                    _parse_config(values);
+                } catch(const FileError &) {
+                    if(config_required_)
+                        throw;
+                }
+            }
+        }
+    }
+
+    /// Get envname options if not yet passed. Runs on *all* subcommands.
+    void _process_env() {
+        for(const Option_p &opt : options_) {
+            if(opt->count() == 0 && !opt->envname_.empty()) {
+                char *buffer = nullptr;
+                std::string ename_string;
+
+#ifdef _MSC_VER
+                // Windows version
+                size_t sz = 0;
+                if(_dupenv_s(&buffer, &sz, opt->envname_.c_str()) == 0 && buffer != nullptr) {
+                    ename_string = std::string(buffer);
+                    free(buffer);
+                }
+#else
+                // This also works on Windows, but gives a warning
+                buffer = std::getenv(opt->envname_.c_str());
+                if(buffer != nullptr)
+                    ename_string = std::string(buffer);
+#endif
+
+                if(!ename_string.empty()) {
+                    opt->add_result(ename_string);
+                }
+            }
+        }
+
+        for(App_p &sub : subcommands_) {
+            sub->_process_env();
+        }
+    }
+
+    /// Process callbacks. Runs on *all* subcommands.
+    void _process_callbacks() {
+        for(const Option_p &opt : options_) {
+            if(opt->count() > 0 && !opt->get_callback_run()) {
+                opt->run_callback();
+            }
+        }
+
+        for(App_p &sub : subcommands_) {
+            sub->_process_callbacks();
+        }
+    }
+
+    /// Run help flag processing if any are found.
+    ///
+    /// The flags allow recursive calls to remember if there was a help flag on a parent.
+    void _process_help_flags(bool trigger_help = false, bool trigger_all_help = false) const {
+        const Option *help_ptr = get_help_ptr();
+        const Option *help_all_ptr = get_help_all_ptr();
+
+        if(help_ptr != nullptr && help_ptr->count() > 0)
+            trigger_help = true;
+        if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
+            trigger_all_help = true;
+
+        // If there were parsed subcommands, call those. First subcommand wins if there are multiple ones.
+        if(!parsed_subcommands_.empty()) {
+            for(const App *sub : parsed_subcommands_)
+                sub->_process_help_flags(trigger_help, trigger_all_help);
+
+            // Only the final subcommand should call for help. All help wins over help.
+        } else if(trigger_all_help) {
+            throw CallForAllHelp();
+        } else if(trigger_help) {
+            throw CallForHelp();
+        }
+    }
+
+    /// Verify required options and cross requirements. Subcommands too (only if selected).
+    void _process_requirements() {
+        for(const Option_p &opt : options_) {
+
+            // Required or partially filled
+            if(opt->get_required() || opt->count() != 0) {
+                // Make sure enough -N arguments parsed (+N is already handled in parsing function)
+                if(opt->get_items_expected() < 0 && opt->count() < static_cast<size_t>(-opt->get_items_expected()))
+                    throw ArgumentMismatch::AtLeast(opt->get_name(), -opt->get_items_expected());
+
+                // Required but empty
+                if(opt->get_required() && opt->count() == 0)
+                    throw RequiredError(opt->get_name());
+            }
+            // Requires
+            for(const Option *opt_req : opt->needs_)
+                if(opt->count() > 0 && opt_req->count() == 0)
+                    throw RequiresError(opt->get_name(), opt_req->get_name());
+            // Excludes
+            for(const Option *opt_ex : opt->excludes_)
+                if(opt->count() > 0 && opt_ex->count() != 0)
+                    throw ExcludesError(opt->get_name(), opt_ex->get_name());
+        }
+
+        auto selected_subcommands = get_subcommands();
+        if(require_subcommand_min_ > selected_subcommands.size())
+            throw RequiredError::Subcommand(require_subcommand_min_);
+
+        // Max error cannot occur, the extra subcommand will parse as an ExtrasError or a remaining item.
+
+        for(App_p &sub : subcommands_) {
+            if(sub->count() > 0)
+                sub->_process_requirements();
+        }
+    }
+
+    /// Process callbacks and such.
+    void _process() {
+        _process_ini();
+        _process_env();
+        _process_callbacks();
+        _process_help_flags();
+        _process_requirements();
+    }
+
+    /// Throw an error if anything is left over and should not be.
+    /// Modifies the args to fill in the missing items before throwing.
+    void _process_extras(std::vector<std::string> &args) {
+        if(!(allow_extras_ || prefix_command_)) {
+            size_t num_left_over = remaining_size();
+            if(num_left_over > 0) {
+                args = remaining(false);
+                throw ExtrasError(args);
+            }
+        }
+
+        for(App_p &sub : subcommands_) {
+            if(sub->count() > 0)
+                sub->_process_extras(args);
+        }
+    }
+
+    /// Internal parse function
+    void _parse(std::vector<std::string> &args) {
+        parsed_++;
+        bool positional_only = false;
+
+        while(!args.empty()) {
+            _parse_single(args, positional_only);
+        }
+
+        if(parent_ == nullptr) {
+            _process();
+
+            // Throw error if any items are left over (depending on settings)
+            _process_extras(args);
+
+            // Convert missing (pairs) to extras (string only)
+            args = remaining(false);
+        }
+    }
+
+    /// Parse one config param, return false if not found in any subcommand, remove if it is
+    ///
+    /// If this has more than one dot.separated.name, go into the subcommand matching it
+    /// Returns true if it managed to find the option, if false you'll need to remove the arg manually.
+    void _parse_config(std::vector<ConfigItem> &args) {
+        for(ConfigItem item : args) {
+            if(!_parse_single_config(item) && !allow_config_extras_)
+                throw ConfigError::Extras(item.fullname());
+        }
+    }
+
+    /// Fill in a single config option
+    bool _parse_single_config(const ConfigItem &item, size_t level = 0) {
+        if(level < item.parents.size()) {
+            App *subcom;
+            try {
+                subcom = get_subcommand(item.parents.at(level));
+            } catch(const OptionNotFound &) {
+                return false;
+            }
+            return subcom->_parse_single_config(item, level + 1);
+        }
+
+        Option *op;
+        try {
+            op = get_option("--" + item.name);
+        } catch(const OptionNotFound &) {
+            // If the option was not present
+            if(get_allow_config_extras())
+                // Should we worry about classifying the extras properly?
+                missing_.emplace_back(detail::Classifier::NONE, item.fullname());
+            return false;
+        }
+
+        if(!op->get_configurable())
+            throw ConfigError::NotConfigurable(item.fullname());
+
+        if(op->empty()) {
+            // Flag parsing
+            if(op->get_type_size() == 0) {
+                op->set_results(config_formatter_->to_flag(item));
+            } else {
+                op->set_results(item.inputs);
+                op->run_callback();
+            }
+        }
+
+        return true;
+    }
+
+    /// Parse "one" argument (some may eat more than one), delegate to parent if fails, add to missing if missing
+    /// from master
+    void _parse_single(std::vector<std::string> &args, bool &positional_only) {
+
+        detail::Classifier classifier = positional_only ? detail::Classifier::NONE : _recognize(args.back());
+        switch(classifier) {
+        case detail::Classifier::POSITIONAL_MARK:
+            missing_.emplace_back(classifier, args.back());
+            args.pop_back();
+            positional_only = true;
+            break;
+        case detail::Classifier::SUBCOMMAND:
+            _parse_subcommand(args);
+            break;
+        case detail::Classifier::LONG:
+        case detail::Classifier::SHORT:
+        case detail::Classifier::WINDOWS:
+            // If already parsed a subcommand, don't accept options_
+            _parse_arg(args, classifier);
+            break;
+        case detail::Classifier::NONE:
+            // Probably a positional or something for a parent (sub)command
+            _parse_positional(args);
+        }
+    }
+
+    /// Count the required remaining positional arguments
+    size_t _count_remaining_positionals(bool required = false) const {
+        size_t retval = 0;
+        for(const Option_p &opt : options_)
+            if(opt->get_positional() && (!required || opt->get_required()) && opt->get_items_expected() > 0 &&
+               static_cast<int>(opt->count()) < opt->get_items_expected())
+                retval = static_cast<size_t>(opt->get_items_expected()) - opt->count();
+
+        return retval;
+    }
+
+    /// Parse a positional, go up the tree to check
+    void _parse_positional(std::vector<std::string> &args) {
+
+        std::string positional = args.back();
+        for(const Option_p &opt : options_) {
+            // Eat options, one by one, until done
+            if(opt->get_positional() &&
+               (static_cast<int>(opt->count()) < opt->get_items_expected() || opt->get_items_expected() < 0)) {
+
+                opt->add_result(positional);
+                parse_order_.push_back(opt.get());
+                args.pop_back();
+                return;
+            }
+        }
+
+        if(parent_ != nullptr && fallthrough_)
+            return parent_->_parse_positional(args);
+        else {
+            args.pop_back();
+            missing_.emplace_back(detail::Classifier::NONE, positional);
+
+            if(prefix_command_) {
+                while(!args.empty()) {
+                    missing_.emplace_back(detail::Classifier::NONE, args.back());
+                    args.pop_back();
+                }
+            }
+        }
+    }
+
+    /// Parse a subcommand, modify args and continue
+    ///
+    /// Unlike the others, this one will always allow fallthrough
+    void _parse_subcommand(std::vector<std::string> &args) {
+        if(_count_remaining_positionals(/* required */ true) > 0)
+            return _parse_positional(args);
+        for(const App_p &com : subcommands_) {
+            if(com->check_name(args.back())) {
+                args.pop_back();
+                if(std::find(std::begin(parsed_subcommands_), std::end(parsed_subcommands_), com.get()) ==
+                   std::end(parsed_subcommands_))
+                    parsed_subcommands_.push_back(com.get());
+                com->_parse(args);
+                return;
+            }
+        }
+        if(parent_ != nullptr)
+            return parent_->_parse_subcommand(args);
+        else
+            throw HorribleError("Subcommand " + args.back() + " missing");
+    }
+
+    /// Parse a short (false) or long (true) argument, must be at the top of the list
+    void _parse_arg(std::vector<std::string> &args, detail::Classifier current_type) {
+
+        std::string current = args.back();
+
+        std::string arg_name;
+        std::string value;
+        std::string rest;
+
+        switch(current_type) {
+        case detail::Classifier::LONG:
+            if(!detail::split_long(current, arg_name, value))
+                throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
+            break;
+        case detail::Classifier::SHORT:
+            if(!detail::split_short(current, arg_name, rest))
+                throw HorribleError("Short parsed but missing! You should not see this");
+            break;
+        case detail::Classifier::WINDOWS:
+            if(!detail::split_windows(current, arg_name, value))
+                throw HorribleError("windows option parsed but missing! You should not see this");
+            break;
+        default:
+            throw HorribleError("parsing got called with invalid option! You should not see this");
+        }
+
+        auto op_ptr =
+            std::find_if(std::begin(options_), std::end(options_), [arg_name, current_type](const Option_p &opt) {
+                if(current_type == detail::Classifier::LONG)
+                    return opt->check_lname(arg_name);
+                if(current_type == detail::Classifier::SHORT)
+                    return opt->check_sname(arg_name);
+                // this will only get called for detail::Classifier::WINDOWS
+                return opt->check_lname(arg_name) || opt->check_sname(arg_name);
+            });
+
+        // Option not found
+        if(op_ptr == std::end(options_)) {
+            // If a subcommand, try the master command
+            if(parent_ != nullptr && fallthrough_)
+                return parent_->_parse_arg(args, current_type);
+            // Otherwise, add to missing
+            else {
+                args.pop_back();
+                missing_.emplace_back(current_type, current);
+                return;
+            }
+        }
+
+        args.pop_back();
+
+        // Get a reference to the pointer to make syntax bearable
+        Option_p &op = *op_ptr;
+
+        int num = op->get_items_expected();
+
+        // Make sure we always eat the minimum for unlimited vectors
+        int collected = 0;
+
+        // --this=value
+        if(!value.empty()) {
+            // If exact number expected
+            if(num > 0)
+                num--;
+            op->add_result(value);
+            parse_order_.push_back(op.get());
+            collected += 1;
+        } else if(num == 0) {
+            op->add_result("");
+            parse_order_.push_back(op.get());
+            // -Trest
+        } else if(!rest.empty()) {
+            if(num > 0)
+                num--;
+            op->add_result(rest);
+            parse_order_.push_back(op.get());
+            rest = "";
+            collected += 1;
+        }
+
+        // Unlimited vector parser
+        if(num < 0) {
+            while(!args.empty() && _recognize(args.back()) == detail::Classifier::NONE) {
+                if(collected >= -num) {
+                    // We could break here for allow extras, but we don't
+
+                    // If any positionals remain, don't keep eating
+                    if(_count_remaining_positionals() > 0)
+                        break;
+                }
+                op->add_result(args.back());
+                parse_order_.push_back(op.get());
+                args.pop_back();
+                collected++;
+            }
+
+            // Allow -- to end an unlimited list and "eat" it
+            if(!args.empty() && _recognize(args.back()) == detail::Classifier::POSITIONAL_MARK)
+                args.pop_back();
+
+        } else {
+            while(num > 0 && !args.empty()) {
+                num--;
+                std::string current_ = args.back();
+                args.pop_back();
+                op->add_result(current_);
+                parse_order_.push_back(op.get());
+            }
+
+            if(num > 0) {
+                throw ArgumentMismatch::TypedAtLeast(op->get_name(), num, op->get_type_name());
+            }
+        }
+
+        if(!rest.empty()) {
+            rest = "-" + rest;
+            args.push_back(rest);
+        }
+    }
+};
+
+namespace FailureMessage {
+
+/// Printout a clean, simple message on error (the default in CLI11 1.5+)
+inline std::string simple(const App *app, const Error &e) {
+    std::string header = std::string(e.what()) + "\n";
+    std::vector<std::string> names;
+
+    // Collect names
+    if(app->get_help_ptr() != nullptr)
+        names.push_back(app->get_help_ptr()->get_name());
+
+    if(app->get_help_all_ptr() != nullptr)
+        names.push_back(app->get_help_all_ptr()->get_name());
+
+    // If any names found, suggest those
+    if(!names.empty())
+        header += "Run with " + detail::join(names, " or ") + " for more information.\n";
+
+    return header;
+}
+
+/// Printout the full help string on error (if this fn is set, the old default for CLI11)
+inline std::string help(const App *app, const Error &e) {
+    std::string header = std::string("ERROR: ") + e.get_name() + ": " + e.what() + "\n";
+    header += app->help();
+    return header;
+}
+
+} // namespace FailureMessage
+
+namespace detail {
+/// This class is simply to allow tests access to App's protected functions
+struct AppFriend {
+
+    /// Wrap _parse_short, perfectly forward arguments and return
+    template <typename... Args>
+    static auto parse_arg(App *app, Args &&... args) ->
+        typename std::result_of<decltype (&App::_parse_arg)(App, Args...)>::type {
+        return app->_parse_arg(std::forward<Args>(args)...);
+    }
+
+    /// Wrap _parse_subcommand, perfectly forward arguments and return
+    template <typename... Args>
+    static auto parse_subcommand(App *app, Args &&... args) ->
+        typename std::result_of<decltype (&App::_parse_subcommand)(App, Args...)>::type {
+        return app->_parse_subcommand(std::forward<Args>(args)...);
+    }
+};
+} // namespace detail
+
+} // namespace CLI
+
+// From CLI/Config.hpp:
+
+namespace CLI {
+
+inline std::string
+ConfigINI::to_config(const App *app, bool default_also, bool write_description, std::string prefix) const {
+    std::stringstream out;
+    for(const Option *opt : app->get_options({})) {
+
+        // Only process option with a long-name and configurable
+        if(!opt->get_lnames().empty() && opt->get_configurable()) {
+            std::string name = prefix + opt->get_lnames()[0];
+            std::string value;
+
+            // Non-flags
+            if(opt->get_type_size() != 0) {
+
+                // If the option was found on command line
+                if(opt->count() > 0)
+                    value = detail::ini_join(opt->results());
+
+                // If the option has a default and is requested by optional argument
+                else if(default_also && !opt->get_defaultval().empty())
+                    value = opt->get_defaultval();
+                // Flag, one passed
+            } else if(opt->count() == 1) {
+                value = "true";
+
+                // Flag, multiple passed
+            } else if(opt->count() > 1) {
+                value = std::to_string(opt->count());
+
+                // Flag, not present
+            } else if(opt->count() == 0 && default_also) {
+                value = "false";
+            }
+
+            if(!value.empty()) {
+                if(write_description && opt->has_description()) {
+                    if(static_cast<int>(out.tellp()) != 0) {
+                        out << std::endl;
+                    }
+                    out << "; " << detail::fix_newlines("; ", opt->get_description()) << std::endl;
+                }
+
+                // Don't try to quote anything that is not size 1
+                if(opt->get_items_expected() != 1)
+                    out << name << "=" << value << std::endl;
+                else
+                    out << name << "=" << detail::add_quotes_if_needed(value) << std::endl;
+            }
+        }
+    }
+
+    for(const App *subcom : app->get_subcommands({}))
+        out << to_config(subcom, default_also, write_description, prefix + subcom->get_name() + ".");
+
+    return out.str();
+}
+
+} // namespace CLI
+
+// From CLI/Formatter.hpp:
+
+namespace CLI {
+
+inline std::string
+Formatter::make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const {
+    std::stringstream out;
+
+    out << "\n" << group << ":\n";
+    for(const Option *opt : opts) {
+        out << make_option(opt, is_positional);
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_positionals(const App *app) const {
+    std::vector<const Option *> opts =
+        app->get_options([](const Option *opt) { return !opt->get_group().empty() && opt->get_positional(); });
+
+    if(opts.empty())
+        return std::string();
+    else
+        return make_group(get_label("Positionals"), true, opts);
+}
+
+inline std::string Formatter::make_groups(const App *app, AppFormatMode mode) const {
+    std::stringstream out;
+    std::vector<std::string> groups = app->get_groups();
+
+    // Options
+    for(const std::string &group : groups) {
+        std::vector<const Option *> opts = app->get_options([app, mode, &group](const Option *opt) {
+            return opt->get_group() == group                    // Must be in the right group
+                   && opt->nonpositional()                      // Must not be a positional
+                   && (mode != AppFormatMode::Sub               // If mode is Sub, then
+                       || (app->get_help_ptr() != opt           // Ignore help pointer
+                           && app->get_help_all_ptr() != opt)); // Ignore help all pointer
+        });
+        if(!group.empty() && !opts.empty()) {
+            out << make_group(group, false, opts);
+
+            if(group != groups.back())
+                out << "\n";
+        }
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_description(const App *app) const {
+    std::string desc = app->get_description();
+
+    if(!desc.empty())
+        return desc + "\n";
+    else
+        return "";
+}
+
+inline std::string Formatter::make_usage(const App *app, std::string name) const {
+    std::stringstream out;
+
+    out << get_label("Usage") << ":" << (name.empty() ? "" : " ") << name;
+
+    std::vector<std::string> groups = app->get_groups();
+
+    // Print an Options badge if any options exist
+    std::vector<const Option *> non_pos_options =
+        app->get_options([](const Option *opt) { return opt->nonpositional(); });
+    if(!non_pos_options.empty())
+        out << " [" << get_label("OPTIONS") << "]";
+
+    // Positionals need to be listed here
+    std::vector<const Option *> positionals = app->get_options([](const Option *opt) { return opt->get_positional(); });
+
+    // Print out positionals if any are left
+    if(!positionals.empty()) {
+        // Convert to help names
+        std::vector<std::string> positional_names(positionals.size());
+        std::transform(positionals.begin(), positionals.end(), positional_names.begin(), [this](const Option *opt) {
+            return make_option_usage(opt);
+        });
+
+        out << " " << detail::join(positional_names, " ");
+    }
+
+    // Add a marker if subcommands are expected or optional
+    if(!app->get_subcommands({}).empty()) {
+        out << " " << (app->get_require_subcommand_min() == 0 ? "[" : "")
+            << get_label(app->get_require_subcommand_max() < 2 || app->get_require_subcommand_min() > 1 ? "SUBCOMMAND"
+                                                                                                        : "SUBCOMMANDS")
+            << (app->get_require_subcommand_min() == 0 ? "]" : "");
+    }
+
+    out << std::endl;
+
+    return out.str();
+}
+
+inline std::string Formatter::make_footer(const App *app) const {
+    std::string footer = app->get_footer();
+    if(!footer.empty())
+        return footer + "\n";
+    else
+        return "";
+}
+
+inline std::string Formatter::make_help(const App *app, std::string name, AppFormatMode mode) const {
+
+    // This immediately forwards to the make_expanded method. This is done this way so that subcommands can
+    // have overridden formatters
+    if(mode == AppFormatMode::Sub)
+        return make_expanded(app);
+
+    std::stringstream out;
+
+    out << make_description(app);
+    out << make_usage(app, name);
+    out << make_positionals(app);
+    out << make_groups(app, mode);
+    out << make_subcommands(app, mode);
+    out << make_footer(app);
+
+    return out.str();
+}
+
+inline std::string Formatter::make_subcommands(const App *app, AppFormatMode mode) const {
+    std::stringstream out;
+
+    std::vector<const App *> subcommands = app->get_subcommands({});
+
+    // Make a list in definition order of the groups seen
+    std::vector<std::string> subcmd_groups_seen;
+    for(const App *com : subcommands) {
+        std::string group_key = com->get_group();
+        if(!group_key.empty() &&
+           std::find_if(subcmd_groups_seen.begin(), subcmd_groups_seen.end(), [&group_key](std::string a) {
+               return detail::to_lower(a) == detail::to_lower(group_key);
+           }) == subcmd_groups_seen.end())
+            subcmd_groups_seen.push_back(group_key);
+    }
+
+    // For each group, filter out and print subcommands
+    for(const std::string &group : subcmd_groups_seen) {
+        out << "\n" << group << ":\n";
+        std::vector<const App *> subcommands_group = app->get_subcommands(
+            [&group](const App *sub_app) { return detail::to_lower(sub_app->get_group()) == detail::to_lower(group); });
+        for(const App *new_com : subcommands_group) {
+            if(mode != AppFormatMode::All) {
+                out << make_subcommand(new_com);
+            } else {
+                out << new_com->help(new_com->get_name(), AppFormatMode::Sub);
+                out << "\n";
+            }
+        }
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_subcommand(const App *sub) const {
+    std::stringstream out;
+    detail::format_help(out, sub->get_name(), sub->get_description(), column_width_);
+    return out.str();
+}
+
+inline std::string Formatter::make_expanded(const App *sub) const {
+    std::stringstream out;
+    out << sub->get_name() << "\n";
+
+    out << make_description(sub);
+    out << make_positionals(sub);
+    out << make_groups(sub, AppFormatMode::Sub);
+    out << make_subcommands(sub, AppFormatMode::Sub);
+
+    // Drop blank spaces
+    std::string tmp = detail::find_and_replace(out.str(), "\n\n", "\n");
+    tmp = tmp.substr(0, tmp.size() - 1); // Remove the final '\n'
+
+    // Indent all but the first line (the name)
+    return detail::find_and_replace(tmp, "\n", "\n  ") + "\n";
+}
+
+inline std::string Formatter::make_option_name(const Option *opt, bool is_positional) const {
+    if(is_positional)
+        return opt->get_name(true, false);
+    else
+        return opt->get_name(false, true);
+}
+
+inline std::string Formatter::make_option_opts(const Option *opt) const {
+    std::stringstream out;
+
+    if(opt->get_type_size() != 0) {
+        if(!opt->get_type_name().empty())
+            out << " " << get_label(opt->get_type_name());
+        if(!opt->get_defaultval().empty())
+            out << "=" << opt->get_defaultval();
+        if(opt->get_expected() > 1)
+            out << " x " << opt->get_expected();
+        if(opt->get_expected() == -1)
+            out << " ...";
+        if(opt->get_required())
+            out << " " << get_label("REQUIRED");
+    }
+    if(!opt->get_envname().empty())
+        out << " (" << get_label("Env") << ":" << opt->get_envname() << ")";
+    if(!opt->get_needs().empty()) {
+        out << " " << get_label("Needs") << ":";
+        for(const Option *op : opt->get_needs())
+            out << " " << op->get_name();
+    }
+    if(!opt->get_excludes().empty()) {
+        out << " " << get_label("Excludes") << ":";
+        for(const Option *op : opt->get_excludes())
+            out << " " << op->get_name();
+    }
+    return out.str();
+}
+
+inline std::string Formatter::make_option_desc(const Option *opt) const { return opt->get_description(); }
+
+inline std::string Formatter::make_option_usage(const Option *opt) const {
+    // Note that these are positionals usages
+    std::stringstream out;
+    out << make_option_name(opt, true);
+
+    if(opt->get_expected() > 1)
+        out << "(" << std::to_string(opt->get_expected()) << "x)";
+    else if(opt->get_expected() < 0)
+        out << "...";
+
+    return opt->get_required() ? out.str() : "[" + out.str() + "]";
+}
+
+} // namespace CLI
+cmake_minimum_required(VERSION 3.11)
+
+project(CLI11_Examples LANGUAGES CXX)
+
+# Using CMake 3.11's ability to set imported interface targets
+add_library(CLI11::CLI11 IMPORTED INTERFACE)
+target_include_directories(CLI11::CLI11 INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")
+target_compile_features(CLI11::CLI11 INTERFACE cxx_std_11)
+
+# Add CTest
+enable_testing()
+
+# Quick function to add the base executable
+function(add_cli_exe NAME)
+    add_executable(${NAME} ${NAME}.cpp)
+    target_link_libraries(${NAME} CLI11::CLI11)
+endfunction()
+
+
+add_cli_exe(simplest)
+add_test(NAME simplest COMMAND simplest)
+
+
+add_cli_exe(intro)
+add_test(NAME intro COMMAND intro)
+add_test(NAME intro_p COMMAND intro -p 5)
+
+
+add_cli_exe(flags)
+add_test(NAME flags COMMAND flags)
+add_test(NAME flags_bip COMMAND flags -b -i -p)
+
+
+add_cli_exe(geet)
+add_test(NAME geet_add    COMMAND geet add)
+add_test(NAME geet_commit COMMAND geet commit -m "Test")
+
+
+#include "CLI11.hpp"
+#include <iostream>
+
+int main(int argc, char **argv) {
+    using std::cout;
+    using std::endl;
+    CLI::App app{"Flag example program"};
+
+    /// [define]
+    bool flag_bool;
+    app.add_flag("--bool,-b", flag_bool, "This is a bool flag");
+
+    int flag_int;
+    app.add_flag("-i,--int", flag_int, "This is an int flag");
+
+    CLI::Option *flag_plain = app.add_flag("--plain,-p", "This is a plain flag");
+    /// [define]
+
+    /// [parser]
+    try {
+        app.parse(argc, argv);
+    } catch(const CLI::ParseError &e) {
+        return app.exit(e);
+    }
+    /// [parser]
+
+    /// [usage]
+    cout << "The flags program" << endl;
+    if(flag_bool)
+        cout << "Bool flag passed" << endl;
+    if(flag_int > 0)
+        cout << "Flag int: " << flag_int << endl;
+    if(*flag_plain)
+        cout << "Flag plain: " << flag_plain->count() << endl;
+    /// [usage]
+}
+#include "CLI11.hpp"
+
+#include <iostream>
+
+int main(int argc, char **argv) {
+
+    /// [Intro]
+    CLI::App app{"Geet, a command line git lookalike that does nothing"};
+    app.require_subcommand(1);
+    /// [Intro]
+
+    /// [Add]
+    auto add = app.add_subcommand("add", "Add file(s)");
+
+    bool add_update;
+    add->add_flag("-u,--update", add_update, "Add updated files only");
+
+    std::vector<std::string> add_files;
+    add->add_option("files", add_files, "Files to add");
+
+    add->callback([&]() {
+        std::cout << "Adding:";
+        if(add_files.empty()) {
+            if(add_update)
+                std::cout << " all updated files";
+            else
+                std::cout << " all files";
+        } else {
+            for(auto file : add_files)
+                std::cout << " " << file;
+        }
+    });
+    /// [Add]
+
+    /// [Commit]
+    auto commit = app.add_subcommand("commit", "Commit files");
+
+    std::string commit_message;
+    commit->add_option("-m,--message", commit_message, "A message")->required();
+
+    commit->callback([&]() { std::cout << "Commit message: " << commit_message; });
+    /// [Commit]
+
+    /// [Parse]
+    CLI11_PARSE(app, argc, argv);
+
+    std::cout << "\nThanks for using geet!\n" << std::endl;
+    return 0;
+    /// [Parse]
+}
+#include "CLI11.hpp"
+#include <iostream>
+
+int main(int argc, char **argv) {
+    CLI::App app{"App description"};
+
+    // Define options
+    int p = 0;
+    app.add_option("-p", p, "Parameter");
+
+    CLI11_PARSE(app, argc, argv);
+
+    std::cout << "Parameter value: " << p << std::endl;
+    return 0;
+}
+#include "CLI11.hpp"
+
+int main(int argc, char **argv) {
+    CLI::App app;
+
+    // Add new options/flags here
+
+    CLI11_PARSE(app, argc, argv);
+
+    return 0;
+}
 # Introduction
  
-This is the Doxygen API documentation for CLI11 parser. There is a friendly introduction to CLI11 on the [Github page](https://github.com/CLIUtils/CLI11).
+This is the Doxygen API documentation for CLI11 parser. There is a friendly introduction to CLI11 on the [Github page](https://github.com/CLIUtils/CLI11), and [a tutorial series](https://cliutils.github.io/CLI11/book).
  
 The main classes are: