30#if defined CLI11_CPP17 && defined __has_include && !defined CLI11_HAS_FILESYSTEM
31#if __has_include(<filesystem>)
33#if defined __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
34#define CLI11_HAS_FILESYSTEM 0
35#elif defined(__wasi__)
37#define CLI11_HAS_FILESYSTEM 0
40#if defined __cpp_lib_filesystem && __cpp_lib_filesystem >= 201703
41#if defined _GLIBCXX_RELEASE && _GLIBCXX_RELEASE >= 9
42#define CLI11_HAS_FILESYSTEM 1
43#elif defined(__GLIBCXX__)
45#define CLI11_HAS_FILESYSTEM 0
47#define CLI11_HAS_FILESYSTEM 1
50#define CLI11_HAS_FILESYSTEM 0
56#if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0
87 std::function<std::string(std::string &)>
func_{[](std::string &) {
return std::string{}; }};
102 Validator(std::function<std::string(std::string &)> op, std::string validator_desc, std::string validator_name =
"")
104 name_(std::move(validator_name)) {}
107 func_ = std::move(op);
113 std::string retstring;
116 std::string value = str;
117 retstring =
func_(value);
119 retstring =
func_(str);
128 std::string value = str;
140 newval.
desc_function_ = [validator_desc]() {
return validator_desc; };
148 return std::string{};
152 name_ = std::move(validator_name);
158 newval.
name_ = std::move(validator_name);
204 newval._merge_description(*
this, other,
" AND ");
207 const std::function<std::string(std::string & filename)> &f1 =
func_;
208 const std::function<std::string(std::string & filename)> &f2 = other.
func_;
210 newval.
func_ = [f1, f2](std::string &input) {
211 std::string s1 = f1(input);
212 std::string s2 = f2(input);
213 if(!s1.empty() && !s2.empty())
214 return std::string(
"(") + s1 +
") AND (" + s2 +
")";
229 newval._merge_description(*
this, other,
" OR ");
232 const std::function<std::string(std::string &)> &f1 =
func_;
233 const std::function<std::string(std::string &)> &f2 = other.
func_;
235 newval.
func_ = [f1, f2](std::string &input) {
236 std::string s1 = f1(input);
237 std::string s2 = f2(input);
238 if(s1.empty() || s2.empty())
239 return std::string();
241 return std::string(
"(") + s1 +
") OR (" + s2 +
")";
254 return (!str.empty()) ? std::string(
"NOT ") + str : std::string{};
257 const std::function<std::string(std::string & res)> &f1 =
func_;
259 newval.
func_ = [f1, dfunc1](std::string &test) -> std::string {
260 std::string s1 = f1(test);
262 return std::string(
"check ") + dfunc1() +
" succeeded improperly";
264 return std::string{};
272 void _merge_description(
const Validator &val1,
const Validator &val2,
const std::string &merger) {
278 std::string f1 = dfunc1();
279 std::string f2 = dfunc2();
280 if((f1.empty()) || (f2.empty())) {
283 return std::string(1,
'(') + f1 +
')' + merger +
'(' + f2 +
')';
300#if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0
304 auto stat = std::filesystem::status(
file, ec);
308 switch(stat.type()) {
309 case std::filesystem::file_type::none:
310 case std::filesystem::file_type::not_found:
312 case std::filesystem::file_type::directory:
314 case std::filesystem::file_type::symlink:
315 case std::filesystem::file_type::block:
316 case std::filesystem::file_type::character:
317 case std::filesystem::file_type::fifo:
318 case std::filesystem::file_type::socket:
319 case std::filesystem::file_type::regular:
320 case std::filesystem::file_type::unknown:
329 struct __stat64 buffer;
330 if(_stat64(
file, &buffer) == 0) {
335 if(stat(
file, &buffer) == 0) {
346 func_ = [](std::string &filename) {
347 auto path_result =
check_path(filename.c_str());
349 return "File does not exist: " + filename;
352 return "File is actually a directory: " + filename;
354 return std::string();
363 func_ = [](std::string &filename) {
364 auto path_result =
check_path(filename.c_str());
366 return "Directory does not exist: " + filename;
369 return "Directory is actually a file: " + filename;
371 return std::string();
380 func_ = [](std::string &filename) {
381 auto path_result =
check_path(filename.c_str());
383 return "Path does not exist: " + filename;
385 return std::string();
394 func_ = [](std::string &filename) {
395 auto path_result =
check_path(filename.c_str());
397 return "Path already exists: " + filename;
399 return std::string();
408 func_ = [](std::string &ip_addr) {
410 if(result.size() != 4) {
411 return std::string(
"Invalid IPV4 address must have four parts (") + ip_addr +
')';
414 for(
const auto &var : result) {
417 return std::string(
"Failed parsing number (") + var +
')';
419 if(num < 0 || num > 255) {
420 return std::string(
"Each IP number must be between 0 and 255 ") + var;
423 return std::string();
451 func_ = [](std::string &input_string) {
452 auto val = DesiredType();
454 return std::string(
"Failed parsing ") + input_string +
" as a " + detail::type_name<DesiredType>();
456 return std::string();
470 func_ = [default_path, enableErrorReturn](std::string &filename) {
473 std::string test_file_path = default_path;
474 if(default_path.back() !=
'/' && default_path.back() !=
'\\') {
476 test_file_path +=
'/';
478 test_file_path.append(filename);
481 filename = test_file_path;
483 if(enableErrorReturn) {
484 return "File does not exist: " + filename;
488 return std::string{};
500 template <
typename T>
501 Range(T min_val, T max_val,
const std::string &validator_name = std::string{}) :
Validator(validator_name) {
502 if(validator_name.empty()) {
503 std::stringstream out;
504 out << detail::type_name<T>() <<
" in [" << min_val <<
" - " << max_val <<
"]";
505 description(out.str());
508 func_ = [min_val, max_val](std::string &input) {
510 bool converted = detail::lexical_cast(input, val);
511 if((!converted) || (val < min_val || val > max_val)) {
512 std::stringstream out;
513 out <<
"Value " << input <<
" not in range [";
514 out << min_val <<
" - " << max_val <<
"]";
517 return std::string{};
522 template <
typename T>
523 explicit Range(T max_val,
const std::string &validator_name = std::string{})
524 :
Range(static_cast<T>(0), max_val, validator_name) {}
531const Range PositiveNumber((std::numeric_limits<double>::min)(), (std::numeric_limits<double>::max)(),
"POSITIVE");
540 template <
typename T>
Bound(T min_val, T max_val) {
541 std::stringstream out;
542 out << detail::type_name<T>() <<
" bounded to [" << min_val <<
" - " << max_val <<
"]";
543 description(out.str());
545 func_ = [min_val, max_val](std::string &input) {
547 bool converted = detail::lexical_cast(input, val);
549 return std::string(
"Value ") + input +
" could not be converted";
552 input = detail::to_string(min_val);
553 else if(val > max_val)
554 input = detail::to_string(max_val);
556 return std::string{};
561 template <
typename T>
explicit Bound(T max_val) :
Bound(static_cast<T>(0), max_val) {}
566 enable_if_t<is_copyable_ptr<typename std::remove_reference<T>::type>::value, detail::enabler> = detail::dummy>
581 std::string out(1,
'{');
582 out.append(detail::join(
583 detail::smart_deref(set),
591template <
typename T> std::string
generate_map(
const T &map,
bool key_only =
false) {
594 std::string out(1,
'{');
595 out.append(detail::join(
596 detail::smart_deref(map),
597 [key_only](
const iteration_type_t &v) {
612 template <
typename CC,
typename VV>
613 static auto test(
int) ->
decltype(std::declval<CC>().find(std::declval<VV>()), std::true_type());
614 template <
typename,
typename>
static auto test(...) ->
decltype(std::false_type());
616 static const auto value =
decltype(test<C, V>(0))::value;
617 using type = std::integral_constant<bool, value>;
621template <typename T, typename V, enable_if_t<!has_find<T, V>::value,
detail::enabler> = detail::dummy>
622auto search(
const T &set,
const V &val) -> std::pair<bool,
decltype(std::begin(detail::smart_deref(set)))> {
624 auto &setref = detail::smart_deref(set);
625 auto it = std::find_if(std::begin(setref), std::end(setref), [&val](
decltype(*std::begin(setref)) v) {
628 return {(it != std::end(setref)), it};
632template <typename T, typename V, enable_if_t<has_find<T, V>::value,
detail::enabler> = detail::dummy>
633auto search(
const T &set,
const V &val) -> std::pair<bool,
decltype(std::begin(detail::smart_deref(set)))> {
634 auto &setref = detail::smart_deref(set);
635 auto it = setref.find(val);
636 return {(it != std::end(setref)), it};
640template <
typename T,
typename V>
641auto search(
const T &set,
const V &val,
const std::function<V(V)> &filter_function)
642 -> std::pair<bool,
decltype(std::begin(detail::smart_deref(set)))> {
645 auto res =
search(set, val);
646 if((res.first) || (!(filter_function))) {
650 auto &setref = detail::smart_deref(set);
651 auto it = std::find_if(std::begin(setref), std::end(setref), [&](
decltype(*std::begin(setref)) v) {
653 a = filter_function(a);
656 return {(it != std::end(setref)), it};
664inline typename std::enable_if<std::is_signed<T>::value, T>::type
overflowCheck(
const T &a,
const T &b) {
665 if((a > 0) == (b > 0)) {
666 return ((std::numeric_limits<T>::max)() / (std::abs)(a) < (std::abs)(b));
668 return ((std::numeric_limits<T>::min)() / (std::abs)(a) > -(std::abs)(b));
673inline typename std::enable_if<!std::is_signed<T>::value, T>::type
overflowCheck(
const T &a,
const T &b) {
674 return ((std::numeric_limits<T>::max)() / a < b);
678template <
typename T>
typename std::enable_if<std::is_integral<T>::value,
bool>::type
checked_multiply(T &a, T b) {
679 if(a == 0 || b == 0 || a == 1 || b == 1) {
683 if(a == (std::numeric_limits<T>::min)() || b == (std::numeric_limits<T>::min)()) {
695typename std::enable_if<std::is_floating_point<T>::value,
bool>::type
checked_multiply(T &a, T b) {
697 if(std::isinf(c) && !std::isinf(a) && !std::isinf(b)) {
711 template <
typename T,
typename... Args>
712 IsMember(std::initializer_list<T> values, Args &&...args)
713 :
IsMember(std::vector<T>(values), std::forward<Args>(args)...) {}
716 template <
typename T>
explicit IsMember(T &&set) :
IsMember(std::forward<T>(set), nullptr) {}
720 template <
typename T,
typename F>
explicit IsMember(T set, F filter_function) {
731 std::function<local_item_t(local_item_t)> filter_fn = filter_function;
734 desc_function_ = [set]() {
return detail::generate_set(detail::smart_deref(set)); };
738 func_ = [set, filter_fn](std::string &input) {
740 if(!detail::lexical_cast(input, b)) {
746 auto res = detail::search(set, b, filter_fn);
754 return std::string{};
758 return input +
" not in " + detail::generate_set(detail::smart_deref(set));
763 template <
typename T,
typename... Args>
766 std::forward<T>(set),
767 [filter_fn_1, filter_fn_2](std::string a) {
return filter_fn_2(filter_fn_1(a)); },
772template <
typename T>
using TransformPairs = std::vector<std::pair<std::string, T>>;
780 template <
typename... Args>
781 Transformer(std::initializer_list<std::pair<std::string, std::string>> values, Args &&...args)
789 template <
typename T,
typename F>
explicit Transformer(T mapping, F filter_function) {
792 "mapping must produce value pairs");
801 std::function<local_item_t(local_item_t)> filter_fn = filter_function;
804 desc_function_ = [mapping]() {
return detail::generate_map(detail::smart_deref(mapping)); };
806 func_ = [mapping, filter_fn](std::string &input) {
808 if(!detail::lexical_cast(input, b)) {
809 return std::string();
815 auto res = detail::search(mapping, b, filter_fn);
819 return std::string{};
824 template <
typename T,
typename... Args>
827 std::forward<T>(mapping),
828 [filter_fn_1, filter_fn_2](std::string a) {
return filter_fn_2(filter_fn_1(a)); },
838 template <
typename... Args>
839 CheckedTransformer(std::initializer_list<std::pair<std::string, std::string>> values, Args &&...args)
850 "mapping must produce value pairs");
860 std::function<local_item_t(local_item_t)> filter_fn = filter_function;
862 auto tfunc = [mapping]() {
863 std::string out(
"value in ");
864 out += detail::generate_map(detail::smart_deref(mapping)) +
" OR {";
866 detail::smart_deref(mapping),
873 desc_function_ = tfunc;
875 func_ = [mapping, tfunc, filter_fn](std::string &input) {
877 bool converted = detail::lexical_cast(input, b);
882 auto res = detail::search(mapping, b, filter_fn);
885 return std::string{};
888 for(
const auto &v : detail::smart_deref(mapping)) {
890 if(output_string == input) {
891 return std::string();
895 return "Check " + input +
" " + tfunc() +
" FAILED";
900 template <
typename T,
typename... Args>
903 std::forward<T>(mapping),
904 [filter_fn_1, filter_fn_2](std::string a) {
return filter_fn_2(filter_fn_1(a)); },
909inline std::string
ignore_case(std::string item) {
return detail::to_lower(item); }
912inline std::string
ignore_underscore(std::string item) {
return detail::remove_underscore(item); }
916 item.erase(std::remove(std::begin(item), std::end(item),
' '), std::end(item));
917 item.erase(std::remove(std::begin(item), std::end(item),
'\t'), std::end(item));
940 CASE_INSENSITIVE = 1,
943 DEFAULT = CASE_INSENSITIVE | UNIT_OPTIONAL
946 template <
typename Number>
949 const std::string &unit_name =
"UNIT") {
950 description(generate_description<Number>(unit_name, opts));
951 validate_mapping(mapping, opts);
954 func_ = [mapping, opts](std::string &input) -> std::string {
957 detail::rtrim(input);
963 auto unit_begin = input.end();
964 while(unit_begin > input.begin() && std::isalpha(*(unit_begin - 1), std::locale())) {
968 std::string unit{unit_begin, input.end()};
969 input.resize(
static_cast<std::size_t
>(std::distance(input.begin(), unit_begin)));
972 if(opts & UNIT_REQUIRED && unit.empty()) {
975 if(opts & CASE_INSENSITIVE) {
976 unit = detail::to_lower(unit);
979 if(!detail::lexical_cast(input, num)) {
980 throw ValidationError(std::string(
"Value ") + input +
" could not be converted to " +
981 detail::type_name<Number>());
988 auto it = mapping.find(unit);
989 if(it == mapping.end()) {
991 " unit not recognized. "
993 detail::generate_map(mapping,
true));
997 bool converted = detail::lexical_cast(input, num);
999 throw ValidationError(std::string(
"Value ") + input +
" could not be converted to " +
1000 detail::type_name<Number>());
1003 bool ok = detail::checked_multiply(num, it->second);
1005 throw ValidationError(detail::to_string(num) +
" multiplied by " + unit +
1006 " factor would cause number overflow. Use smaller value.");
1009 num =
static_cast<Number>(it->second);
1012 input = detail::to_string(num);
1021 template <
typename Number>
static void validate_mapping(std::map<std::string, Number> &mapping, Options opts) {
1022 for(
auto &kv : mapping) {
1023 if(kv.first.empty()) {
1026 if(!detail::isalpha(kv.first)) {
1027 throw ValidationError(
"Unit must contain only letters.");
1032 if(opts & CASE_INSENSITIVE) {
1033 std::map<std::string, Number> lower_mapping;
1034 for(
auto &kv : mapping) {
1035 auto s = detail::to_lower(kv.first);
1036 if(lower_mapping.count(s)) {
1037 throw ValidationError(std::string(
"Several matching lowercase unit representations are found: ") +
1040 lower_mapping[detail::to_lower(kv.first)] = kv.second;
1042 mapping = std::move(lower_mapping);
1047 template <
typename Number>
static std::string generate_description(
const std::string &name, Options opts) {
1048 std::stringstream out;
1049 out << detail::type_name<Number>() <<
' ';
1050 if(opts & UNIT_REQUIRED) {
1053 out <<
'[' << name <<
']';
1083 description(
"SIZE [b, kb(=1000b), kib(=1024b), ...]");
1085 description(
"SIZE [b, kb(=1024b), ...]");
1091 static std::map<std::string, result_t> init_mapping(
bool kb_is_1000) {
1092 std::map<std::string, result_t> m;
1093 result_t k_factor = kb_is_1000 ? 1000 : 1024;
1094 result_t ki_factor = 1024;
1098 for(std::string p : {
"k",
"m",
"g",
"t",
"p",
"e"}) {
1110 static std::map<std::string, result_t> get_mapping(
bool kb_is_1000) {
1112 static auto m = init_mapping(
true);
1115 static auto m = init_mapping(
false);
1128 std::pair<std::string, std::string> vals;
1130 auto esp = commandline.find_first_of(
' ', 1);
1131 while(detail::check_path(commandline.substr(0, esp).c_str()) != path_type::file) {
1132 esp = commandline.find_first_of(
' ', esp + 1);
1133 if(esp == std::string::npos) {
1136 if(commandline[0] ==
'"' || commandline[0] ==
'\'' || commandline[0] ==
'`') {
1138 auto keyChar = commandline[0];
1139 auto end = commandline.find_first_of(
keyChar, 1);
1140 while((end != std::string::npos) && (commandline[end - 1] ==
'\\')) {
1141 end = commandline.find_first_of(
keyChar, end + 1);
1144 if(end != std::string::npos) {
1145 vals.first = commandline.substr(1, end - 1);
1151 esp = commandline.find_first_of(
' ', 1);
1154 esp = commandline.find_first_of(
' ', 1);
1160 if(vals.first.empty()) {
1161 vals.first = commandline.substr(0, esp);
1166 vals.second = (esp != std::string::npos) ? commandline.substr(esp + 1) : std::string{};
Definition Validators.hpp:932
Options
Definition Validators.hpp:938
AsNumberWithUnit(std::map< std::string, Number > mapping, Options opts=DEFAULT, const std::string &unit_name="UNIT")
Definition Validators.hpp:947
Definition Validators.hpp:1070
AsSizeValue(bool kb_is_1000)
Definition Validators.hpp:1081
std::uint64_t result_t
Definition Validators.hpp:1072
Produce a bounded range (factory). Min and max are inclusive.
Definition Validators.hpp:534
Bound(T min_val, T max_val)
Definition Validators.hpp:540
Bound(T max_val)
Range of one value is 0 to value.
Definition Validators.hpp:561
Class wrapping some of the accessors of Validator.
Definition Validators.hpp:289
Definition Validators.hpp:467
FileOnDefaultPath(std::string default_path, bool enableErrorReturn=true)
Definition Validators.hpp:469
Verify items are in a set.
Definition Validators.hpp:706
IsMember(T &&set)
This checks to see if an item is in a set (empty function)
Definition Validators.hpp:716
IsMember(T set, F filter_function)
Definition Validators.hpp:720
IsMember(T &&set, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&...other)
You can pass in as many filter functions as you like, they nest (string only currently)
Definition Validators.hpp:764
IsMember(std::initializer_list< T > values, Args &&...args)
This allows in-place construction using an initializer list.
Definition Validators.hpp:712
std::function< std::string(std::string)> filter_fn_t
Definition Validators.hpp:708
Produce a range (factory). Min and max are inclusive.
Definition Validators.hpp:494
Range(T min_val, T max_val, const std::string &validator_name=std::string{})
Definition Validators.hpp:501
Range(T max_val, const std::string &validator_name=std::string{})
Range of one value is 0 to value.
Definition Validators.hpp:523
Validate the input as a particular type.
Definition Validators.hpp:448
TypeValidator()
Definition Validators.hpp:459
TypeValidator(const std::string &validator_name)
Definition Validators.hpp:450
Thrown when validation of results fails.
Definition Error.hpp:212
Some validators that are provided.
Definition Validators.hpp:80
bool get_active() const
Get a boolean if the validator is active.
Definition Validators.hpp:194
int application_index_
A Validator will only apply to an indexed value (-1 is all elements)
Definition Validators.hpp:91
Validator & non_modifying(bool no_modify=true)
Specify whether the Validator can be modifying or not.
Definition Validators.hpp:176
Validator & description(std::string validator_desc)
Specify the type string.
Definition Validators.hpp:133
std::string operator()(const std::string &str) const
Definition Validators.hpp:127
Validator operator&(const Validator &other) const
Definition Validators.hpp:201
bool active_
Enable for Validator to allow it to be disabled if need be.
Definition Validators.hpp:93
Validator name(std::string validator_name) const
Specify the type string.
Definition Validators.hpp:156
Validator application_index(int app_index) const
Specify the application index of a validator.
Definition Validators.hpp:186
bool non_modifying_
specify that a validator should not modify the input
Definition Validators.hpp:95
const std::string & get_name() const
Get the name of the Validator.
Definition Validators.hpp:162
Validator(std::string validator_desc)
Construct a Validator with just the description string.
Definition Validators.hpp:100
std::string get_description() const
Generate type description information for the Validator.
Definition Validators.hpp:144
Validator & name(std::string validator_name)
Specify the type string.
Definition Validators.hpp:151
std::string operator()(std::string &str) const
Definition Validators.hpp:112
Validator active(bool active_val=true) const
Specify whether the Validator is active or not.
Definition Validators.hpp:169
std::function< std::string()> desc_function_
This is the description function, if empty the description_ will be used.
Definition Validators.hpp:83
int get_application_index() const
Get the current value of the application index.
Definition Validators.hpp:192
std::function< std::string(std::string &)> func_
Definition Validators.hpp:87
Validator operator!() const
Create a validator that fails when a given validator succeeds.
Definition Validators.hpp:249
Validator operator|(const Validator &other) const
Definition Validators.hpp:226
Validator & active(bool active_val=true)
Specify whether the Validator is active or not.
Definition Validators.hpp:164
std::string name_
The name for search purposes of the Validator.
Definition Validators.hpp:89
Validator description(std::string validator_desc) const
Specify the type string.
Definition Validators.hpp:138
bool get_modifying() const
Get a boolean if the validator is allowed to modify the input returns true if it can modify the input...
Definition Validators.hpp:197
Validator & application_index(int app_index)
Specify the application index of a validator.
Definition Validators.hpp:181
Validator(std::function< std::string(std::string &)> op, std::string validator_desc, std::string validator_name="")
Construct Validator from basic information.
Definition Validators.hpp:102
Validator & operation(std::function< std::string(std::string &)> op)
Set the Validator operation function.
Definition Validators.hpp:106
Check for an existing directory (returns error message if check fails)
Definition Validators.hpp:360
ExistingDirectoryValidator()
Definition Validators.hpp:362
Check for an existing file (returns error message if check fails)
Definition Validators.hpp:343
ExistingFileValidator()
Definition Validators.hpp:345
Check for an existing path.
Definition Validators.hpp:377
ExistingPathValidator()
Definition Validators.hpp:379
Validate the given string is a legal ipv4 address.
Definition Validators.hpp:405
IPV4Validator()
Definition Validators.hpp:407
Check for an non-existing path.
Definition Validators.hpp:391
NonexistentPathValidator()
Definition Validators.hpp:393
auto smart_deref(T value) -> decltype(*value)
Definition Validators.hpp:567
path_type check_path(const char *file) noexcept
get the type of the path from a file name
Definition Validators.hpp:327
path_type
CLI enumeration of different file types.
Definition Validators.hpp:298
std::string generate_map(const T &map, bool key_only=false)
Generate a string representation of a map.
Definition Validators.hpp:591
std::string & rtrim(std::string &str)
Trim whitespace from right of string.
Definition StringTools.hpp:123
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.
Definition Validators.hpp:664
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.
Definition Validators.hpp:678
std::string & trim(std::string &str)
Trim whitespace from string.
Definition StringTools.hpp:138
std::string generate_set(const T &set)
Generate a string representation of a set.
Definition Validators.hpp:578
std::pair< std::string, std::string > split_program_name(std::string commandline)
Definition Validators.hpp:1126
std::string & ltrim(std::string &str)
Trim whitespace from left of string.
Definition StringTools.hpp:109
auto search(const T &set, const V &val) -> std::pair< bool, decltype(std::begin(detail::smart_deref(set)))>
A search function.
Definition Validators.hpp:622
std::string find_and_replace(std::string str, std::string from, std::string to)
Find and replace a substring with another substring.
Definition StringTools.hpp:273
std::vector< std::string > split(const std::string &s, char delim)
Split a string by a delim.
Definition StringTools.hpp:46
bool embeddedQuote
Definition StringTools.hpp:355
char keyChar
Definition StringTools.hpp:356
enabler
Simple empty scoped class.
Definition TypeTools.hpp:31
bool lexical_cast(const std::string &input, T &output)
Integer conversion.
Definition TypeTools.hpp:883
std::string ignore_case(std::string item)
Helper function to allow ignore_case to be passed to IsMember or Transform.
Definition Validators.hpp:909
std::string ignore_underscore(std::string item)
Helper function to allow ignore_underscore to be passed to IsMember or Transform.
Definition Validators.hpp:912
const detail::ExistingDirectoryValidator ExistingDirectory
Check for an existing directory (returns error message if check fails)
Definition Validators.hpp:436
typename std::enable_if< B, T >::type enable_if_t
Definition TypeTools.hpp:42
const detail::NonexistentPathValidator NonexistentPath
Check for an non-existing path.
Definition Validators.hpp:442
const detail::IPV4Validator ValidIPV4
Check for an IP4 address.
Definition Validators.hpp:445
const detail::ExistingPathValidator ExistingPath
Check for an existing path.
Definition Validators.hpp:439
const detail::ExistingFileValidator ExistingFile
Check for existing file (returns error message if check fails)
Definition Validators.hpp:433
const Range NonNegativeNumber((std::numeric_limits< double >::max)(), "NONNEGATIVE")
Check for a non negative number.
std::string ignore_space(std::string item)
Helper function to allow checks to ignore spaces to be passed to IsMember or Transform.
Definition Validators.hpp:915
const Range 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.
const TypeValidator< double > Number("NUMBER")
Check for a number.
std::vector< std::pair< std::string, T > > TransformPairs
definition of the default transformation object
Definition Validators.hpp:772
T type
Definition TypeTools.hpp:74
T type
Definition TypeTools.hpp:87
Definition Validators.hpp:611
std::integral_constant< bool, value > type
Definition Validators.hpp:617
static auto test(int) -> decltype(std::declval< CC >().find(std::declval< VV >()), std::true_type())
static auto test(...) -> decltype(std::false_type())
Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost ...
Definition TypeTools.hpp:98
typename T::value_type value_type
Definition TypeTools.hpp:99
typename std::remove_const< value_type >::type first_type
Definition TypeTools.hpp:100