click-style boolean flags (#219)

Updates to the readme update the readme with some documentation add a few more tests to complete code coverage update with count strings in flags instead an array of strings for each count add the '!' shortcut notation. add some checks on the help output allow the false flag syntax to support --option{false} add a bool lexical cast to make everything consistent when converting to a bool. Moved a few functions around make the command line behave like the INI file wrt flags, flag options are allowed to process the value so `--flag=false` actually does the expected thing. Add functionality similar to click style argument that allow specifying a false flag that when used generates a false result on the flag.

click-style boolean flags (#219)
Updates to the readme update the readme with some documentation add a few more tests to complete code coverage update with count strings in flags instead an array of strings for each count add the '!' shortcut notation. add some checks on the help output allow the false flag syntax to support --option{false} add a bool lexical cast to make everything consistent when converting to a bool. Moved a few functions around make the command line behave like the INI file wrt flags, flag options are allowed to process the value so `--flag=false` actually does the expected thing. Add functionality similar to click style argument that allow specifying a false flag that when used generates a false result on the flag.
Philip Top · Henry Schreiner
1 parent 59ae97d0
Showing 12 changed files with 560 additions and 110 deletions
README.md
include/CLI/App.hpp
include/CLI/ConfigFwd.hpp
include/CLI/Formatter.hpp
include/CLI/Option.hpp
include/CLI/Split.hpp
include/CLI/StringTools.hpp
include/CLI/TypeTools.hpp
tests/AppTest.cpp
tests/FormatterTest.cpp
tests/HelpersTest.cpp
tests/IniTest.cpp
@@ -186,11 +186,14 @@ app.add_option_function&lt;type&gt;(option_name,
 app.add_complex(... // Special case: support for complex numbers
  
 app.add_flag(option_name,
-             int_or_bool = nothing,
+             help_string="")
+
+app.add_flag(option_name,
+             int_or_bool,
              help_string="")
  
 app.add_flag_function(option_name,
-             function <void(size_t count)>,
+             function <void(int count)>,
              help_string="")
  
 app.add_set(option_name,
@@ -212,7 +215,33 @@ App* subcom = app.add_subcommand(name, description);
  
 An option name must start with a alphabetic character or underscore. For long options, anything but an equals sign or a comma is valid after that. Names are given as a comma separated string, with the dash or dashes. An option or flag can have as many names as you want, and afterward, using `count`, you can use any of the names, with dashes as needed, to count the options. One of the names is allowed to be given without proceeding dash(es); if present the option is a positional option, and that name will be used on help line for its positional form. If you want the default value to print in the help description, pass in `true` for the final parameter for `add_option` or `add_set`. The set options allow your users to pick from a set of predefined options, and you can use an initializer list directly if you like. If you need to modify the set later, use the `mutable` forms.
  
-The `add_option_function<type>(...` function will typically require the template parameter be given unless a std::function object with an exact match is passed.  The type can be any type supported by the `add_option` function
+The `add_option_function<type>(...` function will typically require the template parameter be given unless a `std::function` object with an exact match is passed.  The type can be any type supported by the `add_option` function.
+
+Flag options specified through the functions
+
+```cpp
+app.add_flag(option_name,
+             int_or_bool,
+             help_string="")
+
+app.add_flag_function(option_name,
+             function <void(int count)>,
+             help_string="")
+```
+
+allow a syntax for the option names to default particular options to a false value if some flags are passed.  For example:
+
+```cpp
+app.add_flag("--flag,!--no-flag,result,"help for flag");`
+``````
+
+specifies that if `--flag` is passed on the command line result will be true or contain a value of 1. If `--no-flag` is
+passed result will contain false or -1 if result is a signed integer type, or 0 if it is an unsigned type.  An
+alternative form of the syntax is more explicit: `"--flag,--no-flag{false}"`; this is equivalent to the previous
+example.  This also works for short form options `"-f,!-n"` or `"-f,-n{false}"` If `int_or_bool` is a boolean value the
+default behavior is to take the last value given, while if `int_or_bool` is an integer type the behavior will be to sum
+all the given arguments and return the result.  This can be modifed if needed by changing the `multi_option_policy` on
+each flag (this is not inherited).
  
 On a C++14 compiler, you can pass a callback function directly to `.add_flag`, while in C++11 mode you'll need to use `.add_flag_function` if you want a callback function. The function will be given the number of times the flag was passed. You can throw a relevant `CLI::ParseError` to signal a failure.
  
@@ -241,7 +270,7 @@ Before parsing, you can set the following options:
 -   `->ignore_case()`: Ignore the case on the command line (also works on subcommands, does not affect arguments).
 -   `->ignore_underscore()`: Ignore any underscores in the options names (also works on subcommands, does not affect arguments). For example "option_one" will match with "optionone".  This does not apply to short form options since they only have one character
 -   `->description(str)`: Set/change the description.
--   `->multi_option_policy(CLI::MultiOptionPolicy::Throw)`: Set the multi-option policy. Shortcuts available: `->take_last()`, `->take_first()`, and `->join()`. This will only affect options expecting 1 argument or bool flags (which always default to take last).
+-   `->multi_option_policy(CLI::MultiOptionPolicy::Throw)`: Set the multi-option policy. Shortcuts available: `->take_last()`, `->take_first()`, 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).
 -   `->check(CLI::ExistingFile)`: Requires that the file exists if given.
 -   `->check(CLI::ExistingDirectory)`: Requires that the directory exists.
 -   `->check(CLI::ExistingPath)`: Requires that the path (file or directory) exists.
@@ -261,6 +290,7 @@ On the command line, options can be given as:
 -   `-ffilename` (no space required)
 -   `-abcf filename` (flags and option can be combined)
 -   `--long` (long flag)
+-   `--long_flag=true` (long flag with equals)
 -   `--file filename` (space)
 -   `--file=filename` (equals)
  
@@ -272,6 +302,8 @@ If allow_windows_style_options() is specified in the application or subcommand o
 -   `/file:filename` (colon)
 =  Windows style options do not allow combining short options or values not separated from the short option like with `-` options
  
+Long flag options may be given with and `=<value>` to allow specifying a false value See [config files](#configuration-file) for details on the values supported.  NOTE: only the `=` or `:` for windows-style options may be used for this, using a space will result in the argument being interpreted as a positional argument.  This syntax can override the default (true or false) values.
+
 Extra positional arguments will cause the program to exit, so at least one positional option with a vector is recommended if you want to allow extraneous arguments.
 If you set `.allow_extras()` on the main `App`, you will not get an error. You can access the missing options using `remaining` (if you have subcommands, `app.remaining(true)` will get all remaining options, subcommands included).
  
@@ -360,7 +392,7 @@ 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". You cannot set positional-only arguments or force subcommands to be present in the command line.
+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`,`enable`; or `false`, `off`, `0`, `no`,`disable` (case insensitive). Sections (and `.` separated names) are treated as subcommands (note: this does not mean that subcommand was passed, it just sets the "defaults". You cannot set positional-only arguments or force subcommands to be present in the command line.
  
 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.
@@ -538,7 +538,6 @@ class App {
     /// 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);
@@ -552,14 +551,21 @@ class App {
     Option *add_flag(std::string flag_name,
                      T &flag_count, ///< A variable holding the count
                      std::string description = "") {
-
         flag_count = 0;
+        Option *opt;
         CLI::callback_t fun = [&flag_count](CLI::results_t res) {
-            flag_count = static_cast<T>(res.size());
+            detail::sum_flag_vector(res, flag_count);
             return true;
         };
+        if(detail::has_false_flags(flag_name)) {
+            std::vector<std::string> neg = detail::get_false_flags(flag_name);
+            detail::remove_false_flag_notation(flag_name);
+            opt = add_option(flag_name, fun, description, false);
+            opt->fnames_ = std::move(neg);
+        } else {
+            opt = add_option(flag_name, fun, description, false);
+        }
  
-        Option *opt = add_option(flag_name, fun, description, false);
         if(opt->get_positional())
             throw IncorrectConstruction::PositionalFlag(flag_name);
         opt->type_size(0);
@@ -570,16 +576,23 @@ class App {
     /// `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
+                     T &flag_result, ///< 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;
+        flag_result = false;
+        Option *opt;
+        CLI::callback_t fun = [&flag_result](CLI::results_t res) {
+            flag_result = (res[0][0] != '-');
             return res.size() == 1;
         };
+        if(detail::has_false_flags(flag_name)) {
+            std::vector<std::string> neg = detail::get_false_flags(flag_name);
+            detail::remove_false_flag_notation(flag_name);
+            opt = add_option(flag_name, fun, std::move(description), false);
+            opt->fnames_ = std::move(neg);
+        } else {
+            opt = add_option(flag_name, fun, std::move(description), false);
+        }
  
-        Option *opt = add_option(flag_name, fun, description, false);
         if(opt->get_positional())
             throw IncorrectConstruction::PositionalFlag(flag_name);
         opt->type_size(0);
@@ -589,15 +602,25 @@ class App {
  
     /// 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::function<void(int)> function, ///< A function to call, void(size_t)
                               std::string description = "") {
  
         CLI::callback_t fun = [function](CLI::results_t res) {
-            function(res.size());
+            int flag_count = 0;
+            detail::sum_flag_vector(res, flag_count);
+            function(flag_count);
             return true;
         };
+        Option *opt;
+        if(detail::has_false_flags(flag_name)) {
+            std::vector<std::string> neg = detail::get_false_flags(flag_name);
+            detail::remove_false_flag_notation(flag_name);
+            opt = add_option(flag_name, fun, std::move(description), false);
+            opt->fnames_ = std::move(neg);
+        } else {
+            opt = add_option(flag_name, fun, std::move(description), false);
+        }
  
-        Option *opt = add_option(flag_name, fun, description, false);
         if(opt->get_positional())
             throw IncorrectConstruction::PositionalFlag(flag_name);
         opt->type_size(0);
@@ -607,9 +630,9 @@ class App {
 #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::function<void(int)> function, ///< A function to call, void(int)
                      std::string description = "") {
-        return add_flag_function(flag_name, std::move(function), description);
+        return add_flag_function(std::move(flag_name), std::move(function), std::move(description));
     }
 #endif
  
@@ -628,7 +651,7 @@ class App {
             return std::find(std::begin(options), std::end(options), member) != std::end(options);
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         std::string typeval = detail::type_name<T>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -650,7 +673,7 @@ class App {
             return std::find(std::begin(options), std::end(options), member) != std::end(options);
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         opt->type_name_fn(
             [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
  
@@ -673,7 +696,7 @@ class App {
             return std::find(std::begin(options), std::end(options), member) != std::end(options);
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         std::string typeval = detail::type_name<T>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -701,7 +724,7 @@ class App {
             return std::find(std::begin(options), std::end(options), member) != std::end(options);
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         opt->type_name_fn(
             [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
         if(defaulted) {
@@ -732,7 +755,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -761,7 +784,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         opt->type_name_fn([&options]() {
             return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
         });
@@ -790,7 +813,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -821,7 +844,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         opt->type_name_fn([&options]() {
             return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
         });
@@ -851,7 +874,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -880,7 +903,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         opt->type_name_fn([&options]() {
             return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
         });
@@ -909,7 +932,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -941,7 +964,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         opt->type_name_fn([&options]() {
             return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
         });
@@ -971,7 +994,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -1000,7 +1023,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, false);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), false);
         opt->type_name_fn([&options]() {
             return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
         });
@@ -1029,7 +1052,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         std::string typeval = detail::type_name<std::string>();
         typeval += " in {" + detail::join(options) + "}";
         opt->type_name(typeval);
@@ -1061,7 +1084,7 @@ class App {
             }
         };
  
-        Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         opt->type_name_fn([&options]() {
             return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
         });
@@ -1090,7 +1113,7 @@ class App {
             return worked;
         };
  
-        CLI::Option *opt = add_option(option_name, std::move(fun), description, defaulted);
+        CLI::Option *opt = add_option(option_name, std::move(fun), std::move(description), defaulted);
         opt->type_name(label)->type_size(2);
         if(defaulted) {
             std::stringstream out;
@@ -1149,7 +1172,7 @@ class App {
  
     /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
     App *add_subcommand(std::string subcommand_name = "", std::string description = "") {
-        CLI::App_p subcom = std::shared_ptr<App>(new App(description, subcommand_name, this));
+        CLI::App_p subcom = std::shared_ptr<App>(new App(std::move(description), subcommand_name, this));
         return add_subcommand(std::move(subcom));
     }
  
@@ -1186,7 +1209,7 @@ class App {
     }
     /// Get a pointer to subcommand by index
     App *get_subcommand(int index = 0) const {
-        if((index >= 0) && (index < subcommands_.size()))
+        if((index >= 0) && (index < static_cast<int>(subcommands_.size())))
             return subcommands_[index].get();
         throw OptionNotFound(std::to_string(index));
     }
@@ -1211,7 +1234,7 @@ class App {
  
     /// Get an owning pointer to subcommand by index
     CLI::App_p get_subcommand_ptr(int index = 0) const {
-        if((index >= 0) && (index < subcommands_.size()))
+        if((index >= 0) && (index < static_cast<int>(subcommands_.size())))
             return subcommands_[index];
         throw OptionNotFound(std::to_string(index));
     }
@@ -1957,7 +1980,12 @@ class App {
         if(op->empty()) {
             // Flag parsing
             if(op->get_type_size() == 0) {
-                op->set_results(config_formatter_->to_flag(item));
+                auto res = config_formatter_->to_flag(item);
+                if(op->check_fname(item.name)) {
+                    res = (res == "1") ? "-1" : ((res[0] == '-') ? res.substr(1) : std::string("-" + res));
+                }
+                op->add_result(res);
+
             } else {
                 op->set_results(item.inputs);
                 op->run_callback();
@@ -2138,18 +2166,27 @@ class App {
  
         // Make sure we always eat the minimum for unlimited vectors
         int collected = 0;
-
+        // deal with flag like things
+        if(num == 0) {
+            try {
+                auto res = (value.empty()) ? std ::string("1") : detail::to_flag_value(value);
+                if(op->check_fname(arg_name)) {
+                    res = (res == "1") ? "-1" : ((res[0] == '-') ? res.substr(1) : std::string("-" + res));
+                }
+                op->add_result(res);
+                parse_order_.push_back(op.get());
+            } catch(const std::invalid_argument &) {
+                throw ConversionError::TrueFalse(arg_name);
+            }
+        }
         // --this=value
-        if(!value.empty()) {
+        else 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)
@@ -69,27 +69,16 @@ class Config {
     /// 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 {
+    /// Convert a flag to a bool representation
+    virtual 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());
-                }
+            try {
+                return detail::to_flag_value(item.inputs.at(0));
+            } catch(const std::invalid_argument &) {
+                throw ConversionError::TrueFalse(item.fullname());
             }
-        } else {
-            throw ConversionError::TooManyInputsFlag(item.fullname());
         }
+        throw ConversionError::TooManyInputsFlag(item.fullname());
     }
  
     /// Parse a config file, throw an error (ParseError:ConfigParseError or FileError) on failure
@@ -59,10 +59,7 @@ inline std::string Formatter::make_groups(const App *app, AppFormatMode mode) co
 inline std::string Formatter::make_description(const App *app) const {
     std::string desc = app->get_description();
  
-    if(!desc.empty())
-        return desc + "\n";
-    else
-        return "";
+    return (!desc.empty()) ? desc + "\n" : std::string{};
 }
  
 inline std::string Formatter::make_usage(const App *app, std::string name) const {
@@ -243,7 +240,6 @@ inline std::string Formatter::make_option_usage(const Option *opt) const {
         out << "(" << std::to_string(opt->get_expected()) << "x)";
     else if(opt->get_expected() < 0)
         out << "...";
-
     return opt->get_required() ? out.str() : "[" + out.str() + "]";
 }
  
@@ -173,6 +173,10 @@ class Option : public OptionBase&lt;Option&gt; {
     /// A list of the long names (`--a`) without the leading dashes
     std::vector<std::string> lnames_;
  
+    /// A list of the negation names, should be duplicates of what is in snames or lnames but trigger a false response
+    /// on a flag
+    std::vector<std::string> fnames_;
+
     /// A positional name
     std::string pname_;
  
@@ -478,6 +482,9 @@ class Option : public OptionBase&lt;Option&gt; {
     /// Get the short names
     const std::vector<std::string> get_snames() const { return snames_; }
  
+    /// get the negative flag names
+    const std::vector<std::string> get_fnames() const { return fnames_; }
+
     /// The number of times the option expects to be included
     int get_expected() const { return expected_; }
  
@@ -542,12 +549,27 @@ class Option : public OptionBase&lt;Option&gt; {
             /// 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_);
+            if((get_items_expected() == 0) && (!fnames_.empty())) {
+                for(const std::string &sname : snames_) {
+                    name_list.push_back("-" + sname);
+                    if(check_fname(sname)) {
+                        name_list.back() += "{false}";
+                    }
+                }
  
-            for(const std::string &sname : snames_)
-                name_list.push_back("-" + sname);
+                for(const std::string &lname : lnames_) {
+                    name_list.push_back("--" + lname);
+                    if(check_fname(lname)) {
+                        name_list.back() += "{false}";
+                    }
+                }
+            } else {
+                for(const std::string &sname : snames_)
+                    name_list.push_back("-" + sname);
  
-            for(const std::string &lname : lnames_)
-                name_list.push_back("--" + lname);
+                for(const std::string &lname : lnames_)
+                    name_list.push_back("--" + lname);
+            }
  
             return detail::join(name_list);
  
@@ -651,62 +673,55 @@ class Option : public OptionBase&lt;Option&gt; {
     /// 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) == "--")
+        if(name.length() > 2 && name[0] == '-' && name[1] == '-')
             return check_lname(name.substr(2));
-        else if(name.length() > 1 && name.substr(0, 1) == "-")
+        else if(name.length() > 1 && name.front() == '-')
             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);
             }
+            if(ignore_case_) {
+                local_pname = detail::to_lower(local_pname);
+                name = detail::to_lower(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_);
-    }
+    bool check_sname(std::string name) const { return detail::check_is_member(name, snames_, ignore_case_); }
  
     /// 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_);
-            }
+        return detail::check_is_member(name, lnames_, ignore_case_, ignore_underscore_);
+    }
  
-        } 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_);
+    /// Requires "--" to be removed from string
+    bool check_fname(std::string name) const {
+        if(fnames_.empty()) {
+            return false;
+        }
+        return detail::check_is_member(name, fnames_, ignore_case_, ignore_underscore_);
     }
  
     /// Puts a result at the end
     Option *add_result(std::string s) {
-        results_.push_back(s);
+        results_.push_back(std::move(s));
+        callback_run_ = false;
+        return this;
+    }
+
+    /// Puts a result at the end
+    Option *add_result(std::vector<std::string> s) {
+        if(results_.empty()) {
+            results_ = std::move(s);
+        } else {
+            results_.insert(results_.end(), s.begin(), s.end());
+        }
+
         callback_run_ = false;
         return this;
     }
@@ -67,6 +67,26 @@ inline std::vector&lt;std::string&gt; split_names(std::string current) {
     return output;
 }
  
+/// extract negation arguments basically everything after a '|' and before the next comma
+inline std::vector<std::string> get_false_flags(const std::string &str) {
+    std::vector<std::string> output = split_names(str);
+    output.erase(std::remove_if(output.begin(),
+                                output.end(),
+                                [](const std::string &name) {
+                                    return ((name.empty()) ||
+                                            ((name.find("{false}") == std::string::npos) && (name[0] != '!')));
+                                }),
+                 output.end());
+    for(auto &flag : output) {
+        auto false_loc = flag.find("{false}");
+        if(false_loc != std::string::npos) {
+            flag.erase(false_loc, std::string::npos);
+        }
+        flag.erase(0, flag.find_first_not_of("-!"));
+    }
+    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) {
@@ -7,6 +7,7 @@
 #include <iomanip>
 #include <locale>
 #include <sstream>
+#include <stdexcept>
 #include <string>
 #include <type_traits>
 #include <vector>
@@ -161,6 +162,42 @@ inline std::string find_and_replace(std::string str, std::string from, std::stri
     return str;
 }
  
+/// check if the flag definitions has possible false flags
+inline bool has_false_flags(const std::string &flags) { return (flags.find_first_of("{!") != std::string::npos); }
+
+inline void remove_false_flag_notation(std::string &flags) {
+    flags = detail::find_and_replace(flags, "{false}", std::string{});
+    flags = detail::find_and_replace(flags, "{true}", std::string{});
+    flags.erase(std::remove(flags.begin(), flags.end(), '!'), flags.end());
+}
+
+/// Check if a string is a member of a list of strings and optionally ignore case or ignore underscores
+inline bool check_is_member(std::string name,
+                            const std::vector<std::string> names,
+                            bool ignore_case = false,
+                            bool ignore_underscore = false) {
+    if(ignore_case) {
+        if(ignore_underscore) {
+            name = detail::to_lower(detail::remove_underscore(name));
+            return std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
+                       return detail::to_lower(detail::remove_underscore(local_name)) == name;
+                   }) != std::end(names);
+        } else {
+            name = detail::to_lower(name);
+            return std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
+                       return detail::to_lower(local_name) == name;
+                   }) != std::end(names);
+        }
+
+    } else if(ignore_underscore) {
+        name = detail::remove_underscore(name);
+        return std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
+                   return detail::remove_underscore(local_name) == name;
+               }) != std::end(names);
+    } else
+        return std::find(std::begin(names), std::end(names), name) != std::end(names);
+}
+
 /// 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) {
@@ -171,6 +208,49 @@ template &lt;typename Callable&gt; inline std::string find_and_modify(std::string str,
     return str;
 }
  
+/// generate a vector of values that represent a boolean  they will be either "+" or "-"
+inline std::string to_flag_value(std::string val) {
+    val = detail::to_lower(val);
+    std::string ret;
+    if(val.size() == 1) {
+        switch(val[0]) {
+        case '0':
+        case 'f':
+        case 'n':
+        case '-':
+            ret = "-1";
+            break;
+        case '1':
+        case 't':
+        case 'y':
+        case '+':
+            ret = "1";
+            break;
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            ret = val;
+            break;
+        default:
+            throw std::invalid_argument("unrecognized character");
+        }
+        return ret;
+    }
+    if(val == "true" || val == "on" || val == "yes" || val == "enable") {
+        ret = "1";
+    } else if(val == "false" || val == "off" || val == "no" || val == "disable") {
+        ret = "-1";
+    } else {
+        auto ui = std::stoll(val);
+        ret = (ui == 0) ? "-1" : val;
+    }
+    return ret;
+}
 /// 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) {
@@ -80,7 +80,8 @@ constexpr const char *type_name() {
  
 /// Signed integers / enums
 template <typename T,
-          enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), detail::enabler> = detail::dummy>
+          enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value && !is_bool<T>::value, detail::enabler> =
+              detail::dummy>
 bool lexical_cast(std::string input, T &output) {
     try {
         size_t n = 0;
@@ -96,7 +97,8 @@ bool lexical_cast(std::string input, T &amp;output) {
  
 /// Unsigned integers
 template <typename T,
-          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value && !is_bool<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.
@@ -113,6 +115,24 @@ bool lexical_cast(std::string input, T &amp;output) {
     }
 }
  
+/// boolean values
+template <typename T, enable_if_t<is_bool<T>::value, detail::enabler> = detail::dummy>
+bool lexical_cast(std::string input, T &output) {
+    try {
+        auto out = to_flag_value(input);
+        if(out == "1") {
+            output = true;
+        } else if(out == "-1") {
+            output = false;
+        } else {
+            output = (std::stoll(out) > 0);
+        }
+        return true;
+    } catch(const std::invalid_argument &) {
+        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) {
@@ -150,5 +170,37 @@ bool lexical_cast(std::string input, T &amp;output) {
     return !is.fail() && !is.rdbuf()->in_avail();
 }
  
+/// sum a vector of flag representations
+/// The flag vector produces a series of strings in a vector,  simple true is represented by a "1",  simple false is by
+/// "-1" an if numbers are passed by some fashion they are captured as well so the function just checks for the most
+/// common true and false strings then uses stoll to convert the rest for summing
+template <typename T,
+          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
+    int64_t count{0};
+    static const auto trueString = std::string("1");
+    static const auto falseString = std::string("-1");
+    for(auto &flag : flags) {
+        count += (flag == trueString) ? 1 : ((flag == falseString) ? (-1) : std::stoll(flag));
+    }
+    output = (count > 0) ? static_cast<T>(count) : T{0};
+}
+
+/// sum a vector of flag representations
+/// The flag vector produces a series of strings in a vector,  simple true is represented by a "1",  simple false is by
+/// "-1" an if numbers are passed by some fashion they are captured as well so the function just checks for the most
+/// common true and false strings then uses stoll to convert the rest for summing
+template <typename T,
+          enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, detail::enabler> = detail::dummy>
+void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
+    int64_t count{0};
+    static const auto trueString = std::string("1");
+    static const auto falseString = std::string("-1");
+    for(auto &flag : flags) {
+        count += (flag == trueString) ? 1 : ((flag == falseString) ? (-1) : std::stoll(flag));
+    }
+    output = static_cast<T>(count);
+}
+
 } // namespace detail
 } // namespace CLI
@@ -91,6 +91,57 @@ TEST_F(TApp, OneFlagRef) {
     EXPECT_EQ(1, ref);
 }
  
+TEST_F(TApp, OneFlagRefValue) {
+    int ref;
+    app.add_flag("-c,--count", ref);
+    args = {"--count=7"};
+    run();
+    EXPECT_EQ(1u, app.count("-c"));
+    EXPECT_EQ(1u, app.count("--count"));
+    EXPECT_EQ(7, ref);
+}
+
+TEST_F(TApp, OneFlagRefValueFalse) {
+    int ref;
+    app.add_flag("-c,--count", ref);
+    args = {"--count=false"};
+    run();
+    EXPECT_EQ(1u, app.count("-c"));
+    EXPECT_EQ(1u, app.count("--count"));
+    EXPECT_EQ(-1, ref);
+
+    args = {"--count=0"};
+    run();
+    EXPECT_EQ(1u, app.count("-c"));
+    EXPECT_EQ(1u, app.count("--count"));
+    EXPECT_EQ(-1, ref);
+
+    args = {"--count=happy"};
+    EXPECT_THROW(run(), CLI::ConversionError);
+}
+
+TEST_F(TApp, FlagNegation) {
+    int ref;
+    app.add_flag("-c,--count,--ncount{false}", ref);
+    args = {"--count", "-c", "--ncount"};
+    run();
+    EXPECT_EQ(3u, app.count("-c"));
+    EXPECT_EQ(3u, app.count("--count"));
+    EXPECT_EQ(3u, app.count("--ncount"));
+    EXPECT_EQ(1, ref);
+}
+
+TEST_F(TApp, FlagNegationShortcutNotation) {
+    int ref;
+    app.add_flag("-c,--count,!--ncount", ref);
+    args = {"--count", "-c", "--ncount"};
+    run();
+    EXPECT_EQ(3u, app.count("-c"));
+    EXPECT_EQ(3u, app.count("--count"));
+    EXPECT_EQ(3u, app.count("--ncount"));
+    EXPECT_EQ(1, ref);
+}
+
 TEST_F(TApp, OneString) {
     std::string str;
     app.add_option("-s,--string", str);
@@ -467,6 +518,23 @@ TEST_F(TApp, BoolOnlyFlag) {
     EXPECT_THROW(run(), CLI::ConversionError);
 }
  
+TEST_F(TApp, BoolOption) {
+    bool bflag;
+    app.add_option("-b", bflag);
+
+    args = {"-b", "false"};
+    run();
+    EXPECT_FALSE(bflag);
+
+    args = {"-b", "1"};
+    run();
+    EXPECT_TRUE(bflag);
+
+    args = {"-b", "-7"};
+    run();
+    EXPECT_FALSE(bflag);
+}
+
 TEST_F(TApp, ShortOpts) {
  
     unsigned long long funnyint;
@@ -976,6 +1044,64 @@ TEST_F(TApp, CallbackFlags) {
     EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
 }
  
+TEST_F(TApp, CallbackFlagsFalse) {
+    int value = 0;
+
+    auto func = [&value](int x) { value = x; };
+
+    app.add_flag_function("-v,-f{false},--val,--fval{false}", func);
+
+    run();
+    EXPECT_EQ(value, 0u);
+
+    args = {"-f"};
+    run();
+    EXPECT_EQ(value, -1);
+
+    args = {"-vfv"};
+    run();
+    EXPECT_EQ(value, 1);
+
+    args = {"--fval"};
+    run();
+    EXPECT_EQ(value, -1);
+
+    args = {"--fval=2"};
+    run();
+    EXPECT_EQ(value, -2);
+
+    EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
+}
+
+TEST_F(TApp, CallbackFlagsFalseShortcut) {
+    int value = 0;
+
+    auto func = [&value](int x) { value = x; };
+
+    app.add_flag_function("-v,!-f,--val,!--fval", func);
+
+    run();
+    EXPECT_EQ(value, 0u);
+
+    args = {"-f"};
+    run();
+    EXPECT_EQ(value, -1);
+
+    args = {"-vfv"};
+    run();
+    EXPECT_EQ(value, 1);
+
+    args = {"--fval"};
+    run();
+    EXPECT_EQ(value, -1);
+
+    args = {"--fval=2"};
+    run();
+    EXPECT_EQ(value, -2);
+
+    EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
+}
+
 #if __cplusplus >= 201402L || _MSC_VER >= 1900
 TEST_F(TApp, CallbackFlagsAuto) {
  
@@ -83,6 +83,25 @@ TEST(Formatter, OptCustomizeSimple) {
               "  --opt INT (MUST HAVE)  Something\n");
 }
  
+TEST(Formatter, FalseFlagExample) {
+    CLI::App app{"My prog"};
+
+    app.get_formatter()->column_width(25);
+    app.get_formatter()->label("REQUIRED", "(MUST HAVE)");
+
+    int v;
+    app.add_flag("--opt,!--no_opt", v, "Something");
+
+    bool flag;
+    app.add_flag("!-O,--opt2,--no_opt2{false}", flag, "Something else");
+
+    std::string help = app.help();
+
+    EXPECT_THAT(help, HasSubstr("--no_opt{false}"));
+    EXPECT_THAT(help, HasSubstr("--no_opt2{false}"));
+    EXPECT_THAT(help, HasSubstr("-O{false}"));
+}
+
 TEST(Formatter, AppCustomize) {
     CLI::App app{"My prog"};
     app.add_subcommand("subcom1", "This");
@@ -68,6 +68,20 @@ TEST(StringTools, Modify3) {
     EXPECT_EQ(newString, "aba");
 }
  
+TEST(StringTools, flagValues) {
+    EXPECT_EQ(CLI::detail::to_flag_value("0"), "-1");
+    EXPECT_EQ(CLI::detail::to_flag_value("t"), "1");
+    EXPECT_EQ(CLI::detail::to_flag_value("1"), "1");
+    EXPECT_EQ(CLI::detail::to_flag_value("6"), "6");
+    EXPECT_EQ(CLI::detail::to_flag_value("-6"), "-6");
+    EXPECT_EQ(CLI::detail::to_flag_value("false"), "-1");
+    EXPECT_EQ(CLI::detail::to_flag_value("YES"), "1");
+    EXPECT_THROW(CLI::detail::to_flag_value("frog"), std::invalid_argument);
+    EXPECT_THROW(CLI::detail::to_flag_value("q"), std::invalid_argument);
+    EXPECT_EQ(CLI::detail::to_flag_value("NO"), "-1");
+    EXPECT_EQ(CLI::detail::to_flag_value("4755263255233"), "4755263255233");
+}
+
 TEST(Trim, Various) {
     std::string s1{"  sdlfkj sdflk sd s  "};
     std::string a1{"sdlfkj sdflk sd s"};
@@ -568,6 +582,20 @@ TEST(Types, LexicalCastDouble) {
     EXPECT_FALSE(CLI::detail::lexical_cast(extra_input, x));
 }
  
+TEST(Types, LexicalCastBool) {
+    std::string input = "false";
+    bool x;
+    EXPECT_TRUE(CLI::detail::lexical_cast(input, x));
+    EXPECT_FALSE(x);
+
+    std::string bad_input = "happy";
+    EXPECT_FALSE(CLI::detail::lexical_cast(bad_input, x));
+
+    std::string input_true = "EnaBLE";
+    EXPECT_TRUE(CLI::detail::lexical_cast(input_true, x));
+    EXPECT_TRUE(x);
+}
+
 TEST(Types, LexicalCastString) {
     std::string input = "one";
     std::string output;
@@ -608,6 +608,62 @@ TEST_F(TApp, IniFlags) {
     EXPECT_EQ(true, five);
 }
  
+TEST_F(TApp, IniFalseFlags) {
+    TempFile tmpini{"TestIniTmp.ini"};
+    app.set_config("--config", tmpini);
+
+    {
+        std::ofstream out{tmpini};
+        out << "[default]" << std::endl;
+        out << "two=-2" << std::endl;
+        out << "three=false" << std::endl;
+        out << "four=1" << std::endl;
+        out << "five" << std::endl;
+    }
+
+    int two;
+    bool three, four, five;
+    app.add_flag("--two", two);
+    app.add_flag("--three", three);
+    app.add_flag("--four", four);
+    app.add_flag("--five", five);
+
+    run();
+
+    EXPECT_EQ(-2, two);
+    EXPECT_EQ(false, three);
+    EXPECT_EQ(true, four);
+    EXPECT_EQ(true, five);
+}
+
+TEST_F(TApp, IniFalseFlagsDef) {
+    TempFile tmpini{"TestIniTmp.ini"};
+    app.set_config("--config", tmpini);
+
+    {
+        std::ofstream out{tmpini};
+        out << "[default]" << std::endl;
+        out << "two=2" << std::endl;
+        out << "three=true" << std::endl;
+        out << "four=on" << std::endl;
+        out << "five" << std::endl;
+    }
+
+    int two;
+    bool three, four, five;
+    app.add_flag("--two{false}", two);
+    app.add_flag("--three", three);
+    app.add_flag("!--four", four);
+    app.add_flag("--five", five);
+
+    run();
+
+    EXPECT_EQ(-2, two);
+    EXPECT_EQ(true, three);
+    EXPECT_EQ(false, four);
+    EXPECT_EQ(true, five);
+}
+
 TEST_F(TApp, IniOutputSimple) {
  
     int v;