CLI::detail Namespace Reference

Classes
struct	AppFriend
	This class is simply to allow tests access to App's protected functions. More...
struct	classify_object
	some type that is not otherwise recognized More...
struct	classify_object< T, typename std::enable_if< is_bool< T >::value >::type >
	Boolean values. More...
struct	classify_object< T, typename std::enable_if< is_vector< T >::value >::type >
	Vector type. More...
struct	classify_object< T, typename std::enable_if< std::is_enum< T >::value >::type >
	Enumerations. More...
struct	classify_object< T, typename std::enable_if< std::is_floating_point< T >::value >::type >
	Floats. More...
struct	classify_object< T, typename std::enable_if< std::is_integral< T >::value &&std::is_signed< T >::value &&!is_bool< T >::value &&!std::is_enum< T >::value >::type >
	Set of overloads to classify an object according to type. More...
struct	classify_object< T, typename std::enable_if< std::is_integral< T >::value &&std::is_unsigned< T >::value &&!is_bool< T >::value >::type >
	Unsigned integers. More...
struct	classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&!is_direct_constructible< T, double >::value &&is_direct_constructible< T, int >::value >::type >
	Assignable from int. More...
struct	classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&is_direct_constructible< T, double >::value &&!is_direct_constructible< T, int >::value >::type >
	Assignable from double. More...
struct	classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&is_direct_constructible< T, double >::value &&is_direct_constructible< T, int >::value >::type >
	Assignable from double or int. More...
struct	classify_object< T, typename std::enable_if<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&!std::is_assignable< T &, std::string >::value &&std::is_constructible< T, std::string >::value &&!is_vector< T >::value >::type >
	String and similar constructible and copy assignment. More...
struct	classify_object< T, typename std::enable_if<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&std::is_assignable< T &, std::string >::value &&!is_vector< T >::value >::type >
	String and similar direct assignment. More...
struct	classify_object< T, typename std::enable_if<(type_count< T >::value >=2 &&!is_vector< T >::value)||(is_tuple_like< T >::value &&uncommon_type< T >::value &&!is_direct_constructible< T, double >::value &&!is_direct_constructible< T, int >::value)>::type >
	Tuple type. More...
struct	element_type
	not a pointer More...
struct	element_type< T, typename std::enable_if< is_copyable_ptr< T >::value >::type >
struct	element_value_type
class	ExistingDirectoryValidator
	Check for an existing directory (returns error message if check fails) More...
class	ExistingFileValidator
	Check for an existing file (returns error message if check fails) More...
class	ExistingPathValidator
	Check for an existing path. More...
struct	expected_count
	This will only trigger for actual void type. More...
struct	expected_count< T, typename std::enable_if< is_vector< T >::value >::type >
	number of expected items in a vector More...
struct	expected_count< T, typename std::enable_if<!is_vector< T >::value &&!std::is_void< T >::value >::type >
	For most types the number of expected items is 1. More...
struct	has_find
class	IPV4Validator
	Validate the given string is a legal ipv4 address. More...
class	is_direct_constructible
class	is_istreamable
	Check for input streamability. More...
class	is_ostreamable
class	is_tuple_like
class	NonexistentPathValidator
	Check for an non-existing path. More...
class	NonNegativeNumber
	Validate the argument is a number and greater than or equal to 0. More...
class	Number
	Validate the argument is a number. More...
struct	pair_adaptor
	Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost nothing. More...
struct	pair_adaptor< T, conditional_t< false, void_t< typename T::value_type::first_type, typename T::value_type::second_type >, void > >
class	PositiveNumber
	Validate the argument is a number and greater than 0. More...
struct	type_count
	This will only trigger for actual void type. More...
struct	type_count< T, typename std::enable_if< is_tuple_like< T >::value >::type >
	Set of overloads to get the type size of an object. More...
struct	type_count< T, typename std::enable_if< is_vector< T >::value >::type >
	Type size of types that look like a vector. More...
struct	type_count< T, typename std::enable_if<!is_vector< T >::value &&!is_tuple_like< T >::value &&!std::is_void< T >::value >::type >
	Type size for regular object types that do not look like a tuple. More...
struct	uncommon_type

Enumerations
enum class	enabler
	Simple empty scoped class. More...
enum class	object_category : int {   integral_value = 2 , unsigned_integral = 4 , enumeration = 6 , boolean_value = 8 ,   floating_point = 10 , number_constructible = 12 , double_constructible = 14 , integer_constructible = 16 ,   vector_value = 30 , tuple_value = 35 , string_assignable = 50 , string_constructible = 60 ,   other = 200 }
enum class	path_type { nonexistant , file , directory }
	CLI enumeration of different file types. More...
enum class	Classifier {   NONE , POSITIONAL_MARK , SHORT , LONG ,   WINDOWS , SUBCOMMAND , SUBCOMMAND_TERMINATOR }

Functions
std::vector< std::string >	split (const std::string &s, char delim)
	Split a string by a delim.
template<typename T >
std::string	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	join (const T &v, Callable func, std::string delim=",")
	Simple function to join a string from processed elements.
template<typename T >
std::string	rjoin (const T &v, std::string delim=",")
	Join a string in reverse order.
std::string &	ltrim (std::string &str)
	Trim whitespace from left of string.
std::string &	ltrim (std::string &str, const std::string &filter)
	Trim anything from left of string.
std::string &	rtrim (std::string &str)
	Trim whitespace from right of string.
std::string &	rtrim (std::string &str, const std::string &filter)
	Trim anything from right of string.
std::string &	trim (std::string &str)
	Trim whitespace from string.
std::string &	trim (std::string &str, const std::string filter)
	Trim anything from string.
std::string	trim_copy (const std::string &str)
	Make a copy of the string and then trim it.
std::string &	remove_quotes (std::string &str)
	remove quotes at the front and back of a string either '"' or '\''
std::string	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 &	format_help (std::ostream &out, std::string name, std::string description, std::size_t wid)
	Print a two part "help" string.
template<typename T >
bool	valid_first_char (T c)
	Verify the first character of an option.
template<typename T >
bool	valid_later_char (T c)
	Verify following characters of an option.
bool	valid_name_string (const std::string &str)
	Verify an option name.
bool	isalpha (const std::string &str)
	Verify that str consists of letters only.
std::string	to_lower (std::string str)
	Return a lower case version of a string.
std::string	remove_underscore (std::string str)
	remove underscores from a string
std::string	find_and_replace (std::string str, std::string from, std::string to)
	Find and replace a substring with another substring.
bool	has_default_flag_values (const std::string &flags)
	check if the flag definitions has possible false flags
void	remove_default_flag_values (std::string &flags)
std::ptrdiff_t	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	find_and_modify (std::string str, std::string trigger, Callable modify)
	trim (str)
	while (!str.empty())
template<typename T , enable_if_t< is_istreamable< T >::value, detail::enabler > = detail::dummy>
bool	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_constructible< std::string, T >::value, detail::enabler > = detail::dummy>
auto	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 &&is_ostreamable< T >::value, detail::enabler > = detail::dummy>
std::string	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	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	checked_to_string (T &&)
	special template overload
template<typename T , enable_if_t< std::is_arithmetic< T >::value, detail::enabler > = detail::dummy>
std::string	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	value_string (const T &value) -> decltype(to_string(value))
	for other types just use the regular to_string function
template<typename T , enable_if_t< classify_object< T >::value==object_category::integral_value||classify_object< T >::value==object_category::integer_constructible, detail::enabler > = detail::dummy>
constexpr const char *	type_name ()
	Print name for enumeration types.
std::size_t I std::enable_if< I==type_count< T >::value, std::string >::type	tuple_name ()
	if (str.back()==',') str.pop_back()
std::size_t I inline typename bool ::type	tuple_conversion (const std::vector< std::string > &, T &)
template<class T , class XC , enable_if_t< is_tuple_like< T >::value, detail::enabler > = detail::dummy>
bool	lexical_conversion (const std::vector< std ::string > &strings, T &output)
	Conversion for tuples.
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)
bool	split_short (const std::string &current, std::string &name, std::string &rest)
bool	split_long (const std::string &current, std::string &name, std::string &value)
bool	split_windows_style (const std::string &current, std::string &name, std::string &value)
std::vector< std::string >	split_names (std::string current)
std::vector< std::pair< std::string, std::string > >	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 >	get_names (const std::vector< std::string > &input)
	Get a vector of short names, one of long names, and a single name.
path_type	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	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 &	smart_deref (T &value)
template<typename T >
std::string	generate_set (const T &set)
	Generate a string representation of a set.
template<typename T >
std::string	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	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	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	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	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	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	checked_multiply (T &a, T b)
	Performs a *= b; if it doesn't equal infinity. Returns false otherwise.
std::pair< std::string, std::string >	split_program_name (std::string commandline)
std::string	convert_arg_for_ini (const std::string &arg)
std::string	ini_join (const std::vector< std::string > &args, char sepChar=',', char arrayStart='[', char arrayEnd=']')
	Comma separated join, adds quotes if needed.
std::vector< std::string >	generate_parents (const std::string &section, std::string &name)
void	checkParentSegments (std::vector< ConfigItem > &output, const std::string &currentSection)
	assuming non default segments do a check on the close and open of the segments in a configItem structure

Variables
constexpr int	expected_max_vector_size {1 << 29}
auto	find_ws
std::vector< std::string >	output
bool	embeddedQuote = false
char	keyChar = ' '
constexpr enabler	dummy = {}
	An instance to use in EnableIf.
return	str
	XC
return	retval

Enumeration Type Documentation

Classifier

enum class CLI::detail::Classifier

strong

Enumerator
NONE
POSITIONAL_MARK
SHORT
LONG
WINDOWS
SUBCOMMAND
SUBCOMMAND_TERMINATOR

Definition at line 4592 of file CLI11.hpp.

{ NONE, POSITIONAL_MARK, SHORT, LONG, WINDOWS, SUBCOMMAND, SUBCOMMAND_TERMINATOR };

enabler

enum class CLI::detail::enabler

strong

Definition at line 853 of file CLI11.hpp.

{};

object_category

enum class CLI::detail::object_category : int

strong

Enumerator
integral_value
unsigned_integral
enumeration
boolean_value
floating_point
number_constructible
double_constructible
integer_constructible
vector_value
tuple_value
string_assignable
string_constructible
other

Definition at line 1162 of file CLI11.hpp.

                           : int {
    integral_value = 2,
    unsigned_integral = 4,
    enumeration = 6,
    boolean_value = 8,
    floating_point = 10,
    number_constructible = 12,
    double_constructible = 14,
    integer_constructible = 16,
    vector_value = 30,
    tuple_value = 35,
    // string assignable or greater used in a condition so anything string like must come last
    string_assignable = 50,
    string_constructible = 60,
    other = 200,
 
};

path_type

enum class CLI::detail::path_type

strong

Enumerator
nonexistant
file
directory

Definition at line 2307 of file CLI11.hpp.

{ nonexistant, file, directory };

Function Documentation

check_path()

path_type CLI::detail::check_path ( const char * file )

inlinenoexcept

Definition at line 2336 of file CLI11.hpp.

                                                       {
#if defined(_MSC_VER)
    struct __stat64 buffer;
    if(_stat64(file, &buffer) == 0) {
        return ((buffer.st_mode & S_IFDIR) != 0) ? path_type::directory : path_type::file;
    }
#else
    struct stat buffer;
    if(stat(file, &buffer) == 0) {
        return ((buffer.st_mode & S_IFDIR) != 0) ? path_type::directory : path_type::file;
    }
#endif
    return path_type::nonexistant;
}

Here is the caller graph for this function:

checked_multiply() [1/2]

template<typename T >

std::enable_if< std::is_integral< T >::value, bool >::type CLI::detail::checked_multiply	(	T &	a,
		T	b )

Definition at line 2684 of file CLI11.hpp.

                                                                                                          {
    if(a == 0 || b == 0 || a == 1 || b == 1) {
        a *= b;
        return true;
    }
    if(a == (std::numeric_limits<T>::min)() || b == (std::numeric_limits<T>::min)()) {
        return false;
    }
    if(overflowCheck(a, b)) {
        return false;
    }
    a *= b;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

checked_multiply() [2/2]

template<typename T >

std::enable_if< std::is_floating_point< T >::value, bool >::type CLI::detail::checked_multiply	(	T &	a,
		T	b )

Definition at line 2701 of file CLI11.hpp.

                                                                                          {
    T c = a * b;
    if(std::isinf(c) && !std::isinf(a) && !std::isinf(b)) {
        return false;
    }
    a = c;
    return true;
}

checked_to_string() [1/2]

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 &&

)

Definition at line 1107 of file CLI11.hpp.

                                  {
    return std::string{};
}

checked_to_string() [2/2]

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)))

Definition at line 1098 of file CLI11.hpp.

                                                                               {
    return to_string(std::forward<T>(value));
}

Here is the call graph for this function:

Here is the caller graph for this function:

checkParentSegments()

void CLI::detail::checkParentSegments ( std::vector< ConfigItem > & output, const std::string & currentSection )

inline

Definition at line 7723 of file CLI11.hpp.

                                                                                                {
 
    std::string estring;
    auto parents = detail::generate_parents(currentSection, estring);
    if(!output.empty() && output.back().name == "--") {
        std::size_t msize = (parents.size() > 1U) ? parents.size() : 2;
        while(output.back().parents.size() >= msize) {
            output.push_back(output.back());
            output.back().parents.pop_back();
        }
 
        if(parents.size() > 1) {
            std::size_t common = 0;
            std::size_t mpair = (std::min)(output.back().parents.size(), parents.size() - 1);
            for(std::size_t ii = 0; ii < mpair; ++ii) {
                if(output.back().parents[ii] != parents[ii]) {
                    break;
                }
                ++common;
            }
            if(common == mpair) {
                output.pop_back();
            } else {
                while(output.back().parents.size() > common + 1) {
                    output.push_back(output.back());
                    output.back().parents.pop_back();
                }
            }
            for(std::size_t ii = common; ii < parents.size() - 1; ++ii) {
                output.emplace_back();
                output.back().parents.assign(parents.begin(), parents.begin() + static_cast<std::ptrdiff_t>(ii) + 1);
                output.back().name = "++";
            }
        }
    } else if(parents.size() > 1) {
        for(std::size_t ii = 0; ii < parents.size() - 1; ++ii) {
            output.emplace_back();
            output.back().parents.assign(parents.begin(), parents.begin() + static_cast<std::ptrdiff_t>(ii) + 1);
            output.back().name = "++";
        }
    }
 
    // insert a section end which is just an empty items_buffer
    output.emplace_back();
    output.back().parents = std::move(parents);
    output.back().name = "++";
}

Here is the call graph for this function:

Here is the caller graph for this function:

convert_arg_for_ini()

std::string CLI::detail::convert_arg_for_ini ( const std::string & arg )

inline

Definition at line 7631 of file CLI11.hpp.

                                                           {
    if(arg.empty()) {
        return std::string(2, '"');
    }
    // some specifically supported strings
    if(arg == "true" || arg == "false" || arg == "nan" || arg == "inf") {
        return arg;
    }
    // floating point conversion can convert some hex codes, but don't try that here
    if(arg.compare(0, 2, "0x") != 0 && arg.compare(0, 2, "0X") != 0) {
        double val;
        if(detail::lexical_cast(arg, val)) {
            return arg;
        }
    }
    // just quote a single non numeric character
    if(arg.size() == 1) {
        return std::string("'") + arg + '\'';
    }
    // handle hex, binary or octal arguments
    if(arg.front() == '0') {
        if(arg[1] == 'x') {
            if(std::all_of(arg.begin() + 2, arg.end(), [](char x) {
                   return (x >= '0' && x <= '9') || (x >= 'A' && x <= 'F') || (x >= 'a' && x <= 'f');
               })) {
                return arg;
            }
        } else if(arg[1] == 'o') {
            if(std::all_of(arg.begin() + 2, arg.end(), [](char x) { return (x >= '0' && x <= '7'); })) {
                return arg;
            }
        } else if(arg[1] == 'b') {
            if(std::all_of(arg.begin() + 2, arg.end(), [](char x) { return (x == '0' || x == '1'); })) {
                return arg;
            }
        }
    }
    if(arg.find_first_of('"') == std::string::npos) {
        return std::string("\"") + arg + '"';
    } else {
        return std::string("'") + arg + '\'';
    }
}

Here is the caller graph for this function:

find_and_modify()

template<typename Callable >

std::string CLI::detail::find_and_modify ( std::string str, std::string trigger, Callable modify )

inline

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

Definition at line 412 of file CLI11.hpp.

                                                                                                                 {
    std::size_t start_pos = 0;
    while((start_pos = str.find(trigger, start_pos)) != std::string::npos) {
        start_pos = modify(str, start_pos);
    }
    return str;
}

Here is the caller graph for this function:

find_and_replace()

std::string CLI::detail::find_and_replace ( std::string str, std::string from, std::string to )

inline

Definition at line 350 of file CLI11.hpp.

                                                                               {
 
    std::size_t start_pos = 0;
 
    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length();
    }
 
    return str;
}

Here is the caller graph for this function:

find_member()

std::ptrdiff_t CLI::detail::find_member ( std::string name, const std::vector< std::string > names, bool ignore_case = false, bool ignore_underscore = false )

inline

Definition at line 381 of file CLI11.hpp.

                                                                  {
    auto it = std::end(names);
    if(ignore_case) {
        if(ignore_underscore) {
            name = detail::to_lower(detail::remove_underscore(name));
            it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
                return detail::to_lower(detail::remove_underscore(local_name)) == name;
            });
        } else {
            name = detail::to_lower(name);
            it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
                return detail::to_lower(local_name) == name;
            });
        }
 
    } else if(ignore_underscore) {
        name = detail::remove_underscore(name);
        it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
            return detail::remove_underscore(local_name) == name;
        });
    } else
        it = std::find(std::begin(names), std::end(names), name);
 
    return (it != std::end(names)) ? (it - std::begin(names)) : (-1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

format_help()

std::ostream & CLI::detail::format_help ( std::ostream & out, std::string name, std::string description, std::size_t wid )

inline

Definition at line 295 of file CLI11.hpp.

                                                                                                      {
    name = "  " + name;
    out << std::setw(static_cast<int>(wid)) << std::left << name;
    if(!description.empty()) {
        if(name.length() >= wid)
            out << "\n" << std::setw(static_cast<int>(wid)) << "";
        for(const char c : description) {
            out.put(c);
            if(c == '\n') {
                out << std::setw(static_cast<int>(wid)) << "";
            }
        }
    }
    out << "\n";
    return out;
}

Here is the caller graph for this function:

from_stream()

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 )

Definition at line 1027 of file CLI11.hpp.

                                                   {
    std::istringstream is;
    is.str(istring);
    is >> obj;
    return !is.fail() && !is.rdbuf()->in_avail();
}

generate_map()

template<typename T >

std::string CLI::detail::generate_map	(	const T &	map,
		bool	key_only = false )

Definition at line 2597 of file CLI11.hpp.

                                                                                  {
    using element_t = typename detail::element_type<T>::type;
    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type; // the type of the object pair
    std::string out(1, '{');
    out.append(detail::join(
        detail::smart_deref(map),
        [key_only](const iteration_type_t &v) {
            std::string res{detail::to_string(detail::pair_adaptor<element_t>::first(v))};
 
            if(!key_only) {
                res.append("->");
                res += detail::to_string(detail::pair_adaptor<element_t>::second(v));
            }
            return res;
        },
        ","));
    out.push_back('}');
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

generate_parents()

std::vector< std::string > CLI::detail::generate_parents ( const std::string & section, std::string & name )

inline

Definition at line 7698 of file CLI11.hpp.

                                                                                        {
    std::vector<std::string> parents;
    if(detail::to_lower(section) != "default") {
        if(section.find('.') != std::string::npos) {
            parents = detail::split(section, '.');
        } else {
            parents = {section};
        }
    }
    if(name.find('.') != std::string::npos) {
        std::vector<std::string> plist = detail::split(name, '.');
        name = plist.back();
        detail::remove_quotes(name);
        plist.pop_back();
        parents.insert(parents.end(), plist.begin(), plist.end());
    }
 
    // clean up quotes on the parents
    for(auto &parent : parents) {
        detail::remove_quotes(parent);
    }
    return parents;
}

Here is the call graph for this function:

Here is the caller graph for this function:

generate_set()

template<typename T >

std::string CLI::detail::generate_set

(

const T &

set

)

Definition at line 2584 of file CLI11.hpp.

                                                           {
    using element_t = typename detail::element_type<T>::type;
    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type; // the type of the object pair
    std::string out(1, '{');
    out.append(detail::join(
        detail::smart_deref(set),
        [](const iteration_type_t &v) { return detail::pair_adaptor<element_t>::first(v); },
        ","));
    out.push_back('}');
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_default_flag_values()

std::vector< std::pair< std::string, std::string > > CLI::detail::get_default_flag_values ( const std::string & str )

inline

Definition at line 1891 of file CLI11.hpp.

                                                                                              {
    std::vector<std::string> flags = split_names(str);
    flags.erase(std::remove_if(flags.begin(),
                               flags.end(),
                               [](const std::string &name) {
                                   return ((name.empty()) || (!(((name.find_first_of('{') != std::string::npos) &&
                                                                 (name.back() == '}')) ||
                                                                (name[0] == '!'))));
                               }),
                flags.end());
    std::vector<std::pair<std::string, std::string>> output;
    output.reserve(flags.size());
    for(auto &flag : flags) {
        auto def_start = flag.find_first_of('{');
        std::string defval = "false";
        if((def_start != std::string::npos) && (flag.back() == '}')) {
            defval = flag.substr(def_start + 1);
            defval.pop_back();
            flag.erase(def_start, std::string::npos);
        }
        flag.erase(0, flag.find_first_not_of("-!"));
        output.emplace_back(flag, defval);
    }
    return output;
}

Here is the call graph for this function:

get_names()

std::tuple< std::vector< std::string >, std::vector< std::string >, std::string > CLI::detail::get_names ( const std::vector< std::string > & input )

inline

Definition at line 1919 of file CLI11.hpp.

                                             {
 
    std::vector<std::string> short_names;
    std::vector<std::string> long_names;
    std::string pos_name;
 
    for(std::string name : input) {
        if(name.length() == 0) {
            continue;
        }
        if(name.length() > 1 && name[0] == '-' && name[1] != '-') {
            if(name.length() == 2 && valid_first_char(name[1]))
                short_names.emplace_back(1, name[1]);
            else
                throw BadNameString::OneCharName(name);
        } else if(name.length() > 2 && name.substr(0, 2) == "--") {
            name = name.substr(2);
            if(valid_name_string(name))
                long_names.push_back(name);
            else
                throw BadNameString::BadLongName(name);
        } else if(name == "-" || name == "--") {
            throw BadNameString::DashesOnly(name);
        } else {
            if(pos_name.length() > 0)
                throw BadNameString::MultiPositionalNames(name);
            pos_name = name;
        }
    }
 
    return std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>(
        short_names, long_names, pos_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

has_default_flag_values()

bool CLI::detail::has_default_flag_values ( const std::string & flags )

inline

Definition at line 363 of file CLI11.hpp.

                                                            {
    return (flags.find_first_of("{!") != std::string::npos);
}

if()

CLI::detail::if

(

str.

back() = =','

)

ini_join()

std::string CLI::detail::ini_join ( const std::vector< std::string > & args, char sepChar = ',', char arrayStart = '[', char arrayEnd = ']' )

inline

Definition at line 7677 of file CLI11.hpp.

                                                                                                           {
    std::string joined;
    if(args.size() > 1 && arrayStart != '\0') {
        joined.push_back(arrayStart);
    }
    std::size_t start = 0;
    for(const auto &arg : args) {
        if(start++ > 0) {
            joined.push_back(sepChar);
            if(isspace(sepChar) == 0) {
                joined.push_back(' ');
            }
        }
        joined.append(convert_arg_for_ini(arg));
    }
    if(args.size() > 1 && arrayEnd != '\0') {
        joined.push_back(arrayEnd);
    }
    return joined;
}

Here is the call graph for this function:

Here is the caller graph for this function:

isalpha()

bool CLI::detail::isalpha ( const std::string & str )

inline

Definition at line 331 of file CLI11.hpp.

                                          {
    return std::all_of(str.begin(), str.end(), [](char c) { return std::isalpha(c, std::locale()); });
}

join() [1/2]

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 = "," )

Definition at line 212 of file CLI11.hpp.

                                                                 {
    std::ostringstream s;
    auto beg = std::begin(v);
    auto end = std::end(v);
    if(beg != end)
        s << func(*beg++);
    while(beg != end) {
        s << delim << func(*beg++);
    }
    return s.str();
}

join() [2/2]

template<typename T >

std::string CLI::detail::join	(	const T &	v,
		std::string	delim = "," )

Definition at line 196 of file CLI11.hpp.

                                                                        {
    std::ostringstream s;
    auto beg = std::begin(v);
    auto end = std::end(v);
    if(beg != end)
        s << *beg++;
    while(beg != end) {
        s << delim << *beg++;
    }
    return s.str();
}

Here is the caller graph for this function:

lexical_conversion()

template<class T , class XC , enable_if_t< is_tuple_like< T >::value, detail::enabler > = detail::dummy>

bool CLI::detail::lexical_conversion	(	const std::vector< std ::string > &	strings,
		T &	output )

Lexical conversion of a vector types with type_size >2.

Definition at line 1759 of file CLI11.hpp.

                                                                         {
    static_assert(
        !is_tuple_like<XC>::value || type_count<T>::value == type_count<XC>::value,
        "if the conversion type is defined as a tuple it must be the same size as the type you are converting to");
    return tuple_conversion<T, XC, 0>(strings, output);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ltrim() [1/2]

std::string & CLI::detail::ltrim ( std::string & str )

inline

Definition at line 238 of file CLI11.hpp.

                                        {
    auto it = std::find_if(str.begin(), str.end(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
    str.erase(str.begin(), it);
    return str;
}

Here is the caller graph for this function:

ltrim() [2/2]

std::string & CLI::detail::ltrim ( std::string & str, const std::string & filter )

inline

Definition at line 245 of file CLI11.hpp.

                                                                 {
    auto it = std::find_if(str.begin(), str.end(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
    str.erase(str.begin(), it);
    return str;
}

overflowCheck() [1/2]

template<typename T >

std::enable_if< std::is_signed< T >::value, T >::type CLI::detail::overflowCheck ( const T & a, const T & b )

inline

Definition at line 2670 of file CLI11.hpp.

                                                                                                {
    if((a > 0) == (b > 0)) {
        return ((std::numeric_limits<T>::max)() / (std::abs)(a) < (std::abs)(b));
    } else {
        return ((std::numeric_limits<T>::min)() / (std::abs)(a) > -(std::abs)(b));
    }
}

Here is the caller graph for this function:

overflowCheck() [2/2]

template<typename T >

std::enable_if<!std::is_signed< T >::value, T >::type CLI::detail::overflowCheck ( const T & a, const T & b )

inline

Definition at line 2679 of file CLI11.hpp.

                                                                                                 {
    return ((std::numeric_limits<T>::max)() / a < b);
}

remove_default_flag_values()

void CLI::detail::remove_default_flag_values ( std::string & flags )

inline

Definition at line 367 of file CLI11.hpp.

                                                         {
    auto loc = flags.find_first_of('{');
    while(loc != std::string::npos) {
        auto finish = flags.find_first_of("},", loc + 1);
        if((finish != std::string::npos) && (flags[finish] == '}')) {
            flags.erase(flags.begin() + static_cast<std::ptrdiff_t>(loc),
                        flags.begin() + static_cast<std::ptrdiff_t>(finish) + 1);
        }
        loc = flags.find_first_of('{', loc + 1);
    }
    flags.erase(std::remove(flags.begin(), flags.end(), '!'), flags.end());
}

remove_quotes()

std::string & CLI::detail::remove_quotes ( std::string & str )

inline

Definition at line 279 of file CLI11.hpp.

                                                {
    if(str.length() > 1 && (str.front() == '"' || str.front() == '\'')) {
        if(str.front() == str.back()) {
            str.pop_back();
            str.erase(str.begin(), str.begin() + 1);
        }
    }
    return str;
}

Here is the caller graph for this function:

remove_underscore()

std::string CLI::detail::remove_underscore ( std::string str )

inline

Definition at line 344 of file CLI11.hpp.

                                                  {
    str.erase(std::remove(std::begin(str), std::end(str), '_'), std::end(str));
    return str;
}

Here is the caller graph for this function:

rjoin()

template<typename T >

std::string CLI::detail::rjoin	(	const T &	v,
		std::string	delim = "," )

Definition at line 225 of file CLI11.hpp.

                                                                         {
    std::ostringstream s;
    for(std::size_t start = 0; start < v.size(); start++) {
        if(start > 0)
            s << delim;
        s << v[v.size() - start - 1];
    }
    return s.str();
}

rtrim() [1/2]

std::string & CLI::detail::rtrim ( std::string & str )

inline

Definition at line 252 of file CLI11.hpp.

                                        {
    auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
    str.erase(it.base(), str.end());
    return str;
}

Here is the caller graph for this function:

rtrim() [2/2]

std::string & CLI::detail::rtrim ( std::string & str, const std::string & filter )

inline

Definition at line 259 of file CLI11.hpp.

                                                                 {
    auto it =
        std::find_if(str.rbegin(), str.rend(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
    str.erase(it.base(), str.end());
    return str;
}

search() [1/2]

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 that uses the built in find function.

Definition at line 2628 of file CLI11.hpp.

                                                                                                     {
    using element_t = typename detail::element_type<T>::type;
    auto &setref = detail::smart_deref(set);
    auto it = std::find_if(std::begin(setref), std::end(setref), [&val](decltype(*std::begin(setref)) v) {
        return (detail::pair_adaptor<element_t>::first(v) == val);
    });
    return {(it != std::end(setref)), it};
}

Here is the call graph for this function:

Here is the caller graph for this function:

search() [2/2]

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)))>

Definition at line 2647 of file CLI11.hpp.

                                                                 {
    using element_t = typename detail::element_type<T>::type;
    // do the potentially faster first search
    auto res = search(set, val);
    if((res.first) || (!(filter_function))) {
        return res;
    }
    // if we haven't found it do the longer linear search with all the element translations
    auto &setref = detail::smart_deref(set);
    auto it = std::find_if(std::begin(setref), std::end(setref), [&](decltype(*std::begin(setref)) v) {
        V a{detail::pair_adaptor<element_t>::first(v)};
        a = filter_function(a);
        return (a == val);
    });
    return {(it != std::end(setref)), it};
}

Here is the call graph for this function:

smart_deref() [1/2]

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

)

Definition at line 2580 of file CLI11.hpp.

                                                           {
    return value;
}

smart_deref() [2/2]

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)

Definition at line 2573 of file CLI11.hpp.

                                              {
    return *value;
}

Here is the caller graph for this function:

split()

std::vector< std::string > CLI::detail::split ( const std::string & s, char delim )

inline

Definition at line 179 of file CLI11.hpp.

                                                                  {
    std::vector<std::string> elems;
    // Check to see if empty string, give consistent result
    if(s.empty())
        elems.emplace_back();
    else {
        std::stringstream ss;
        ss.str(s);
        std::string item;
        while(std::getline(ss, item, delim)) {
            elems.push_back(item);
        }
    }
    return elems;
}

Here is the caller graph for this function:

split_long()

bool CLI::detail::split_long ( const std::string & current, std::string & name, std::string & value )

inline

Definition at line 1847 of file CLI11.hpp.

                                                                                    {
    if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
        auto loc = current.find_first_of('=');
        if(loc != std::string::npos) {
            name = current.substr(2, loc - 2);
            value = current.substr(loc + 1);
        } else {
            name = current.substr(2);
            value = "";
        }
        return true;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

split_names()

std::vector< std::string > CLI::detail::split_names ( std::string current )

inline

Definition at line 1879 of file CLI11.hpp.

                                                           {
    std::vector<std::string> output;
    std::size_t val;
    while((val = current.find(",")) != std::string::npos) {
        output.push_back(trim_copy(current.substr(0, val)));
        current = current.substr(val + 1);
    }
    output.push_back(trim_copy(current));
    return output;
}

Here is the call graph for this function:

Here is the caller graph for this function:

split_program_name()

std::pair< std::string, std::string > CLI::detail::split_program_name ( std::string commandline )

inline

Split a string into a program name and command line arguments the string is assumed to contain a file name followed by other arguments the return value contains is a pair with the first argument containing the program name and the second everything else.

Definition at line 3128 of file CLI11.hpp.

                                                                               {
    // try to determine the programName
    std::pair<std::string, std::string> vals;
    trim(commandline);
    auto esp = commandline.find_first_of(' ', 1);
    while(detail::check_path(commandline.substr(0, esp).c_str()) != path_type::file) {
        esp = commandline.find_first_of(' ', esp + 1);
        if(esp == std::string::npos) {
            // if we have reached the end and haven't found a valid file just assume the first argument is the
            // program name
            esp = commandline.find_first_of(' ', 1);
            break;
        }
    }
    vals.first = commandline.substr(0, esp);
    rtrim(vals.first);
    // strip the program name
    vals.second = (esp != std::string::npos) ? commandline.substr(esp + 1) : std::string{};
    ltrim(vals.second);
    return vals;
}

Here is the call graph for this function:

Here is the caller graph for this function:

split_short()

bool CLI::detail::split_short ( const std::string & current, std::string & name, std::string & rest )

inline

Definition at line 1837 of file CLI11.hpp.

                                                                                    {
    if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {
        name = current.substr(1, 1);
        rest = current.substr(2);
        return true;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

split_windows_style()

bool CLI::detail::split_windows_style ( const std::string & current, std::string & name, std::string & value )

inline

Definition at line 1863 of file CLI11.hpp.

                                                                                             {
    if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {
        auto loc = current.find_first_of(':');
        if(loc != std::string::npos) {
            name = current.substr(1, loc - 1);
            value = current.substr(loc + 1);
        } else {
            name = current.substr(1);
            value = "";
        }
        return true;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sum_flag_vector()

template<typename T , enable_if_t< std::is_integral< T >::value &&std::is_unsigned< T >::value, detail::enabler > = detail::dummy>

void CLI::detail::sum_flag_vector	(	const std::vector< std::string > &	flags,
		T &	output )

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

Definition at line 1805 of file CLI11.hpp.

                                                                   {
    int64_t count{0};
    for(auto &flag : flags) {
        count += detail::to_flag_value(flag);
    }
    output = (count > 0) ? static_cast<T>(count) : T{0};
}

Here is the caller graph for this function:

to_lower()

std::string CLI::detail::to_lower ( std::string str )

inline

Definition at line 336 of file CLI11.hpp.

                                         {
    std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
        return std::tolower(x, std::locale());
    });
    return str;
}

Here is the caller graph for this function:

to_string() [1/2]

template<typename T , enable_if_t<!std::is_constructible< std::string, T >::value &&is_ostreamable< T >::value, detail::enabler > = detail::dummy>

std::string CLI::detail::to_string

(

T &&

value

)

convert a vector to a string

If conversion is not supported, return an empty string (streaming is not supported for that type)

Definition at line 1061 of file CLI11.hpp.

                               {
    std::stringstream stream;
    stream << value;
    return stream.str();
}

to_string() [2/2]

template<typename T , enable_if_t< std::is_constructible< std::string, T >::value, detail::enabler > = detail::dummy>

auto CLI::detail::to_string

(

T &&

value

)

-> decltype(std::forward<T>(value))

Definition at line 1053 of file CLI11.hpp.

                                                            {
    return std::forward<T>(value);
}

Here is the caller graph for this function:

trim() [1/3]

std::string & CLI::detail::trim ( std::string & str )

inline

Definition at line 267 of file CLI11.hpp.

{ return ltrim(rtrim(str)); }

Here is the call graph for this function:

Here is the caller graph for this function:

trim() [2/3]

std::string & CLI::detail::trim ( std::string & str, const std::string filter )

inline

Definition at line 270 of file CLI11.hpp.

{ return ltrim(rtrim(str, filter), filter); }

Here is the call graph for this function:

trim() [3/3]

CLI::detail::trim

(

str

)

trim_copy() [1/2]

std::string CLI::detail::trim_copy ( const std::string & str )

inline

Definition at line 273 of file CLI11.hpp.

                                                 {
    std::string s = str;
    return trim(s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

trim_copy() [2/2]

std::string CLI::detail::trim_copy ( const std::string & str, const std::string & filter )

inline

Definition at line 290 of file CLI11.hpp.

                                                                          {
    std::string s = str;
    return trim(s, filter);
}

Here is the call graph for this function:

tuple_conversion()

std::size_t I inline typename bool ::type CLI::detail::tuple_conversion	(	const std::vector< std::string > &	,
		T &	)

Definition at line 1738 of file CLI11.hpp.

                                                                                            {
    return true;
}

Here is the caller graph for this function:

tuple_name()

std::size_t I std::enable_if< I==type_count< T >::value, std::string >::type CLI::detail::tuple_name ( )

inline

Definition at line 1349 of file CLI11.hpp.

                                                                                  {
    return std::string{};
}

type_name()

template<typename T , enable_if_t< classify_object< T >::value==object_category::integral_value||classify_object< T >::value==object_category::integer_constructible, detail::enabler > = detail::dummy>

const char * CLI::detail::type_name ( )

constexpr

Was going to be based on http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template But this is cleaner and works better in this case

Definition at line 1299 of file CLI11.hpp.

                                  {
    return "INT";
}

Here is the caller graph for this function:

valid_first_char()

template<typename T >

bool CLI::detail::valid_first_char

(

T

c

)

Definition at line 313 of file CLI11.hpp.

                                                 {
    return std::isalnum(c, std::locale()) || c == '_' || c == '?' || c == '@';
}

Here is the caller graph for this function:

valid_later_char()

template<typename T >

bool CLI::detail::valid_later_char

(

T

c

)

Definition at line 318 of file CLI11.hpp.

{ return valid_first_char(c) || c == '.' || c == '-'; }

Here is the call graph for this function:

Here is the caller graph for this function:

valid_name_string()

bool CLI::detail::valid_name_string ( const std::string & str )

inline

Definition at line 321 of file CLI11.hpp.

                                                    {
    if(str.empty() || !valid_first_char(str[0]))
        return false;
    for(auto c : str.substr(1))
        if(!valid_later_char(c))
            return false;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

value_string() [1/2]

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 enumerations

Definition at line 1112 of file CLI11.hpp.

                                       {
    return std::to_string(value);
}

Here is the caller graph for this function:

value_string() [2/2]

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))

Definition at line 1123 of file CLI11.hpp.

                                                                {
    return to_string(value);
}

Here is the call graph for this function:

while()

CLI::detail::while

(

!str.

empty()

)

Definition at line 433 of file CLI11.hpp.

                        {
        if(delims.find_first_of(str[0]) != std::string::npos) {
            keyChar = str[0];
            auto end = str.find_first_of(keyChar, 1);
            while((end != std::string::npos) && (str[end - 1] == '\\')) { // deal with escaped quotes
                end = str.find_first_of(keyChar, end + 1);
                embeddedQuote = true;
            }
            if(end != std::string::npos) {
                output.push_back(str.substr(1, end - 1));
                str = str.substr(end + 1);
            } else {
                output.push_back(str.substr(1));
                str = "";
            }
        } else {
            auto it = std::find_if(std::begin(str), std::end(str), find_ws);
            if(it != std::end(str)) {
                std::string value = std::string(str.begin(), it);
                output.push_back(value);
                str = std::string(it + 1, str.end());
            } else {
                output.push_back(str);
                str = "";
            }
        }
        // transform any embedded quotes into the regular character
        if(embeddedQuote) {
            output.back() = find_and_replace(output.back(), std::string("\\") + keyChar, std::string(1, keyChar));
            embeddedQuote = false;
        }
        trim(str);
    }

Here is the call graph for this function:

Variable Documentation

dummy

enabler CLI::detail::dummy = {}

constexpr

Definition at line 856 of file CLI11.hpp.

{};

embeddedQuote

bool CLI::detail::embeddedQuote = false

Definition at line 431 of file CLI11.hpp.

expected_max_vector_size

int CLI::detail::expected_max_vector_size {1 << 29}

constexpr

a constant defining an expected max vector size defined to be a big number that could be multiplied by 4 and not produce overflow for some expected uses

Definition at line 176 of file CLI11.hpp.

{1 << 29};

find_ws

auto CLI::detail::find_ws

Initial value:

= [delimiter](char ch) {
        return (delimiter == '\0') ? (std::isspace<char>(ch, std::locale()) != 0) : (ch == delimiter);
    }

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, char delimiter = '\0') { @iverbatim const std::string delims("\'"`");

Definition at line 425 of file CLI11.hpp.

                                        {
        return (delimiter == '\0') ? (std::isspace<char>(ch, std::locale()) != 0) : (ch == delimiter);
    };

keyChar

char CLI::detail::keyChar = ' '

Definition at line 432 of file CLI11.hpp.

output

return CLI::detail::output

Definition at line 430 of file CLI11.hpp.

retval

return CLI::detail::retval

Definition at line 1754 of file CLI11.hpp.

str

return CLI::detail::str

Definition at line 1359 of file CLI11.hpp.

XC

CLI::detail::XC

Definition at line 1579 of file CLI11.hpp.