CLI11.hpp File Reference

#include <memory>
#include <string>
#include <cmath>
#include <functional>
#include <numeric>
#include <map>
#include <fstream>
#include <tuple>
#include <utility>
#include <iomanip>
#include <locale>
#include <sstream>
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <set>
#include <type_traits>
#include <iterator>
#include <stdexcept>
#include <vector>
#include <limits>
#include <exception>
#include <sys/stat.h>
#include <sys/types.h>

Include dependency graph for CLI11.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	CLI::Error
	All errors derive from this one. More...
class	CLI::ConstructionError
	Construction errors (not in parsing) More...
class	CLI::IncorrectConstruction
	Thrown when an option is set to conflicting values (non-vector and multi args, for example) More...
class	CLI::BadNameString
	Thrown on construction of a bad name. More...
class	CLI::OptionAlreadyAdded
	Thrown when an option already exists. More...
class	CLI::ParseError
	Anything that can error in Parse. More...
class	CLI::Success
	This is a successful completion on parsing, supposed to exit. More...
class	CLI::CallForHelp
	-h or –help on command line More...
class	CLI::CallForAllHelp
	Usually something like –help-all on command line. More...
class	CLI::CallForVersion
	-v or –version on command line More...
class	CLI::RuntimeError
	Does not output a diagnostic in CLI11_PARSE, but allows main() to return with a specific error code. More...
class	CLI::FileError
	Thrown when parsing an INI file and it is missing. More...
class	CLI::ConversionError
	Thrown when conversion call back fails, such as when an int fails to coerce to a string. More...
class	CLI::ValidationError
	Thrown when validation of results fails. More...
class	CLI::RequiredError
	Thrown when a required option is missing. More...
class	CLI::ArgumentMismatch
	Thrown when the wrong number of arguments has been received. More...
class	CLI::RequiresError
	Thrown when a requires option is missing. More...
class	CLI::ExcludesError
	Thrown when an excludes option is present. More...
class	CLI::ExtrasError
	Thrown when too many positionals or options are found. More...
class	CLI::ConfigError
	Thrown when extra values are found in an INI file. More...
class	CLI::InvalidError
	Thrown when validation fails before parsing. More...
class	CLI::HorribleError
class	CLI::OptionNotFound
	Thrown when counting a non-existent option. More...
struct	CLI::make_void< Ts >
	A copy of std::void_t from C++17 (helper for C++11 and C++14) More...
struct	CLI::is_bool< T >
	Check to see if something is bool (fail check by default) More...
struct	CLI::is_bool< bool >
	Check to see if something is bool (true if actually a bool) More...
struct	CLI::is_shared_ptr< T >
	Check to see if something is a shared pointer. More...
struct	CLI::is_shared_ptr< std::shared_ptr< T > >
	Check to see if something is a shared pointer (True if really a shared pointer) More...
struct	CLI::is_shared_ptr< const std::shared_ptr< T > >
	Check to see if something is a shared pointer (True if really a shared pointer) More...
struct	CLI::is_copyable_ptr< T >
	Check to see if something is copyable pointer. More...
struct	CLI::IsMemberType< T >
	This can be specialized to override the type deduction for IsMember. More...
struct	CLI::IsMemberType< const char * >
	The main custom type needed here is const char * should be a string. More...
struct	CLI::detail::element_type< T, Enable >
	not a pointer More...
struct	CLI::detail::element_type< T, typename std::enable_if< is_copyable_ptr< T >::value >::type >
struct	CLI::detail::element_value_type< T >
struct	CLI::detail::pair_adaptor< T, _ >
	Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost nothing. More...
struct	CLI::detail::pair_adaptor< T, conditional_t< false, void_t< typename T::value_type::first_type, typename T::value_type::second_type >, void > >
class	CLI::detail::is_direct_constructible< T, C >
class	CLI::detail::is_ostreamable< T, S >
class	CLI::detail::is_istreamable< T, S >
	Check for input streamability. More...
class	CLI::detail::is_complex< T >
	Check for complex. More...
struct	CLI::detail::is_mutable_container< T, _ >
struct	CLI::detail::is_mutable_container< T, conditional_t< false, void_t< typename T::value_type, decltype(std::declval< T >().end()), decltype(std::declval< T >().clear()), decltype(std::declval< T >().insert(std::declval< decltype(std::declval< T >().end())>(), std::declval< const typename T::value_type & >()))>, void > >
struct	CLI::detail::is_readable_container< T, _ >
struct	CLI::detail::is_readable_container< T, conditional_t< false, void_t< decltype(std::declval< T >().end()), decltype(std::declval< T >().begin())>, void > >
struct	CLI::detail::is_wrapper< T, _ >
struct	CLI::detail::is_wrapper< T, conditional_t< false, void_t< typename T::value_type >, void > >
class	CLI::detail::is_tuple_like< S >
struct	CLI::detail::wrapped_type< T, def, Enable >
	template to get the underlying value type if it exists or use a default More...
struct	CLI::detail::wrapped_type< T, def, typename std::enable_if< is_wrapper< T >::value >::type >
	Type size for regular object types that do not look like a tuple. More...
struct	CLI::detail::type_count_base< T, Enable >
	This will only trigger for actual void type. More...
struct	CLI::detail::type_count_base< T, typename std::enable_if<!is_tuple_like< T >::value &&!is_mutable_container< T >::value &&!std::is_void< T >::value >::type >
	Type size for regular object types that do not look like a tuple. More...
struct	CLI::detail::type_count_base< T, typename std::enable_if< is_tuple_like< T >::value &&!is_mutable_container< T >::value >::type >
	the base tuple size More...
struct	CLI::detail::type_count_base< T, typename std::enable_if< is_mutable_container< T >::value >::type >
	Type count base for containers is the type_count_base of the individual element. More...
struct	CLI::detail::type_count< T, Enable >
	This will only trigger for actual void type. More...
struct	CLI::detail::type_count< T, typename std::enable_if<!is_wrapper< T >::value &&!is_tuple_like< T >::value &&!is_complex< T >::value &&!std::is_void< T >::value >::type >
	Type size for regular object types that do not look like a tuple. More...
struct	CLI::detail::type_count< T, typename std::enable_if< is_complex< T >::value >::type >
	Type size for complex since it sometimes looks like a wrapper. More...
struct	CLI::detail::type_count< T, typename std::enable_if< is_mutable_container< T >::value >::type >
	Type size of types that are wrappers,except complex and tuples(which can also be wrappers sometimes) More...
struct	CLI::detail::type_count< T, typename std::enable_if< is_wrapper< T >::value &&!is_complex< T >::value &&!is_tuple_like< T >::value &&!is_mutable_container< T >::value >::type >
	Type size of types that are wrappers,except containers complex and tuples(which can also be wrappers sometimes) More...
struct	CLI::ConfigItem
	Holds values to load into Options. More...
class	CLI::Config
	This class provides a converter for configuration files. More...
class	CLI::ConfigBase
	This converter works with INI/TOML files; to write INI files use ConfigINI. More...
class	CLI::ConfigINI
	ConfigINI generates a "standard" INI compliant output. More...
class	CLI::Validator
	Some validators that are provided. More...
class	CLI::CustomValidator
	Class wrapping some of the accessors of Validator. More...
class	CLI::detail::ExistingFileValidator
	Check for an existing file (returns error message if check fails) More...
class	CLI::detail::ExistingDirectoryValidator
	Check for an existing directory (returns error message if check fails) More...
class	CLI::detail::ExistingPathValidator
	Check for an existing path. More...
class	CLI::detail::NonexistentPathValidator
	Check for an non-existing path. More...
class	CLI::detail::IPV4Validator
	Validate the given string is a legal ipv4 address. More...
class	CLI::TypeValidator< DesiredType >
	Validate the input as a particular type. More...
class	CLI::Range
	Produce a range (factory). Min and max are inclusive. More...
class	CLI::Bound
	Produce a bounded range (factory). Min and max are inclusive. More...
struct	CLI::detail::has_find< C, V >
class	CLI::IsMember
	Verify items are in a set. More...
class	CLI::Transformer
	Translate named items to other or a value set. More...
class	CLI::CheckedTransformer
	translate named items to other or a value set More...
class	CLI::AsNumberWithUnit
class	CLI::AsSizeValue
class	CLI::FormatterBase
class	CLI::FormatterLambda
	This is a specialty override for lambda functions. More...
class	CLI::Formatter
class	CLI::OptionBase< CRTP >
class	CLI::OptionDefaults
class	CLI::Option
class	CLI::App
	Creates a command line program, with very few defaults. More...
class	CLI::Option_group
	Extension of App to better manage groups of options. More...
struct	CLI::detail::AppFriend
	This class is simply to allow tests access to App's protected functions. More...

Namespaces
namespace	CLI
namespace	CLI::enums
namespace	CLI::detail
namespace	CLI::FailureMessage

Macros
#define	CLI11_VERSION_MAJOR   2
#define	CLI11_VERSION_MINOR   1
#define	CLI11_VERSION_PATCH   2
#define	CLI11_VERSION   "2.1.2"
#define	CLI11_DEPRECATED(reason)   __attribute__((deprecated(reason)))
#define	CLI11_ERROR_DEF(parent, name)
#define	CLI11_ERROR_SIMPLE(name)    explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}
#define	CLI11_PARSE(app, argc, argv)

Typedefs
template<bool B, class T = void>
using	CLI::enable_if_t = typename std::enable_if< B, T >::type
template<typename... Ts>
using	CLI::void_t = typename make_void< Ts... >::type
	A copy of std::void_t from C++17 - same reasoning as enable_if_t, it does not hurt to redefine.
template<bool B, class T , class F >
using	CLI::conditional_t = typename std::conditional< B, T, F >::type
	A copy of std::conditional_t from C++14 - same reasoning as enable_if_t, it does not hurt to redefine.
using	CLI::ConfigTOML = ConfigBase
	the default Config is the TOML file format
using	CLI::results_t = std::vector< std::string >
using	CLI::callback_t = std::function< bool(const results_t &)>
	callback function definition
using	CLI::Option_p = std::unique_ptr< Option >
using	CLI::App_p = std::shared_ptr< App >

Enumerations
enum class	CLI::ExitCodes {   CLI::Success = 0 , CLI::IncorrectConstruction = 100 , CLI::BadNameString , CLI::OptionAlreadyAdded ,   CLI::FileError , CLI::ConversionError , CLI::ValidationError , CLI::RequiredError ,   CLI::RequiresError , CLI::ExcludesError , CLI::ExtrasError , CLI::ConfigError ,   CLI::InvalidError , CLI::HorribleError , CLI::OptionNotFound , CLI::ArgumentMismatch ,   CLI::BaseClass = 127 }
enum class	CLI::detail::enabler
	Simple empty scoped class. More...
enum class	CLI::detail::path_type { CLI::detail::nonexistent , CLI::detail::file , CLI::detail::directory }
	CLI enumeration of different file types. More...
enum class	CLI::AppFormatMode { CLI::Normal , CLI::All , CLI::Sub }
enum class	CLI::MultiOptionPolicy : char {   CLI::Throw , CLI::TakeLast , CLI::TakeFirst , CLI::Join ,   CLI::TakeAll }
	Enumeration of the multiOption Policy selection. More...
enum class	CLI::detail::Classifier {   CLI::detail::NONE , CLI::detail::POSITIONAL_MARK , CLI::detail::SHORT , CLI::detail::LONG ,   CLI::detail::WINDOWS_STYLE , CLI::detail::SUBCOMMAND , CLI::detail::SUBCOMMAND_TERMINATOR }
enum class	CLI::config_extras_mode : char { CLI::error = 0 , CLI::ignore , CLI::ignore_all , CLI::capture }
	enumeration of modes of how to deal with extras in config files More...

Functions
template<typename T , typename = typename std::enable_if<std::is_enum<T>::value>::type>
std::ostream &	CLI::enums::operator<< (std::ostream &in, const T &item)
	output streaming for enumerations
std::vector< std::string >	CLI::detail::split (const std::string &s, char delim)
	Split a string by a delim.
template<typename T >
std::string	CLI::detail::join (const T &v, std::string delim=",")
	Simple function to join a string.
template<typename T , typename Callable , typename = typename std::enable_if<!std::is_constructible<std::string, Callable>::value>::type>
std::string	CLI::detail::join (const T &v, Callable func, std::string delim=",")
	Simple function to join a string from processed elements.
template<typename T >
std::string	CLI::detail::rjoin (const T &v, std::string delim=",")
	Join a string in reverse order.
std::string &	CLI::detail::ltrim (std::string &str)
	Trim whitespace from left of string.
std::string &	CLI::detail::ltrim (std::string &str, const std::string &filter)
	Trim anything from left of string.
std::string &	CLI::detail::rtrim (std::string &str)
	Trim whitespace from right of string.
std::string &	CLI::detail::rtrim (std::string &str, const std::string &filter)
	Trim anything from right of string.
std::string &	CLI::detail::trim (std::string &str)
	Trim whitespace from string.
std::string &	CLI::detail::trim (std::string &str, const std::string filter)
	Trim anything from string.
std::string	CLI::detail::trim_copy (const std::string &str)
	Make a copy of the string and then trim it.
std::string &	CLI::detail::remove_quotes (std::string &str)
	remove quotes at the front and back of a string either '"' or '\''
std::string	CLI::detail::fix_newlines (const std::string &leader, std::string input)
std::string	CLI::detail::trim_copy (const std::string &str, const std::string &filter)
	Make a copy of the string and then trim it, any filter string can be used (any char in string is filtered)
std::ostream &	CLI::detail::format_help (std::ostream &out, std::string name, const std::string &description, std::size_t wid)
	Print a two part "help" string.
std::ostream &	CLI::detail::format_aliases (std::ostream &out, const std::vector< std::string > &aliases, std::size_t wid)
	Print subcommand aliases.
template<typename T >
bool	CLI::detail::valid_first_char (T c)
template<typename T >
bool	CLI::detail::valid_later_char (T c)
	Verify following characters of an option.
bool	CLI::detail::valid_name_string (const std::string &str)
	Verify an option/subcommand name.
bool	CLI::detail::valid_alias_name_string (const std::string &str)
	Verify an app name.
bool	CLI::detail::is_separator (const std::string &str)
	check if a string is a container segment separator (empty or "%%")
bool	CLI::detail::isalpha (const std::string &str)
	Verify that str consists of letters only.
std::string	CLI::detail::to_lower (std::string str)
	Return a lower case version of a string.
std::string	CLI::detail::remove_underscore (std::string str)
	remove underscores from a string
std::string	CLI::detail::find_and_replace (std::string str, std::string from, std::string to)
	Find and replace a substring with another substring.
bool	CLI::detail::has_default_flag_values (const std::string &flags)
	check if the flag definitions has possible false flags
void	CLI::detail::remove_default_flag_values (std::string &flags)
std::ptrdiff_t	CLI::detail::find_member (std::string name, const std::vector< std::string > names, bool ignore_case=false, bool ignore_underscore=false)
	Check if a string is a member of a list of strings and optionally ignore case or ignore underscores.
template<typename Callable >
std::string	CLI::detail::find_and_modify (std::string str, std::string trigger, Callable modify)
std::vector< std::string >	CLI::detail::split_up (std::string str, char delimiter='\0')
std::size_t	CLI::detail::escape_detect (std::string &str, std::size_t offset)
std::string &	CLI::detail::add_quotes_if_needed (std::string &str)
	Add quotes if the string contains spaces.
template<typename T , enable_if_t< is_istreamable< T >::value, detail::enabler > = detail::dummy>
bool	CLI::detail::from_stream (const std::string &istring, T &obj)
	Templated operation to get a value from a stream.
template<typename T , enable_if_t< std::is_convertible< T, std::string >::value, detail::enabler > = detail::dummy>
auto	CLI::detail::to_string (T &&value) -> decltype(std::forward< T >(value))
	Convert an object to a string (directly forward if this can become a string)
template<typename T , enable_if_t< std::is_constructible< std::string, T >::value &&!std::is_convertible< T, std::string >::value, detail::enabler > = detail::dummy>
std::string	CLI::detail::to_string (const T &value)
	Construct a string from the object.
template<typename T , enable_if_t<!std::is_convertible< std::string, T >::value &&!std::is_constructible< std::string, T >::value &&is_ostreamable< T >::value, detail::enabler > = detail::dummy>
std::string	CLI::detail::to_string (T &&value)
	Convert an object to a string (streaming must be supported for that type)
template<typename T1 , typename T2 , typename T , enable_if_t< std::is_same< T1, T2 >::value, detail::enabler > = detail::dummy>
auto	CLI::detail::checked_to_string (T &&value) -> decltype(to_string(std::forward< T >(value)))
	special template overload
template<typename T1 , typename T2 , typename T , enable_if_t<!std::is_same< T1, T2 >::value, detail::enabler > = detail::dummy>
std::string	CLI::detail::checked_to_string (T &&)
	special template overload
template<typename T , enable_if_t< std::is_arithmetic< T >::value, detail::enabler > = detail::dummy>
std::string	CLI::detail::value_string (const T &value)
	get a string as a convertible value for arithmetic types
template<typename T , enable_if_t<!std::is_enum< T >::value &&!std::is_arithmetic< T >::value, detail::enabler > = detail::dummy>
auto	CLI::detail::value_string (const T &value) -> decltype(to_string(value))
	for other types just use the regular to_string function
template<typename T , std::size_t I>
constexpr std::enable_if< I==type_count_base< T >::value, int >::type	CLI::detail::tuple_type_size ()
	0 if the index > tuple size
	CLI::detail::if (str.back()==',') str.pop_back()
template<typename T , enable_if_t< classify_object< T >::value==object_category::tuple_value &&type_count_base< T >::value > = 2, detail::enabler >
std::string	CLI::detail::type_name ()
	Print type name for tuples with 2 or more elements.
template<typename T , enable_if_t< classify_object< T >::value==object_category::container_value||classify_object< T >::value==object_category::wrapper_value, detail::enabler > >
std::string	CLI::detail::type_name ()
	get the type name for a type that has a value_type member
template<typename T , enable_if_t< std::is_unsigned< T >::value, detail::enabler > = detail::dummy>
bool	CLI::detail::integral_conversion (const std::string &input, T &output) noexcept
	Convert to an unsigned integral.
std::int64_t	CLI::detail::to_flag_value (std::string val)
	Convert a flag into an integer value typically binary flags.
template<typename T , enable_if_t< classify_object< T >::value==object_category::integral_value||classify_object< T >::value==object_category::unsigned_integral, detail::enabler > = detail::dummy>
bool	CLI::detail::lexical_cast (const std::string &input, T &output)
	Integer conversion.
template<typename AssignTo , typename ConvertTo , enable_if_t< std::is_same< AssignTo, ConvertTo >::value &&(classify_object< AssignTo >::value==object_category::string_assignable||classify_object< AssignTo >::value==object_category::string_constructible), detail::enabler > = detail::dummy>
bool	CLI::detail::lexical_assign (const std::string &input, AssignTo &output)
	Assign a value through lexical cast operations.
bool	CLI::detail::split_short (const std::string &current, std::string &name, std::string &rest)
bool	CLI::detail::split_long (const std::string &current, std::string &name, std::string &value)
bool	CLI::detail::split_windows_style (const std::string &current, std::string &name, std::string &value)
std::vector< std::string >	CLI::detail::split_names (std::string current)
std::vector< std::pair< std::string, std::string > >	CLI::detail::get_default_flag_values (const std::string &str)
	extract default flag values either {def} or starting with a !
std::tuple< std::vector< std::string >, std::vector< std::string >, std::string >	CLI::detail::get_names (const std::vector< std::string > &input)
	Get a vector of short names, one of long names, and a single name.
path_type	CLI::detail::check_path (const char *file) noexcept
	get the type of the path from a file name
template<typename T , enable_if_t< is_copyable_ptr< typename std::remove_reference< T >::type >::value, detail::enabler > = detail::dummy>
auto	CLI::detail::smart_deref (T value) -> decltype(*value)
template<typename T , enable_if_t<!is_copyable_ptr< typename std::remove_reference< T >::type >::value, detail::enabler > = detail::dummy>
std::remove_reference< T >::type &	CLI::detail::smart_deref (T &value)
template<typename T >
std::string	CLI::detail::generate_set (const T &set)
	Generate a string representation of a set.
template<typename T >
std::string	CLI::detail::generate_map (const T &map, bool key_only=false)
	Generate a string representation of a map.
template<typename T , typename V , enable_if_t<!has_find< T, V >::value, detail::enabler > = detail::dummy>
auto	CLI::detail::search (const T &set, const V &val) -> std::pair< bool, decltype(std::begin(detail::smart_deref(set)))>
	A search function.
template<typename T , typename V >
auto	CLI::detail::search (const T &set, const V &val, const std::function< V(V)> &filter_function) -> std::pair< bool, decltype(std::begin(detail::smart_deref(set)))>
	A search function with a filter function.
template<typename T >
std::enable_if< std::is_signed< T >::value, T >::type	CLI::detail::overflowCheck (const T &a, const T &b)
	Do a check for overflow on signed numbers.
template<typename T >
std::enable_if<!std::is_signed< T >::value, T >::type	CLI::detail::overflowCheck (const T &a, const T &b)
	Do a check for overflow on unsigned numbers.
template<typename T >
std::enable_if< std::is_integral< T >::value, bool >::type	CLI::detail::checked_multiply (T &a, T b)
	Performs a *= b; if it doesn't cause integer overflow. Returns false otherwise.
template<typename T >
std::enable_if< std::is_floating_point< T >::value, bool >::type	CLI::detail::checked_multiply (T &a, T b)
	Performs a *= b; if it doesn't equal infinity. Returns false otherwise.
std::pair< std::string, std::string >	CLI::detail::split_program_name (std::string commandline)
std::string	CLI::FailureMessage::simple (const App *app, const Error &e)
	Printout a clean, simple message on error (the default in CLI11 1.5+)
std::string	CLI::FailureMessage::help (const App *app, const Error &e)
	Printout the full help string on error (if this fn is set, the old default for CLI11)
void	CLI::TriggerOn (App *trigger_app, App *app_to_enable)
	Helper function to enable one option group/subcommand when another is used.
void	CLI::TriggerOn (App *trigger_app, std::vector< App * > apps_to_enable)
	Helper function to enable one option group/subcommand when another is used.
void	CLI::TriggerOff (App *trigger_app, App *app_to_enable)
	Helper function to disable one option group/subcommand when another is used.
void	CLI::TriggerOff (App *trigger_app, std::vector< App * > apps_to_enable)
	Helper function to disable one option group/subcommand when another is used.
void	CLI::deprecate_option (Option *opt, const std::string &replacement="")
	Helper function to mark an option as deprecated.
void	CLI::deprecate_option (App *app, const std::string &option_name, const std::string &replacement="")
	Helper function to mark an option as deprecated.
void	CLI::deprecate_option (App &app, const std::string &option_name, const std::string &replacement="")
	Helper function to mark an option as deprecated.
void	CLI::retire_option (App *app, Option *opt)
	Helper function to mark an option as retired.
void	CLI::retire_option (App &app, Option *opt)
	Helper function to mark an option as retired.
void	CLI::retire_option (App *app, const std::string &option_name)
	Helper function to mark an option as retired.
void	CLI::retire_option (App &app, const std::string &option_name)
	Helper function to mark an option as retired.
std::string	CLI::detail::convert_arg_for_ini (const std::string &arg, char stringQuote='"', char characterQuote = '\'')
std::string	CLI::detail::ini_join (const std::vector< std::string > &args, char sepChar=',', char arrayStart='[', char arrayEnd=']', char stringQuote='"', char characterQuote = '\'')
	Comma separated join, adds quotes if needed.
std::vector< std::string >	CLI::detail::generate_parents (const std::string &section, std::string &name, char parentSeparator)
void	CLI::detail::checkParentSegments (std::vector< ConfigItem > &output, const std::string &currentSection, char parentSeparator)
	assuming non default segments do a check on the close and open of the segments in a configItem structure

Variables
constexpr int	CLI::detail::expected_max_vector_size {1 << 29}
constexpr enabler	CLI::detail::dummy = {}
	An instance to use in EnableIf.
return	CLI::detail::str
template<typename T >
using	CLI::TransformPairs = std::vector< std::pair< std::string, T > >
	definition of the default transformation object
const detail::ExistingFileValidator	CLI::ExistingFile
	Check for existing file (returns error message if check fails)
const detail::ExistingDirectoryValidator	CLI::ExistingDirectory
	Check for an existing directory (returns error message if check fails)
const detail::ExistingPathValidator	CLI::ExistingPath
	Check for an existing path.
const detail::NonexistentPathValidator	CLI::NonexistentPath
	Check for an non-existing path.
const detail::IPV4Validator	CLI::ValidIPV4
	Check for an IP4 address.
const TypeValidator< double >	CLI::Number ("NUMBER")
	Check for a number.
const Range	CLI::NonNegativeNumber ((std::numeric_limits< double >::max)(), "NONNEGATIVE")
	Check for a non negative number.
const Range	CLI::PositiveNumber ((std::numeric_limits< double >::min)(),(std::numeric_limits< double >::max)(), "POSITIVE")
	Check for a positive valued number (val>0.0), min() her is the smallest positive number.
std::string	CLI::ignore_case (std::string item)
	Helper function to allow ignore_case to be passed to IsMember or Transform.
std::string	CLI::ignore_underscore (std::string item)
	Helper function to allow ignore_underscore to be passed to IsMember or Transform.
std::string	CLI::ignore_space (std::string item)
	Helper function to allow checks to ignore spaces to be passed to IsMember or Transform.

Macro Definition Documentation

CLI11_DEPRECATED

#define CLI11_DEPRECATED

(

reason

)

__attribute__((deprecated(reason)))

CLI11_ERROR_DEF

#define CLI11_ERROR_DEF	(		parent,
			name
	)

Value:

  protected:                                                                                                           \
    name(std::string ename, std::string msg, int exit_code) : parent(std::move(ename), std::move(msg), exit_code) {}   \
    name(std::string ename, std::string msg, ExitCodes exit_code)                                                      \
        : parent(std::move(ename), std::move(msg), exit_code) {}                                                       \
                                                                                                                       \
  public:                                                                                                              \
    name(std::string msg, ExitCodes exit_code) : parent(#name, std::move(msg), exit_code) {}                           \
    name(std::string msg, int exit_code) : parent(#name, std::move(msg), exit_code) {}

CLI11_ERROR_SIMPLE

#define CLI11_ERROR_SIMPLE

(

name

)

explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}

CLI11_PARSE

#define CLI11_PARSE	(		app,
			argc,
			argv
	)

Value:

    try {                                                                                                              \
        (app).parse((argc), (argv));                                                                                   \
    } catch(const CLI::ParseError &e) {                                                                                \
        return (app).exit(e);                                                                                          \
    }

CLI11_VERSION

#define CLI11_VERSION   "2.1.2"

CLI11_VERSION_MAJOR

#define CLI11_VERSION_MAJOR   2

CLI11_VERSION_MINOR

#define CLI11_VERSION_MINOR   1

CLI11_VERSION_PATCH

#define CLI11_VERSION_PATCH   2