From 4b43a7d3f055a18958b14062e591fdd62bd8a449 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Sat, 31 Jul 2021 09:00:24 -0700
Subject: [PATCH 01/11] Add some missing modifiers on the options to the docs
 and clarify some of them.

---
 README.md                | 11 +++++++----
 book/chapters/options.md | 10 +++++++---
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 3fb84f7e8..24c7a8592 100644
--- a/README.md
+++ b/README.md
@@ -336,10 +336,12 @@ Before parsing, you can set the following options:
 
 * `->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. If negative, require at least `-N`; end with `--` or another recognized option or subcommand.
+* `->expected(MIN,MAX)`: Set a range of expected values to accompany an option.  `expected(0,1)` is the equivalent of making a flag.  
 * `->type_name(typename)`: Set the name of an Option's type (`type_name_fn` allows a function instead)
-* `->type_size(N)`: Set the intrinsic size of an option. The parser will require multiples of this number if negative.
-* `->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.
+* `->type_size(N)`: Set the intrinsic size of an option value. The parser will require multiples of this number if negative. Most of the time this is detected automatically though can be modified for specific use cases.  
+* `->type_size(MIN,MAX)`: Set the intrinsic size of an option to a range.
+* `->needs(opt)`: This option requires another option to also be present, opt is an `Option` pointer. Options can be removed from the `needs` with `remove_needs(opt)`. The option can also be specified with a string containing the name of the option
+* `->excludes(opt)`: This option cannot be given with `opt` present, opt is an `Option` pointer.  Can also be given as a string containing the name of the option.  Options can be removed from the excludes list with `->remove_excludes(opt)`
 * `->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"`. `""` will not show up in the help print (hidden).
 * `->ignore_case()`: Ignore the case on the command line (also works on subcommands, does not affect arguments).
@@ -348,7 +350,7 @@ Before parsing, you can set the following options:
 * `->allow_extra_args(true/false)`: 🆕 If set to true the option will take an unlimited number of arguments like a vector, if false it will limit the number of arguments to the size of the type used in the option.  Default value depends on the nature of the type use, containers default to true, others default to false.
 * `->delimiter(char)`: Allows specification of a custom delimiter for separating single arguments into vector arguments, for example specifying `->delimiter(',')` on an option would result in `--opt=1,2,3` producing 3 elements of a vector and the equivalent of --opt 1 2 3 assuming opt is a vector value.
 * `->description(str)`: Set/change the description.
-* `->multi_option_policy(CLI::MultiOptionPolicy::Throw)`: Set the multi-option policy. Shortcuts available: `->take_last()`, `->take_first()`,`->take_all()`, and `->join()`. This will only affect options expecting 1 argument or bool flags (which do not inherit their default but always start with a specific policy).
+* `->multi_option_policy(CLI::MultiOptionPolicy::Throw)`: Set the multi-option policy. Shortcuts available: `->take_last()`, `->take_first()`,`->take_all()`, and `->join()`. This will only affect options expecting 1 argument or bool flags (which do not inherit their default but always start with a specific policy). `->join(delim)` can also be used to join with a specific delimiter. This equivalent to calling `->delimiter(delim)` and `->join()`
 * `->check(std::string(const std::string &), validator_name="",validator_description="")`: Define a check function.  The function should return a non empty string with the error message if the check fails
 * `->check(Validator)`: Use a Validator object to do the check see [Validators](#validators) for a description of available Validators and how to create new ones.
 * `->transform(std::string(std::string &), validator_name="",validator_description=")`: Converts the input string into the output string, in-place in the parsed options.
@@ -360,6 +362,7 @@ Before parsing, you can set the following options:
 * `->always_capture_default()`: Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`.
 * `->default_str(string)`:  Set the default string directly.  This string will also be used as a default value if no arguments are passed and the value is requested.
 * `->default_val(value)`: Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator).
+* `->run_callback_for_default()`: This will force the option callback to be executed or the variable set regardless of whether the option was passed or not. Can be used to force an output variable to be set to the default_str.  
 * `->option_text(string)`: Sets the text between the option name and description.
 
 These options return the `Option` pointer, so you can chain them together, and even skip storing the pointer entirely. The `each` function takes any function that has the signature `void(const std::string&)`; it should throw a `ValidationError` when validation fails. The help message will have the name of the parent option prepended. Since `each`, `check` and `transform` use the same underlying mechanism, you can chain as many as you want, and they will be executed in order. Operations added through `transform` are executed first in reverse order of addition, and `check` and `each` are run following the transform functions in order of addition. If you just want to see the unconverted values, use `.results()` to get the `std::vector<std::string>` of results.
diff --git a/book/chapters/options.md b/book/chapters/options.md
index 60a1a4679..424cc6470 100644
--- a/book/chapters/options.md
+++ b/book/chapters/options.md
@@ -129,8 +129,8 @@ When you call `add_option`, you get a pointer to the added option. You can use t
 | `->expected(Nmin,Nmax)` | Take between `Nmin` and `Nmax` values. |
 | `->type_size(N)` | specify that each block of values would consist of N elements |
 | `->type_size(Nmin,Nmax)` | specify that each block of values would consist of between Nmin and Nmax elements |
-| `->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. |
+| `->needs(opt)` | This option requires another option to also be present, opt is an `Option` pointer or a string with the name of the option.  Can be removed with `->remove_needs(opt)` |
+| `->excludes(opt)` | This option cannot be given with `opt` present, opt is an `Option` pointer or a string with the name of the option.  Can be removed with `->remove_excludes(opt)` |
 | `->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. |
 | `->description(string)` | Set/change the description |
@@ -149,8 +149,12 @@ When you call `add_option`, you get a pointer to the added option. You can use t
 | `->transform(Validator)` | Run a transforming validator on each value passed. See [Validators](./validators.md) for more info |
 | `->each(void(std::string))` | Run a function on each parsed value, *in order*. |
 | `->default_str(string)` | set a default string for use in the help and as a default value if no arguments are passed and a value is requested |
-| `->default_function(string())` | Advanced: Change the function that `capture_default_str()` uses. |
+| `->default_function(std::string())` | Advanced: Change the function that `capture_default_str()` uses. |
 | `->default_val(value)` | Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator). |
+| `->capture_default_str()` | Store the current value attached and display it in the help string. |
+| `->always_capture_default()` | Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`. |
+| `->run_callback_for_default()` | Force the option callback to be executed or the variable set regardless of whether the option was passed or not. Can be used to force an output variable to be set to the default_str.  |
+| `->option_text(string)` | Sets the text between the option name and description. |
 
 The `->check(...)` and `->transform(...)` modifiers can also take 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.
 

From cd92b5a8067285a359cd239b933a8f81f06e4887 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sun, 1 Aug 2021 15:06:10 +0000
Subject: [PATCH 02/11] style: pre-commit.ci fixes

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 24c7a8592..9ed940085 100644
--- a/README.md
+++ b/README.md
@@ -336,9 +336,9 @@ Before parsing, you can set the following options:
 
 * `->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. If negative, require at least `-N`; end with `--` or another recognized option or subcommand.
-* `->expected(MIN,MAX)`: Set a range of expected values to accompany an option.  `expected(0,1)` is the equivalent of making a flag.  
+* `->expected(MIN,MAX)`: Set a range of expected values to accompany an option.  `expected(0,1)` is the equivalent of making a flag.
 * `->type_name(typename)`: Set the name of an Option's type (`type_name_fn` allows a function instead)
-* `->type_size(N)`: Set the intrinsic size of an option value. The parser will require multiples of this number if negative. Most of the time this is detected automatically though can be modified for specific use cases.  
+* `->type_size(N)`: Set the intrinsic size of an option value. The parser will require multiples of this number if negative. Most of the time this is detected automatically though can be modified for specific use cases.
 * `->type_size(MIN,MAX)`: Set the intrinsic size of an option to a range.
 * `->needs(opt)`: This option requires another option to also be present, opt is an `Option` pointer. Options can be removed from the `needs` with `remove_needs(opt)`. The option can also be specified with a string containing the name of the option
 * `->excludes(opt)`: This option cannot be given with `opt` present, opt is an `Option` pointer.  Can also be given as a string containing the name of the option.  Options can be removed from the excludes list with `->remove_excludes(opt)`
@@ -362,7 +362,7 @@ Before parsing, you can set the following options:
 * `->always_capture_default()`: Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`.
 * `->default_str(string)`:  Set the default string directly.  This string will also be used as a default value if no arguments are passed and the value is requested.
 * `->default_val(value)`: Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator).
-* `->run_callback_for_default()`: This will force the option callback to be executed or the variable set regardless of whether the option was passed or not. Can be used to force an output variable to be set to the default_str.  
+* `->run_callback_for_default()`: This will force the option callback to be executed or the variable set regardless of whether the option was passed or not. Can be used to force an output variable to be set to the default_str.
 * `->option_text(string)`: Sets the text between the option name and description.
 
 These options return the `Option` pointer, so you can chain them together, and even skip storing the pointer entirely. The `each` function takes any function that has the signature `void(const std::string&)`; it should throw a `ValidationError` when validation fails. The help message will have the name of the parent option prepended. Since `each`, `check` and `transform` use the same underlying mechanism, you can chain as many as you want, and they will be executed in order. Operations added through `transform` are executed first in reverse order of addition, and `check` and `each` are run following the transform functions in order of addition. If you just want to see the unconverted values, use `.results()` to get the `std::vector<std::string>` of results.

From 1c27ee8fdfeebbe9ef8495aa9fc09409ed609e96 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Mon, 2 Aug 2021 07:20:53 -0700
Subject: [PATCH 03/11] add a more clear force callback and callback on parse
 modifier for options.

---
 include/CLI/Option.hpp | 37 ++++++++++++++++++++++++++++++++-----
 tests/AppTest.cpp      | 29 +++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+), 5 deletions(-)

diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index 11ae2c05a..cdbda3743 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -337,6 +337,10 @@ class Option : public OptionBase<Option> {
     bool run_callback_for_default_{false};
     /// flag indicating a separator needs to be injected after each argument call
     bool inject_separator_{false};
+    /// flag indicating tha the option should trigger the callback on each result when loaded
+    bool trigger_on_result_{false};
+    /// flag indicating tha the option should force the callback regardless if any results present
+    bool force_callback_{false};
     ///@}
 
     /// Making an option by hand is not defined, it must be made by the App class
@@ -358,8 +362,8 @@ class Option : public OptionBase<Option> {
     /// True if the option was not passed
     bool empty() const { return results_.empty(); }
 
-    /// This class is true if option is passed.
-    explicit operator bool() const { return !empty(); }
+    /// This bool operator returns true if any arguments were passed or the option callback is forced
+    explicit operator bool() const { return !empty() || force_callback_; }
 
     /// Clear the parsed results (mostly for testing)
     void clear() {
@@ -420,6 +424,21 @@ class Option : public OptionBase<Option> {
     }
     /// Get the current value of allow extra args
     bool get_allow_extra_args() const { return allow_extra_args_; }
+    /// Set the value of trigger_on_parse which specifies that the option callback should be triggered on every parse
+    Option *trigger_on_parse(bool value = true) {
+        trigger_on_result_ = value;
+        return this;
+    }
+    /// The status of trigger on parse
+    bool get_trigger_on_parse() const { return trigger_on_result_; }
+
+    /// Set the value of force_callback
+    Option *force_callback(bool value = true) {
+        force_callback_ = value;
+        return this;
+    }
+    /// The status of force_callback
+    bool get_force_callback() const { return force_callback_; }
 
     /// Set the value of run_callback_for_default which controls whether the callback function should be called to set
     /// the default This is controlled automatically but could be manipulated by the user.
@@ -818,7 +837,9 @@ class Option : public OptionBase<Option> {
 
     /// Process the callback
     void run_callback() {
-
+        if(force_callback_ && results_.empty()) {
+            add_result(default_str_);
+        }
         if(current_option_state_ == option_state::parsing) {
             _validate_results(results_);
             current_option_state_ = option_state::validated;
@@ -960,8 +981,11 @@ class Option : public OptionBase<Option> {
 
     /// Puts a result at the end
     Option *add_result(std::string s) {
-        _add_result(std::move(s), results_);
+        auto results_added = _add_result(std::move(s), results_);
         current_option_state_ = option_state::parsing;
+        if(trigger_on_result_ && results_added > 0) {
+            run_callback();
+        }
         return this;
     }
 
@@ -969,6 +993,9 @@ class Option : public OptionBase<Option> {
     Option *add_result(std::string s, int &results_added) {
         results_added = _add_result(std::move(s), results_);
         current_option_state_ = option_state::parsing;
+        if(trigger_on_result_ && results_added > 0) {
+            run_callback();
+        }
         return this;
     }
 
@@ -1136,7 +1163,7 @@ class Option : public OptionBase<Option> {
         results_.clear();
         try {
             add_result(val_str);
-            if(run_callback_for_default_) {
+            if(run_callback_for_default_ && !trigger_on_result_) {
                 run_callback();  // run callback sets the state we need to reset it again
                 current_option_state_ = option_state::parsing;
             } else {
diff --git a/tests/AppTest.cpp b/tests/AppTest.cpp
index d779c6de6..8a3544f07 100644
--- a/tests/AppTest.cpp
+++ b/tests/AppTest.cpp
@@ -2254,3 +2254,32 @@ TEST_CASE_METHOD(TApp, "CustomUserSepParse5", "[app]") {
     run();
     CHECK(std::vector<std::string>({"this", "is", "a", "test"}) == bar);
 }
+
+// #218
+TEST_CASE_METHOD(TApp, "logFormSingleDash", "[app]") {
+    bool verbose{false};
+    bool veryverbose{false};
+    bool veryveryverbose{false};
+    app.name("testargs");
+    app.allow_extras();
+    args = {"-v", "-vv", "-vvv"};
+    app.final_callback([&]() {
+        auto rem = app.remaining();
+        for(auto &arg : rem) {
+            if(arg == "-v") {
+                verbose = true;
+            }
+            if(arg == "-vv") {
+                veryverbose = true;
+            }
+            if(arg == "-vvv") {
+                veryveryverbose = true;
+            }
+        }
+    });
+    run();
+    CHECK(app.remaining().size()==3U);
+    CHECK(verbose);
+    CHECK(veryverbose);
+    CHECK(veryveryverbose);
+}

From 07f2707c1eace4e1e83d8d8945018430d51a51be Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Wed, 4 Aug 2021 14:04:40 -0700
Subject: [PATCH 04/11] update the book with new modifiers

---
 book/chapters/options.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/book/chapters/options.md b/book/chapters/options.md
index 424cc6470..9c24d661a 100644
--- a/book/chapters/options.md
+++ b/book/chapters/options.md
@@ -26,7 +26,7 @@ You can use any C++ int-like type, not just `int`. CLI11 understands the followi
 | complex-number | std::complex or any type which has a real(), and imag() operations available, will allow 1 or 2 string definitions like "1+2j" or two arguments "1","2" |
 | enumeration | any enum or enum class type is supported through conversion from the underlying type(typically int, though it can be specified otherwise) |
 | container-like | a container(like vector) of any available types including other containers |
-| wrapper | any other object with a `value_type` static definition where the type specified by `value_type` is one of type in this list |
+| wrapper | any other object with a `value_type` static definition where the type specified by `value_type` is one of the types in this list |
 | tuple | a tuple, pair, or array, or other type with a tuple size and tuple_type operations defined and the members being a type contained in this list |
 | 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. (`{}`) |
 | streamable | any other type with a `<<` operator will also work |
@@ -153,7 +153,9 @@ When you call `add_option`, you get a pointer to the added option. You can use t
 | `->default_val(value)` | Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator). |
 | `->capture_default_str()` | Store the current value attached and display it in the help string. |
 | `->always_capture_default()` | Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`. |
-| `->run_callback_for_default()` | Force the option callback to be executed or the variable set regardless of whether the option was passed or not. Can be used to force an output variable to be set to the default_str.  |
+| `->run_callback_for_default()` | Force the option callback to be executed or the variable set when the `default_val` is used.  |
+| `->force_callback()` | Force the option callback to be executed regardless of whether the option was used or not.  Will use the default_str if available. |
+|`->trigger_on_parse()` | Have the option callback be triggered when the value is parsed vs. at the end of all parsing the callback can potentially be executed multiple times.|
 | `->option_text(string)` | Sets the text between the option name and description. |
 
 The `->check(...)` and `->transform(...)` modifiers can also take 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.

From 8a6d824feb042e75ce150f320cdc46a31797db29 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Thu, 5 Aug 2021 07:05:49 -0700
Subject: [PATCH 05/11] update documentation and add tests

---
 README.md                |  8 +++--
 book/chapters/options.md |  4 +--
 include/CLI/App.hpp      |  2 +-
 include/CLI/Option.hpp   |  5 +--
 tests/OptionTypeTest.cpp | 67 ++++++++++++++++++++++++++++++++++++++--
 5 files changed, 76 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 9ed940085..d880b9b97 100644
--- a/README.md
+++ b/README.md
@@ -360,10 +360,12 @@ Before parsing, you can set the following options:
 * `->capture_default_str()`: Store the current value attached and display it in the help string.
 * `->default_function(std::string())`: Advanced: Change the function that `capture_default_str()` uses.
 * `->always_capture_default()`: Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`.
-* `->default_str(string)`:  Set the default string directly.  This string will also be used as a default value if no arguments are passed and the value is requested.
-* `->default_val(value)`: Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator).
-* `->run_callback_for_default()`: This will force the option callback to be executed or the variable set regardless of whether the option was passed or not. Can be used to force an output variable to be set to the default_str.
+* `->default_str(string)`:  Set the default string directly (NO VALIDATION OR CALLBACKS).  This string will also be used as a default value if no arguments are passed and the value is requested.
+* `->default_val(value)`: Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator). The callback may be triggered if the `run_callback_for_default` is set.
+* `->run_callback_for_default()`: This will force the option callback to be executed or the variable set when the default_val is set.
 * `->option_text(string)`: Sets the text between the option name and description.
+* `->force_callback()`:  Causes the option callback or value set to be triggered even if the option was not present in parsing.
+* `->trigger_on_parse()`:  if set, causes the callback and all associated validation checks for the option to be executed when the option value is parsed vs. at the end of all parsing. This could cause the callback to be executed multiple times.   
 
 These options return the `Option` pointer, so you can chain them together, and even skip storing the pointer entirely. The `each` function takes any function that has the signature `void(const std::string&)`; it should throw a `ValidationError` when validation fails. The help message will have the name of the parent option prepended. Since `each`, `check` and `transform` use the same underlying mechanism, you can chain as many as you want, and they will be executed in order. Operations added through `transform` are executed first in reverse order of addition, and `check` and `each` are run following the transform functions in order of addition. If you just want to see the unconverted values, use `.results()` to get the `std::vector<std::string>` of results.
 
diff --git a/book/chapters/options.md b/book/chapters/options.md
index 9c24d661a..6d60e7afc 100644
--- a/book/chapters/options.md
+++ b/book/chapters/options.md
@@ -154,8 +154,8 @@ When you call `add_option`, you get a pointer to the added option. You can use t
 | `->capture_default_str()` | Store the current value attached and display it in the help string. |
 | `->always_capture_default()` | Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`. |
 | `->run_callback_for_default()` | Force the option callback to be executed or the variable set when the `default_val` is used.  |
-| `->force_callback()` | Force the option callback to be executed regardless of whether the option was used or not.  Will use the default_str if available. |
-|`->trigger_on_parse()` | Have the option callback be triggered when the value is parsed vs. at the end of all parsing the callback can potentially be executed multiple times.|
+| `->force_callback()` | Force the option callback to be executed regardless of whether the option was used or not.  Will use the default_str if available, if no default is given the callback will be executed with an empty string as an argument, which will translate to a default initialized value, which can be compiler dependent |
+|`->trigger_on_parse()` | Have the option callback be triggered when the value is parsed vs. at the end of all parsing, the option callback can potentially be executed multiple times.  Generally only useful if you have a user defined callback or validation check|
 | `->option_text(string)` | Sets the text between the option name and description. |
 
 The `->check(...)` and `->transform(...)` modifiers can also take 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.
diff --git a/include/CLI/App.hpp b/include/CLI/App.hpp
index b445e49d4..a8116f69a 100644
--- a/include/CLI/App.hpp
+++ b/include/CLI/App.hpp
@@ -2083,7 +2083,7 @@ class App {
         }
 
         for(const Option_p &opt : options_) {
-            if(opt->count() > 0 && !opt->get_callback_run()) {
+            if((*opt) && !opt->get_callback_run()) {
                 opt->run_callback();
             }
         }
diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index cdbda3743..5b0fa9b82 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -685,7 +685,7 @@ class Option : public OptionBase<Option> {
     /// The maximum number of arguments the option expects
     int get_type_size_max() const { return type_size_max_; }
 
-    /// The number of arguments the option expects
+    /// return the inject_separator flag
     int get_inject_separator() const { return inject_separator_; }
 
     /// The environment variable associated to this value
@@ -1001,10 +1001,10 @@ class Option : public OptionBase<Option> {
 
     /// Puts a result at the end
     Option *add_result(std::vector<std::string> s) {
+        current_option_state_ = option_state::parsing;
         for(auto &str : s) {
             _add_result(std::move(str), results_);
         }
-        current_option_state_ = option_state::parsing;
         return this;
     }
 
@@ -1163,6 +1163,7 @@ class Option : public OptionBase<Option> {
         results_.clear();
         try {
             add_result(val_str);
+            // if trigger_on_result_ is set the callback already ran
             if(run_callback_for_default_ && !trigger_on_result_) {
                 run_callback();  // run callback sets the state we need to reset it again
                 current_option_state_ = option_state::parsing;
diff --git a/tests/OptionTypeTest.cpp b/tests/OptionTypeTest.cpp
index 296334e3f..d004ccbf0 100644
--- a/tests/OptionTypeTest.cpp
+++ b/tests/OptionTypeTest.cpp
@@ -320,8 +320,6 @@ TEST_CASE_METHOD(TApp, "pair_check", "[optiontype]") {
     CHECK_THROWS_AS(run(), CLI::ValidationError);
 }
 
-// this will require that modifying the multi-option policy for tuples be allowed which it isn't at present
-
 TEST_CASE_METHOD(TApp, "pair_check_take_first", "[optiontype]") {
     std::string myfile{"pair_check_file2.txt"};
     bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a'));  // create file
@@ -915,3 +913,68 @@ TEST_CASE_METHOD(TApp, "vectorDoubleArg", "[optiontype]") {
     CHECK(2U == cv.size());
     CHECK(2U == extras.size());
 }
+
+
+TEST_CASE_METHOD(TApp, "OnParseCall", "[optiontype]") {
+
+    int cnt{0};
+
+    auto *opt = app.add_option("-c",
+                               [&cnt](const CLI::results_t &) {
+                                   ++cnt;
+                                   return true;
+                               })
+                    ->expected(1,20)
+                    ->trigger_on_parse();
+    std::vector<std::string> extras;
+    app.add_option("args", extras);
+    args = {"-c", "1", "-c", "2", "-c", "3"};
+    CHECK(opt->get_trigger_on_parse());
+    run();
+    CHECK(3 == cnt);
+}
+
+TEST_CASE_METHOD(TApp, "force_callback", "[optiontype]") {
+
+    int cnt{0};
+
+    auto *opt = app.add_option("-c",
+                               [&cnt](const CLI::results_t &) {
+                                   ++cnt;
+                                   return true;
+                               })
+                    ->expected(1, 20)
+                    ->force_callback()
+                    ->default_str("5");
+    std::vector<std::string> extras;
+    app.add_option("args", extras);
+    args = {};
+    CHECK(opt->get_force_callback());
+    run();
+    CHECK(1 == cnt);
+    cnt = 0;
+    args = {"-c", "10"};
+    run();
+    CHECK(1 == cnt);
+}
+
+TEST_CASE_METHOD(TApp, "force_callback2", "[optiontype]") {
+
+    int cnt{0};
+
+    app.add_option("-c", cnt)->force_callback()->default_val(5);
+    args = {};
+    run();
+    CHECK(5 == cnt);
+}
+
+
+TEST_CASE_METHOD(TApp, "force_callback3", "[optiontype]") {
+
+    int cnt{10};
+
+    app.add_option("-c", cnt)->force_callback();
+    args = {};
+    run();
+    CHECK(0 == cnt);
+}

From 5b1538eb9f62e99340ecae3c562317de464439c4 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 5 Aug 2021 14:06:14 +0000
Subject: [PATCH 06/11] style: pre-commit.ci fixes

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d880b9b97..267b21e64 100644
--- a/README.md
+++ b/README.md
@@ -365,7 +365,7 @@ Before parsing, you can set the following options:
 * `->run_callback_for_default()`: This will force the option callback to be executed or the variable set when the default_val is set.
 * `->option_text(string)`: Sets the text between the option name and description.
 * `->force_callback()`:  Causes the option callback or value set to be triggered even if the option was not present in parsing.
-* `->trigger_on_parse()`:  if set, causes the callback and all associated validation checks for the option to be executed when the option value is parsed vs. at the end of all parsing. This could cause the callback to be executed multiple times.   
+* `->trigger_on_parse()`:  if set, causes the callback and all associated validation checks for the option to be executed when the option value is parsed vs. at the end of all parsing. This could cause the callback to be executed multiple times.
 
 These options return the `Option` pointer, so you can chain them together, and even skip storing the pointer entirely. The `each` function takes any function that has the signature `void(const std::string&)`; it should throw a `ValidationError` when validation fails. The help message will have the name of the parent option prepended. Since `each`, `check` and `transform` use the same underlying mechanism, you can chain as many as you want, and they will be executed in order. Operations added through `transform` are executed first in reverse order of addition, and `check` and `each` are run following the transform functions in order of addition. If you just want to see the unconverted values, use `.results()` to get the `std::vector<std::string>` of results.
 

From 15852abd24aa212d567bdd0a1de45a57e8ff1684 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Thu, 5 Aug 2021 07:07:34 -0700
Subject: [PATCH 07/11] more updates to the readme

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 267b21e64..c77606435 100644
--- a/README.md
+++ b/README.md
@@ -541,9 +541,9 @@ Validators have a few functions to query the current values:
 
 In most cases, the fastest and easiest way is to return the results through a callback or variable specified in one of the `add_*` functions.  But there are situations where this is not possible or desired.  For these cases the results may be obtained through one of the following functions. Please note that these functions will do any type conversions and processing during the call so should not used in performance critical code:
 
-* `results()`: Retrieves a vector of strings with all the results in the order they were given.
-* `results(variable_to_bind_to)`: Gets the results according to the MultiOptionPolicy and converts them just like the `add_option_function` with a variable.
-* `Value=as<type>()`: Returns the result or default value directly as the specified type if possible, can be vector to return all results, and a non-vector to get the result according to the MultiOptionPolicy in place.
+* `->results()`: Retrieves a vector of strings with all the results in the order they were given.
+* `->results(variable_to_bind_to)`: Gets the results according to the MultiOptionPolicy and converts them just like the `add_option_function` with a variable.
+* `Value=opt->as<type>()`: Returns the result or default value directly as the specified type if possible, can be vector to return all results, and a non-vector to get the result according to the MultiOptionPolicy in place.
 
 ### Subcommands
 

From d595fdabdbaffab18499a8e338dddd6f70766777 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Thu, 5 Aug 2021 07:16:31 -0700
Subject: [PATCH 08/11] update formatting

---
 tests/AppTest.cpp        | 2 +-
 tests/OptionTypeTest.cpp | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/tests/AppTest.cpp b/tests/AppTest.cpp
index 8a3544f07..3b3725402 100644
--- a/tests/AppTest.cpp
+++ b/tests/AppTest.cpp
@@ -2278,7 +2278,7 @@ TEST_CASE_METHOD(TApp, "logFormSingleDash", "[app]") {
         }
     });
     run();
-    CHECK(app.remaining().size()==3U);
+    CHECK(app.remaining().size() == 3U);
     CHECK(verbose);
     CHECK(veryverbose);
     CHECK(veryveryverbose);
diff --git a/tests/OptionTypeTest.cpp b/tests/OptionTypeTest.cpp
index d004ccbf0..640b146a2 100644
--- a/tests/OptionTypeTest.cpp
+++ b/tests/OptionTypeTest.cpp
@@ -914,7 +914,6 @@ TEST_CASE_METHOD(TApp, "vectorDoubleArg", "[optiontype]") {
     CHECK(2U == extras.size());
 }
 
-
 TEST_CASE_METHOD(TApp, "OnParseCall", "[optiontype]") {
 
     int cnt{0};
@@ -924,7 +923,7 @@ TEST_CASE_METHOD(TApp, "OnParseCall", "[optiontype]") {
                                    ++cnt;
                                    return true;
                                })
-                    ->expected(1,20)
+                    ->expected(1, 20)
                     ->trigger_on_parse();
     std::vector<std::string> extras;
     app.add_option("args", extras);
@@ -968,7 +967,6 @@ TEST_CASE_METHOD(TApp, "force_callback2", "[optiontype]") {
     CHECK(5 == cnt);
 }
 
-
 TEST_CASE_METHOD(TApp, "force_callback3", "[optiontype]") {
 
     int cnt{10};

From 9e7000d1caf9075cad37e24d2f52259873d4a043 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Thu, 5 Aug 2021 10:21:24 -0700
Subject: [PATCH 09/11] rework the trigger_on_parse to better support more
 complex option types

---
 book/chapters/options.md |  4 ++--
 include/CLI/App.hpp      |  7 ++++++-
 include/CLI/Option.hpp   | 12 +++---------
 tests/OptionTypeTest.cpp | 12 ++++++++++++
 4 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/book/chapters/options.md b/book/chapters/options.md
index 6d60e7afc..b1cb8411d 100644
--- a/book/chapters/options.md
+++ b/book/chapters/options.md
@@ -20,7 +20,7 @@ You can use any C++ int-like type, not just `int`. CLI11 understands the followi
 
 | Type        | CLI11 |
 |-------------|-------|
-| number like    | Integers, floats, bools, or any type that can be constructed from an integer or floating point number |
+| number like    | Integers, floats, bools, or any type that can be constructed from an integer or floating point number.  Accepts common numerical strings like `0xFF` as well as octal, and decimal |
 | string-like | std\::string, or anything that can be constructed from or assigned a std\::string |
 | char | For a single char, single string values are accepted, otherwise longer strings are treated as integral values and a conversion is attempted |
 | complex-number | std::complex or any type which has a real(), and imag() operations available, will allow 1 or 2 string definitions like "1+2j" or two arguments "1","2" |
@@ -155,7 +155,7 @@ When you call `add_option`, you get a pointer to the added option. You can use t
 | `->always_capture_default()` | Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`. |
 | `->run_callback_for_default()` | Force the option callback to be executed or the variable set when the `default_val` is used.  |
 | `->force_callback()` | Force the option callback to be executed regardless of whether the option was used or not.  Will use the default_str if available, if no default is given the callback will be executed with an empty string as an argument, which will translate to a default initialized value, which can be compiler dependent |
-|`->trigger_on_parse()` | Have the option callback be triggered when the value is parsed vs. at the end of all parsing, the option callback can potentially be executed multiple times.  Generally only useful if you have a user defined callback or validation check|
+|`->trigger_on_parse()` | Have the option callback be triggered when the value is parsed vs. at the end of all parsing, the option callback can potentially be executed multiple times.  Generally only useful if you have a user defined callback or validation check. Or potentially if a vector input is given multiple times as it will clear the results when a repeat option is given via command line.  It will trigger the callbacks once per option call on the command line|
 | `->option_text(string)` | Sets the text between the option name and description. |
 
 The `->check(...)` and `->transform(...)` modifiers can also take 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.
diff --git a/include/CLI/App.hpp b/include/CLI/App.hpp
index a8116f69a..77e97f97d 100644
--- a/include/CLI/App.hpp
+++ b/include/CLI/App.hpp
@@ -2739,6 +2739,9 @@ class App {
                 op->add_result(std::string{});
             }
         }
+        if(op->get_trigger_on_parse() && op->current_option_state_==Option::option_state::callback_run) {
+            op->clear();
+        }
         int min_num = (std::min)(op->get_type_size_min(), op->get_items_expected_min());
         int max_num = op->get_items_expected_max();
         // check container like options to limit the argument size to a single type if the allow_extra_flags argument is
@@ -2811,7 +2814,9 @@ class App {
         if(min_num > 0 && op->get_type_size_max() != min_num && (collected % op->get_type_size_max()) != 0) {
             op->add_result(std::string{});
         }
-
+        if(op->get_trigger_on_parse()) {
+            op->run_callback();
+        }
         if(!rest.empty()) {
             rest = "-" + rest;
             args.push_back(rest);
diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index 5b0fa9b82..a57bc2ea2 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -337,9 +337,9 @@ class Option : public OptionBase<Option> {
     bool run_callback_for_default_{false};
     /// flag indicating a separator needs to be injected after each argument call
     bool inject_separator_{false};
-    /// flag indicating tha the option should trigger the callback on each result when loaded
+    /// flag indicating that the option should trigger the validation and callback chain on each result when loaded
     bool trigger_on_result_{false};
-    /// flag indicating tha the option should force the callback regardless if any results present
+    /// flag indicating that the option should force the callback regardless if any results present
     bool force_callback_{false};
     ///@}
 
@@ -981,11 +981,8 @@ class Option : public OptionBase<Option> {
 
     /// Puts a result at the end
     Option *add_result(std::string s) {
-        auto results_added = _add_result(std::move(s), results_);
+        _add_result(std::move(s), results_);
         current_option_state_ = option_state::parsing;
-        if(trigger_on_result_ && results_added > 0) {
-            run_callback();
-        }
         return this;
     }
 
@@ -993,9 +990,6 @@ class Option : public OptionBase<Option> {
     Option *add_result(std::string s, int &results_added) {
         results_added = _add_result(std::move(s), results_);
         current_option_state_ = option_state::parsing;
-        if(trigger_on_result_ && results_added > 0) {
-            run_callback();
-        }
         return this;
     }
 
diff --git a/tests/OptionTypeTest.cpp b/tests/OptionTypeTest.cpp
index 640b146a2..1565fc58b 100644
--- a/tests/OptionTypeTest.cpp
+++ b/tests/OptionTypeTest.cpp
@@ -933,6 +933,18 @@ TEST_CASE_METHOD(TApp, "OnParseCall", "[optiontype]") {
     CHECK(3 == cnt);
 }
 
+TEST_CASE_METHOD(TApp, "OnParseCallVector", "[optiontype]") {
+
+    std::vector<std::string> vec;
+
+    auto *opt = app.add_option("-c",
+                               vec)
+                    ->trigger_on_parse();
+    args = {"-c", "1", "2", "3", "-c", "2", "-c", "3", "4", "5"};
+    run();
+    CHECK(vec.size() == 3U);
+}
+
 TEST_CASE_METHOD(TApp, "force_callback", "[optiontype]") {
 
     int cnt{0};

From be3ed84704933f94613c3f6c710163017e84f53f Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Wed, 11 Aug 2021 10:41:44 -0700
Subject: [PATCH 10/11] fix formatting errors

---
 include/CLI/App.hpp      | 2 +-
 tests/OptionTypeTest.cpp | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/include/CLI/App.hpp b/include/CLI/App.hpp
index 77e97f97d..2b0b453a9 100644
--- a/include/CLI/App.hpp
+++ b/include/CLI/App.hpp
@@ -2739,7 +2739,7 @@ class App {
                 op->add_result(std::string{});
             }
         }
-        if(op->get_trigger_on_parse() && op->current_option_state_==Option::option_state::callback_run) {
+        if(op->get_trigger_on_parse() && op->current_option_state_ == Option::option_state::callback_run) {
             op->clear();
         }
         int min_num = (std::min)(op->get_type_size_min(), op->get_items_expected_min());
diff --git a/tests/OptionTypeTest.cpp b/tests/OptionTypeTest.cpp
index 1565fc58b..623206926 100644
--- a/tests/OptionTypeTest.cpp
+++ b/tests/OptionTypeTest.cpp
@@ -937,9 +937,7 @@ TEST_CASE_METHOD(TApp, "OnParseCallVector", "[optiontype]") {
 
     std::vector<std::string> vec;
 
-    auto *opt = app.add_option("-c",
-                               vec)
-                    ->trigger_on_parse();
+    app.add_option("-c", vec)->trigger_on_parse();
     args = {"-c", "1", "2", "3", "-c", "2", "-c", "3", "4", "5"};
     run();
     CHECK(vec.size() == 3U);

From 9c2feefedb5bd717e053e1a7ad801334e235ffbe Mon Sep 17 00:00:00 2001
From: Henry Schreiner <HenrySchreinerIII@gmail.com>
Date: Mon, 20 Sep 2021 10:07:17 -0400
Subject: [PATCH 11/11] Update include/CLI/Option.hpp

---
 include/CLI/Option.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index a57bc2ea2..334f887e6 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -685,7 +685,7 @@ class Option : public OptionBase<Option> {
     /// The maximum number of arguments the option expects
     int get_type_size_max() const { return type_size_max_; }
 
-    /// return the inject_separator flag
+    /// Return the inject_separator flag
     int get_inject_separator() const { return inject_separator_; }
 
     /// The environment variable associated to this value