47template <
bool B,
class T =
void>
using enable_if_t =
typename std::enable_if<B, T>::type;
58template <
bool B,
class T,
class F>
using conditional_t =
typename std::conditional<B, T, F>::type;
61template <
typename T>
struct is_bool : std::false_type {};
64template <>
struct is_bool<bool> : std::true_type {};
70template <
typename T>
struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
73template <
typename T>
struct is_shared_ptr<const std::shared_ptr<T>> : std::true_type {};
97 template <
typename TT,
typename SS>
98 static auto test(
int) ->
decltype(lexical_cast(std::declval<const SS &>(), std::declval<TT &>()), std::true_type());
100 template <
typename,
typename>
static auto test(...) -> std::false_type;
119template <
typename T>
struct element_type<T, typename std::enable_if<is_copyable_ptr<T>::value>::type> {
120 using type =
typename std::pointer_traits<T>::element_type;
130template <
typename T,
typename _ =
void>
struct pair_adaptor : std::false_type {
132 using first_type =
typename std::remove_const<value_type>::type;
136 template <
typename Q>
static auto first(Q &&pair_value) ->
decltype(std::forward<Q>(pair_value)) {
137 return std::forward<Q>(pair_value);
140 template <
typename Q>
static auto second(Q &&pair_value) ->
decltype(std::forward<Q>(pair_value)) {
141 return std::forward<Q>(pair_value);
153 using first_type =
typename std::remove_const<typename value_type::first_type>::type;
154 using second_type =
typename std::remove_const<typename value_type::second_type>::type;
157 template <
typename Q>
static auto first(Q &&pair_value) ->
decltype(std::get<0>(std::forward<Q>(pair_value))) {
158 return std::get<0>(std::forward<Q>(pair_value));
161 template <
typename Q>
static auto second(Q &&pair_value) ->
decltype(std::get<1>(std::forward<Q>(pair_value))) {
162 return std::get<1>(std::forward<Q>(pair_value));
173#pragma GCC diagnostic push
174#pragma GCC diagnostic ignored "-Wnarrowing"
178 template <
typename TT,
typename CC>
179 static auto test(
int, std::true_type) ->
decltype(
182#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
183#pragma nv_diag_suppress 2361
185#pragma diag_suppress 2361
188 TT{std::declval<CC>()}
190#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
191#pragma nv_diag_default 2361
193#pragma diag_default 2361
197 std::is_move_assignable<TT>());
199 template <
typename TT,
typename CC>
static auto test(
int, std::false_type) -> std::false_type;
201 template <
typename,
typename>
static auto test(...) -> std::false_type;
204 static constexpr bool value =
decltype(test<T, C>(0,
typename std::is_constructible<T, C>::type()))
::value;
207#pragma GCC diagnostic pop
214 template <
typename TT,
typename SS>
215 static auto test(
int) ->
decltype(std::declval<SS &>() << std::declval<TT>(), std::true_type());
217 template <
typename,
typename>
static auto test(...) -> std::false_type;
225 template <
typename TT,
typename SS>
226 static auto test(
int) ->
decltype(std::declval<SS &>() >> std::declval<TT &>(), std::true_type());
228 template <
typename,
typename>
static auto test(...) -> std::false_type;
236 template <
typename TT>
237 static auto test(
int) ->
decltype(std::declval<TT>().real(), std::declval<TT>().imag(), std::true_type());
239 template <
typename>
static auto test(...) -> std::false_type;
248 std::istringstream is;
251 return !is.fail() && !is.rdbuf()->in_avail();
269 void_t<typename T::value_type,
270 decltype(std::declval<T>().end()),
271 decltype(std::declval<T>().clear()),
272 decltype(std::declval<T>().insert(std::declval<decltype(std::declval<T>().end())>(),
273 std::declval<const typename T::value_type &>()))>,
274 void>> :
public conditional_t<std::is_constructible<T, std::string>::value ||
275 std::is_constructible<T, std::wstring>::value,
289 :
public std::true_type {};
292template <
typename T,
typename _ =
void>
struct is_wrapper : std::false_type {};
300 template <
typename SS>
303 static auto test(
int) ->
decltype(std::tuple_size<typename std::decay<SS>::type>
::value, std::true_type{});
304 template <
typename>
static auto test(...) -> std::false_type;
312auto to_string(T &&value) ->
decltype(std::forward<T>(value)) {
313 return std::forward<T>(value);
321 return std::string(value);
330 std::stringstream stream;
338 !is_readable_container<typename std::remove_const<T>::type>::value,
347 is_readable_container<T>::value,
350 auto cval = variable.begin();
351 auto end = variable.end();
355 std::vector<std::string> defaults;
364template <
typename T1,
369 return to_string(std::forward<T>(value));
373template <
typename T1,
378 return std::string{};
383 return std::to_string(value);
388 return std::to_string(
static_cast<typename std::underlying_type<T>::type
>(value));
398template <
typename T,
typename def,
typename Enable =
void>
struct wrapped_type {
403template <
typename T,
typename def>
struct wrapped_type<T, def, typename std::enable_if<is_wrapper<T>::value>::type> {
404 using type =
typename T::value_type;
415 typename std::enable_if<!is_tuple_like<T>::value && !is_mutable_container<T>::value &&
416 !std::is_void<T>::value>::type> {
422struct type_count_base<T, typename std::enable_if<is_tuple_like<T>::value && !is_mutable_container<T>::value>::type> {
423 static constexpr int value{std::tuple_size<T>::value};
427template <
typename T>
struct type_count_base<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
440template <
typename T,
typename Enable =
void>
struct type_count {
447 typename std::enable_if<!is_wrapper<T>::value && !is_tuple_like<T>::value && !is_complex<T>::value &&
448 !std::is_void<T>::value>::type> {
453template <
typename T>
struct type_count<T, typename std::enable_if<is_complex<T>::value>::type> {
458template <
typename T>
struct type_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
465 typename std::enable_if<is_wrapper<T>::value && !is_complex<T>::value && !is_tuple_like<T>::value &&
466 !is_mutable_container<T>::value>::type> {
471template <
typename T, std::
size_t I>
472constexpr typename std::enable_if<I == type_count_base<T>::value,
int>::type
tuple_type_size() {
477template <
typename T, std::
size_t I>
478 constexpr typename std::enable_if < I<type_count_base<T>::value,
int>::type
tuple_type_size() {
483template <
typename T>
struct type_count<T, typename std::enable_if<is_tuple_like<T>::value>::type> {
488template <
typename T>
struct subtype_count {
493template <
typename T,
typename Enable =
void>
struct type_count_min {
494 static const int value{0};
499struct type_count_min<
501 typename std::enable_if<!is_mutable_container<T>::value && !is_tuple_like<T>::value && !is_wrapper<T>::value &&
502 !is_complex<T>::value && !std::is_void<T>::value>::type> {
503 static constexpr int value{type_count<T>::value};
507template <
typename T>
struct type_count_min<T, typename std::enable_if<is_complex<T>::value>::type> {
508 static constexpr int value{1};
513struct type_count_min<
515 typename std::enable_if<is_wrapper<T>::value && !is_complex<T>::value && !is_tuple_like<T>::value>::type> {
516 static constexpr int value{subtype_count_min<typename T::value_type>::value};
520template <
typename T, std::
size_t I>
521constexpr typename std::enable_if<I == type_count_base<T>::value,
int>::type tuple_type_size_min() {
526template <
typename T, std::
size_t I>
527 constexpr typename std::enable_if < I<type_count_base<T>::value,
int>::type tuple_type_size_min() {
528 return subtype_count_min<typename std::tuple_element<I, T>::type>::value + tuple_type_size_min<T, I + 1>();
532template <
typename T>
struct type_count_min<T, typename std::enable_if<is_tuple_like<T>::value>::type> {
533 static constexpr int value{tuple_type_size_min<T, 0>()};
537template <
typename T>
struct subtype_count_min {
538 static constexpr int value{is_mutable_container<T>::value
540 : type_count_min<T>::value};
544template <
typename T,
typename Enable =
void>
struct expected_count {
545 static const int value{0};
550struct expected_count<T,
551 typename std::enable_if<!is_mutable_container<T>::value && !is_wrapper<T>::value &&
552 !std::is_void<T>::value>::type> {
553 static constexpr int value{1};
556template <
typename T>
struct expected_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
562struct expected_count<T, typename std::enable_if<!is_mutable_container<T>::value && is_wrapper<T>::value>::type> {
563 static constexpr int value{expected_count<typename T::value_type>::value};
567enum class object_category :
int {
570 unsigned_integral = 4,
574 number_constructible = 12,
575 double_constructible = 14,
576 integer_constructible = 16,
578 string_assignable = 23,
579 string_constructible = 24,
580 wstring_assignable = 25,
581 wstring_constructible = 26,
587 container_value = 80,
594template <
typename T,
typename Enable =
void>
struct classify_object {
595 static constexpr object_category value{object_category::other};
600struct classify_object<
602 typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, char>::value && std::is_signed<T>::value &&
603 !is_bool<T>::value && !std::is_enum<T>::value>::type> {
604 static constexpr object_category value{object_category::integral_value};
609struct classify_object<T,
610 typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value &&
611 !std::is_same<T, char>::value && !is_bool<T>::value>::type> {
612 static constexpr object_category value{object_category::unsigned_integral};
617struct classify_object<T, typename std::enable_if<std::is_same<T, char>::value && !std::is_enum<T>::value>::type> {
618 static constexpr object_category value{object_category::char_value};
622template <
typename T>
struct classify_object<T, typename std::enable_if<is_bool<T>::value>::type> {
623 static constexpr object_category value{object_category::boolean_value};
627template <
typename T>
struct classify_object<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
628 static constexpr object_category value{object_category::floating_point};
633#define WIDE_STRING_CHECK \
634 !std::is_assignable<T &, std::wstring>::value && !std::is_constructible<T, std::wstring>::value
635#define STRING_CHECK true
637#define WIDE_STRING_CHECK true
638#define STRING_CHECK !std::is_assignable<T &, std::string>::value && !std::is_constructible<T, std::string>::value
643struct classify_object<
645 typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value && WIDE_STRING_CHECK &&
646 std::is_assignable<T &, std::string>::value>::type> {
647 static constexpr object_category value{object_category::string_assignable};
652struct classify_object<
654 typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
655 !std::is_assignable<T &, std::string>::value && (type_count<T>::value == 1) &&
656 WIDE_STRING_CHECK && std::is_constructible<T, std::string>::value>::type> {
657 static constexpr object_category value{object_category::string_constructible};
662struct classify_object<T,
663 typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
664 STRING_CHECK && std::is_assignable<T &, std::wstring>::value>::type> {
665 static constexpr object_category value{object_category::wstring_assignable};
669struct classify_object<
671 typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
672 !std::is_assignable<T &, std::wstring>::value && (type_count<T>::value == 1) &&
673 STRING_CHECK && std::is_constructible<T, std::wstring>::value>::type> {
674 static constexpr object_category value{object_category::wstring_constructible};
678template <
typename T>
struct classify_object<T, typename std::enable_if<std::is_enum<T>::value>::type> {
679 static constexpr object_category value{object_category::enumeration};
682template <
typename T>
struct classify_object<T, typename std::enable_if<is_complex<T>::value>::type> {
683 static constexpr object_category value{object_category::complex_number};
688template <
typename T>
struct uncommon_type {
689 using type =
typename std::conditional<
690 !std::is_floating_point<T>::value && !std::is_integral<T>::value &&
691 !std::is_assignable<T &, std::string>::value && !std::is_constructible<T, std::string>::value &&
692 !std::is_assignable<T &, std::wstring>::value && !std::is_constructible<T, std::wstring>::value &&
693 !is_complex<T>::value && !is_mutable_container<T>::value && !std::is_enum<T>::value,
695 std::false_type>::type;
696 static constexpr bool value = type::value;
701struct classify_object<T,
702 typename std::enable_if<(!is_mutable_container<T>::value && is_wrapper<T>::value &&
703 !is_tuple_like<T>::value && uncommon_type<T>::value)>::type> {
704 static constexpr object_category value{object_category::wrapper_value};
709struct classify_object<T,
710 typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
711 !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
712 is_direct_constructible<T, int>::value>::type> {
713 static constexpr object_category value{object_category::number_constructible};
718struct classify_object<T,
719 typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
720 !is_wrapper<T>::value && !is_direct_constructible<T, double>::value &&
721 is_direct_constructible<T, int>::value>::type> {
722 static constexpr object_category value{object_category::integer_constructible};
727struct classify_object<T,
728 typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
729 !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
730 !is_direct_constructible<T, int>::value>::type> {
731 static constexpr object_category value{object_category::double_constructible};
736struct classify_object<
738 typename std::enable_if<is_tuple_like<T>::value &&
739 ((type_count<T>::value >= 2 && !is_wrapper<T>::value) ||
740 (uncommon_type<T>::value && !is_direct_constructible<T, double>::value &&
741 !is_direct_constructible<T, int>::value) ||
742 (uncommon_type<T>::value && type_count<T>::value >= 2))>::type> {
743 static constexpr object_category value{object_category::tuple_value};
752template <
typename T>
struct classify_object<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
753 static constexpr object_category value{object_category::container_value};
764constexpr const char *type_name() {
769 enable_if_t<classify_object<T>::value == object_category::integral_value ||
770 classify_object<T>::value == object_category::integer_constructible,
772constexpr const char *type_name() {
778constexpr const char *type_name() {
783 enable_if_t<classify_object<T>::value == object_category::floating_point ||
784 classify_object<T>::value == object_category::number_constructible ||
785 classify_object<T>::value == object_category::double_constructible,
787constexpr const char *type_name() {
794constexpr const char *type_name() {
801constexpr const char *type_name() {
808constexpr const char *type_name() {
814 enable_if_t<classify_object<T>::value >= object_category::string_assignable &&
815 classify_object<T>::value <= object_category::other,
817constexpr const char *type_name() {
824std::string type_name();
828 enable_if_t<classify_object<T>::value == object_category::container_value ||
829 classify_object<T>::value == object_category::wrapper_value,
831std::string type_name();
837inline std::string type_name() {
838 return type_name<typename std::decay<typename std::tuple_element<0, T>::type>::type>();
842template <
typename T, std::
size_t I>
843inline typename std::enable_if<I == type_count_base<T>::value, std::string>::type tuple_name() {
844 return std::string{};
848template <
typename T, std::
size_t I>
849inline typename std::enable_if<(I < type_count_base<T>::value), std::string>::type tuple_name() {
850 auto str = std::string{type_name<typename std::decay<typename std::tuple_element<I, T>::type>::type>()} +
',' +
851 tuple_name<T, I + 1>();
852 if(str.back() ==
',')
861inline std::string type_name() {
862 auto tname = std::string(1,
'[') + tuple_name<T, 0>();
863 tname.push_back(
']');
869 enable_if_t<classify_object<T>::value == object_category::container_value ||
870 classify_object<T>::value == object_category::wrapper_value,
872inline std::string type_name() {
873 return type_name<typename T::value_type>();
881 if(input.empty() || input.front() ==
'-') {
886 std::uint64_t output_ll = std::strtoull(input.c_str(), &val, 0);
887 if(errno == ERANGE) {
890 output =
static_cast<T
>(output_ll);
891 if(val == (input.c_str() + input.size()) &&
static_cast<std::uint64_t
>(output) == output_ll) {
895 std::int64_t output_sll = std::strtoll(input.c_str(), &val, 0);
896 if(val == (input.c_str() + input.size())) {
897 output = (output_sll < 0) ? static_cast<T>(0) : static_cast<T>(output_sll);
898 return (
static_cast<std::int64_t
>(output) == output_sll);
901 if(input.find_first_of(
"_'") != std::string::npos) {
902 std::string nstring = input;
903 nstring.erase(std::remove(nstring.begin(), nstring.end(),
'_'), nstring.end());
904 nstring.erase(std::remove(nstring.begin(), nstring.end(),
'\''), nstring.end());
905 return integral_conversion(nstring, output);
907 if(input.compare(0, 2,
"0o") == 0) {
910 output_ll = std::strtoull(input.c_str() + 2, &val, 8);
911 if(errno == ERANGE) {
914 output =
static_cast<T
>(output_ll);
915 return (val == (input.c_str() + input.size()) &&
static_cast<std::uint64_t
>(output) == output_ll);
917 if(input.compare(0, 2,
"0b") == 0) {
920 output_ll = std::strtoull(input.c_str() + 2, &val, 2);
921 if(errno == ERANGE) {
924 output =
static_cast<T
>(output_ll);
925 return (val == (input.c_str() + input.size()) &&
static_cast<std::uint64_t
>(output) == output_ll);
938 std::int64_t output_ll = std::strtoll(input.c_str(), &val, 0);
939 if(errno == ERANGE) {
942 output =
static_cast<T
>(output_ll);
943 if(val == (input.c_str() + input.size()) &&
static_cast<std::int64_t
>(output) == output_ll) {
946 if(input ==
"true") {
948 output =
static_cast<T
>(1);
952 if(input.find_first_of(
"_'") != std::string::npos) {
953 std::string nstring = input;
954 nstring.erase(std::remove(nstring.begin(), nstring.end(),
'_'), nstring.end());
955 nstring.erase(std::remove(nstring.begin(), nstring.end(),
'\''), nstring.end());
958 if(input.compare(0, 2,
"0o") == 0) {
961 output_ll = std::strtoll(input.c_str() + 2, &val, 8);
962 if(errno == ERANGE) {
965 output =
static_cast<T
>(output_ll);
966 return (val == (input.c_str() + input.size()) &&
static_cast<std::int64_t
>(output) == output_ll);
968 if(input.compare(0, 2,
"0b") == 0) {
971 output_ll = std::strtoll(input.c_str() + 2, &val, 2);
972 if(errno == ERANGE) {
975 output =
static_cast<T
>(output_ll);
976 return (val == (input.c_str() + input.size()) &&
static_cast<std::int64_t
>(output) == output_ll);
983 static const std::string trueString(
"true");
984 static const std::string falseString(
"false");
985 if(val == trueString) {
988 if(val == falseString) {
992 std::int64_t ret = 0;
993 if(val.size() == 1) {
994 if(val[0] >=
'1' && val[0] <=
'9') {
995 return (
static_cast<std::int64_t
>(val[0]) -
'0');
1015 if(val == trueString || val ==
"on" || val ==
"yes" || val ==
"enable") {
1017 }
else if(val == falseString || val ==
"off" || val ==
"no" || val ==
"disable") {
1020 char *loc_ptr{
nullptr};
1021 ret = std::strtoll(val.c_str(), &loc_ptr, 0);
1022 if(loc_ptr != (val.c_str() + val.size()) && errno == 0) {
1030template <
typename T,
1032 classify_object<T>::value == object_category::unsigned_integral,
1039template <
typename T,
1041bool lexical_cast(
const std::string &input, T &output) {
1042 if(input.size() == 1) {
1043 output =
static_cast<T
>(input[0]);
1050template <
typename T,
1052bool lexical_cast(
const std::string &input, T &output) {
1057 }
else if(errno == ERANGE) {
1058 output = (input[0] !=
'-');
1066template <
typename T,
1068bool lexical_cast(
const std::string &input, T &output) {
1072 char *val =
nullptr;
1073 auto output_ld = std::strtold(input.c_str(), &val);
1074 output =
static_cast<T
>(output_ld);
1075 if(val == (input.c_str() + input.size())) {
1079 if(input.find_first_of(
"_'") != std::string::npos) {
1080 std::string nstring = input;
1081 nstring.erase(std::remove(nstring.begin(), nstring.end(),
'_'), nstring.end());
1082 nstring.erase(std::remove(nstring.begin(), nstring.end(),
'\''), nstring.end());
1089template <
typename T,
1091bool lexical_cast(
const std::string &input, T &output) {
1095 bool worked =
false;
1096 auto nloc = str1.find_last_of(
"+-");
1097 if(nloc != std::string::npos && nloc > 0) {
1099 str1 = str1.substr(nloc);
1100 if(str1.back() ==
'i' || str1.back() ==
'j')
1104 if(str1.back() ==
'i' || str1.back() ==
'j') {
1121template <
typename T,
1123bool lexical_cast(
const std::string &input, T &output) {
1132bool lexical_cast(
const std::string &input, T &output) {
1141bool lexical_cast(
const std::string &input, T &output) {
1142 output =
widen(input);
1149bool lexical_cast(
const std::string &input, T &output) {
1150 output = T{
widen(input)};
1155template <
typename T,
1157bool lexical_cast(
const std::string &input, T &output) {
1158 typename std::underlying_type<T>::type val;
1162 output =
static_cast<T
>(val);
1167template <
typename T,
1168 enable_if_t<classify_object<T>::value == object_category::wrapper_value &&
1169 std::is_assignable<T &, typename T::value_type>::value,
1171bool lexical_cast(
const std::string &input, T &output) {
1172 typename T::value_type val;
1180template <
typename T,
1181 enable_if_t<classify_object<T>::value == object_category::wrapper_value &&
1182 !std::is_assignable<T &, typename T::value_type>::value && std::is_assignable<T &, T>::value,
1184bool lexical_cast(
const std::string &input, T &output) {
1185 typename T::value_type val;
1197bool lexical_cast(
const std::string &input, T &output) {
1217bool lexical_cast(
const std::string &input, T &output) {
1230bool lexical_cast(
const std::string &input, T &output) {
1240template <
typename T,
1241 enable_if_t<classify_object<T>::value == object_category::other && std::is_assignable<T &, int>::value,
1243bool lexical_cast(
const std::string &input, T &output) {
1247#pragma warning(push)
1248#pragma warning(disable : 4800)
1266template <
typename T,
1267 enable_if_t<classify_object<T>::value == object_category::other && !std::is_assignable<T &, int>::value &&
1270bool lexical_cast(
const std::string &input, T &output) {
1276template <
typename T,
1277 enable_if_t<classify_object<T>::value == object_category::other && !std::is_assignable<T &, int>::value &&
1281 static_assert(!std::is_same<T, T>::value,
1282 "option object type must have a lexical cast overload or streaming input operator(>>) defined, if it "
1283 "is convertible from another type use the add_option<T, XC>(...) with XC being the known type");
1289template <
typename AssignTo,
1291 enable_if_t<std::is_same<AssignTo, ConvertTo>::value &&
1292 (classify_object<AssignTo>::value == object_category::string_assignable ||
1293 classify_object<AssignTo>::value == object_category::string_constructible ||
1294 classify_object<AssignTo>::value == object_category::wstring_assignable ||
1295 classify_object<AssignTo>::value == object_category::wstring_constructible),
1302template <
typename AssignTo,
1305 classify_object<AssignTo>::value != object_category::string_assignable &&
1306 classify_object<AssignTo>::value != object_category::string_constructible &&
1307 classify_object<AssignTo>::value != object_category::wstring_assignable &&
1308 classify_object<AssignTo>::value != object_category::wstring_constructible,
1312 output = AssignTo{};
1320template <
typename AssignTo,
1322 enable_if_t<std::is_same<AssignTo, ConvertTo>::value && !std::is_assignable<AssignTo &, AssignTo>::value &&
1323 classify_object<AssignTo>::value == object_category::wrapper_value,
1327 typename AssignTo::value_type emptyVal{};
1336template <
typename AssignTo,
1338 enable_if_t<std::is_same<AssignTo, ConvertTo>::value && !std::is_assignable<AssignTo &, AssignTo>::value &&
1339 classify_object<AssignTo>::value != object_category::wrapper_value &&
1340 std::is_assignable<AssignTo &, int>::value,
1349#if defined(__clang__)
1351#pragma clang diagnostic push
1352#pragma clang diagnostic ignored "-Wsign-conversion"
1355#if defined(__clang__)
1356#pragma clang diagnostic pop
1364template <
typename AssignTo,
1366 enable_if_t<!std::is_same<AssignTo, ConvertTo>::value && std::is_assignable<AssignTo &, ConvertTo &>::value,
1370 bool parse_result = (!input.empty()) ?
lexical_cast(input, val) : true;
1374 return parse_result;
1381 enable_if_t<!std::is_same<AssignTo, ConvertTo>::value && !std::is_assignable<AssignTo &, ConvertTo &>::value &&
1382 std::is_move_assignable<AssignTo>::value,
1386 bool parse_result = input.empty() ? true :
lexical_cast(input, val);
1388 output = AssignTo(val);
1390 return parse_result;
1394template <
typename AssignTo,
1396 enable_if_t<classify_object<ConvertTo>::value <= object_category::other &&
1397 classify_object<AssignTo>::value <= object_category::wrapper_value,
1399bool lexical_conversion(
const std::vector<std ::string> &strings, AssignTo &output) {
1405template <
typename AssignTo,
1410bool lexical_conversion(
const std::vector<std ::string> &strings, AssignTo &output) {
1412 using FirstType =
typename std::remove_const<typename std::tuple_element<0, ConvertTo>::type>::type;
1413 using SecondType =
typename std::tuple_element<1, ConvertTo>::type;
1419 output = AssignTo{v1, v2};
1425template <
class AssignTo,
1427 enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
1430bool lexical_conversion(
const std::vector<std ::string> &strings, AssignTo &output) {
1431 output.erase(output.begin(), output.end());
1432 if(strings.empty()) {
1435 if(strings.size() == 1 && strings[0] ==
"{}") {
1438 bool skip_remaining =
false;
1439 if(strings.size() == 2 && strings[0] ==
"{}" &&
is_separator(strings[1])) {
1440 skip_remaining =
true;
1442 for(
const auto &elem : strings) {
1443 typename AssignTo::value_type out;
1448 output.insert(output.end(), std::move(out));
1449 if(skip_remaining) {
1453 return (!output.empty());
1458bool lexical_conversion(
const std::vector<std::string> &strings, AssignTo &output) {
1460 if(strings.size() >= 2 && !strings[1].empty()) {
1463 auto str1 = strings[1];
1464 if(str1.back() ==
'i' || str1.back() ==
'j') {
1469 output = ConvertTo{x, y};
1477template <
class AssignTo,
1479 enable_if_t<is_mutable_container<AssignTo>::value && (expected_count<ConvertTo>::value == 1) &&
1482bool lexical_conversion(
const std::vector<std ::string> &strings, AssignTo &output) {
1485 output.reserve(strings.size());
1486 for(
const auto &elem : strings) {
1488 output.emplace_back();
1491 return (!output.empty()) && retval;
1497template <
class AssignTo,
1499 enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
1502bool lexical_conversion(std::vector<std::string> strings, AssignTo &output);
1505template <
class AssignTo,
1507 enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
1512bool lexical_conversion(
const std::vector<std::string> &strings, AssignTo &output);
1515template <
class AssignTo,
1521bool lexical_conversion(
const std::vector<std::string> &strings, AssignTo &output);
1525template <
typename AssignTo,
1527 enable_if_t<!is_tuple_like<AssignTo>::value && !is_mutable_container<AssignTo>::value &&
1528 classify_object<ConvertTo>::value != object_category::wrapper_value &&
1531bool lexical_conversion(
const std::vector<std ::string> &strings, AssignTo &output) {
1533 if(strings.size() > 1 || (!strings.empty() && !(strings.front().empty()))) {
1535 auto retval = lexical_conversion<ConvertTo, ConvertTo>(strings, val);
1536 output = AssignTo{val};
1539 output = AssignTo{};
1544template <
class AssignTo,
class ConvertTo, std::
size_t I>
1546tuple_conversion(
const std::vector<std::string> &, AssignTo &) {
1551template <
class AssignTo,
class ConvertTo>
1553tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
1555 strings.erase(strings.begin());
1560template <
class AssignTo,
class ConvertTo>
1564tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
1565 auto retval = lexical_conversion<AssignTo, ConvertTo>(strings, output);
1571template <
class AssignTo,
class ConvertTo>
1572inline typename std::enable_if<is_mutable_container<ConvertTo>::value ||
1575tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
1577 std::size_t index{subtype_count_min<ConvertTo>::value};
1578 const std::size_t mx_count{subtype_count<ConvertTo>::value};
1579 const std::size_t mx{(std::min)(mx_count, strings.size() - 1)};
1587 bool retval = lexical_conversion<AssignTo, ConvertTo>(
1588 std::vector<std::string>(strings.begin(), strings.begin() +
static_cast<std::ptrdiff_t
>(index)), output);
1589 if(strings.size() > index) {
1590 strings.erase(strings.begin(), strings.begin() +
static_cast<std::ptrdiff_t
>(index) + 1);
1598template <
class AssignTo,
class ConvertTo, std::
size_t I>
1599inline typename std::enable_if<(I < type_count_base<AssignTo>::value),
bool>::type
1600tuple_conversion(std::vector<std::string> strings, AssignTo &output) {
1602 using ConvertToElement =
typename std::
1603 conditional<is_tuple_like<ConvertTo>::value,
typename std::tuple_element<I, ConvertTo>::type, ConvertTo>::type;
1604 if(!strings.empty()) {
1605 retval = retval && tuple_type_conversion<typename std::tuple_element<I, AssignTo>::type, ConvertToElement>(
1606 strings, std::get<I>(output));
1608 retval = retval && tuple_conversion<AssignTo, ConvertTo, I + 1>(std::move(strings), output);
1613template <
class AssignTo,
1615 enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
1618bool lexical_conversion(std::vector<std::string> strings, AssignTo &output) {
1620 while(!strings.empty()) {
1622 typename std::remove_const<typename std::tuple_element<0, typename ConvertTo::value_type>::type>::type v1;
1623 typename std::tuple_element<1, typename ConvertTo::value_type>::type v2;
1624 bool retval = tuple_type_conversion<decltype(v1), decltype(v1)>(strings, v1);
1625 if(!strings.empty()) {
1626 retval = retval && tuple_type_conversion<decltype(v2), decltype(v2)>(strings, v2);
1629 output.insert(output.end(),
typename AssignTo::value_type{v1, v2});
1634 return (!output.empty());
1638template <
class AssignTo,
1644bool lexical_conversion(
const std::vector<std ::string> &strings, AssignTo &output) {
1647 "if the conversion type is defined as a tuple it must be the same size as the type you are converting to");
1648 return tuple_conversion<AssignTo, ConvertTo, 0>(strings, output);
1652template <
class AssignTo,
1654 enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
1659bool lexical_conversion(
const std::vector<std ::string> &strings, AssignTo &output) {
1662 std::vector<std::string> temp;
1664 std::size_t icount{0};
1666 auto ii_max = strings.size();
1667 while(ii < ii_max) {
1668 temp.push_back(strings[ii]);
1671 if(icount == xcm ||
is_separator(temp.back()) || ii == ii_max) {
1672 if(
static_cast<int>(xcm) > type_count_min<ConvertTo>::value &&
is_separator(temp.back())) {
1675 typename AssignTo::value_type temp_out;
1677 lexical_conversion<typename AssignTo::value_type, typename ConvertTo::value_type>(temp, temp_out);
1682 output.insert(output.end(), std::move(temp_out));
1690template <
typename AssignTo,
1692 enable_if_t<classify_object<ConvertTo>::value == object_category::wrapper_value &&
1693 std::is_assignable<ConvertTo &, ConvertTo>::value,
1695bool lexical_conversion(
const std::vector<std::string> &strings, AssignTo &output) {
1696 if(strings.empty() || strings.front().empty()) {
1697 output = ConvertTo{};
1700 typename ConvertTo::value_type val;
1701 if(lexical_conversion<typename ConvertTo::value_type, typename ConvertTo::value_type>(strings, val)) {
1702 output = ConvertTo{val};
1709template <
typename AssignTo,
1711 enable_if_t<classify_object<ConvertTo>::value == object_category::wrapper_value &&
1712 !std::is_assignable<AssignTo &, ConvertTo>::value,
1714bool lexical_conversion(
const std::vector<std::string> &strings, AssignTo &output) {
1715 using ConvertType =
typename ConvertTo::value_type;
1716 if(strings.empty() || strings.front().empty()) {
1717 output = ConvertType{};
1721 if(lexical_conversion<typename ConvertTo::value_type, typename ConvertTo::value_type>(strings, val)) {
1729inline std::string sum_string_vector(
const std::vector<std::string> &values) {
1733 for(
const auto &arg : values) {
1739 fail = (errno != 0);
1743 tv =
static_cast<double>(fv);
1748 for(
const auto &arg : values) {
1752 std::ostringstream out;
Definition TypeTools.hpp:96
static constexpr bool value
Definition TypeTools.hpp:103
Check for complex.
Definition TypeTools.hpp:235
static constexpr bool value
Definition TypeTools.hpp:242
Definition TypeTools.hpp:177
static constexpr bool value
Definition TypeTools.hpp:204
Check for input streamability.
Definition TypeTools.hpp:224
static constexpr bool value
Definition TypeTools.hpp:231
Definition TypeTools.hpp:213
static constexpr bool value
Definition TypeTools.hpp:220
Definition TypeTools.hpp:299
static constexpr bool value
Definition TypeTools.hpp:307
constexpr enabler dummy
An instance to use in EnableIf.
Definition TypeTools.hpp:39
auto to_string(T &&value) -> decltype(std::forward< T >(value))
Convert an object to a string (directly forward if this can become a string)
Definition TypeTools.hpp:312
auto checked_to_string(T &&value) -> decltype(to_string(std::forward< T >(value)))
special template overload
Definition TypeTools.hpp:368
return false
Definition TypeTools.hpp:927
bool is_separator(const std::string &str)
check if a string is a container segment separator (empty or "%%")
Definition StringTools.hpp:170
bool from_stream(const std::string &istring, T &obj)
Templated operation to get a value from a stream.
Definition TypeTools.hpp:247
return(val==(input.c_str()+input.size()) &&static_cast< std::uint64_t >(output)==output_ll)
constexpr int expected_max_vector_size
Definition StringTools.hpp:47
std::string value_string(const T &value)
get a string as a convertible value for arithmetic types
Definition TypeTools.hpp:382
std::string join(const T &v, std::string delim=",")
Simple function to join a string.
Definition StringTools.hpp:53
bool lexical_assign(const std::string &input, AssignTo &output)
Assign a value through lexical cast operations.
Definition TypeTools.hpp:1297
std::int64_t to_flag_value(std::string val) noexcept
Convert a flag into an integer value typically binary flags sets errno to nonzero if conversion faile...
Definition TypeTools.hpp:982
std::string to_lower(std::string str)
Return a lower case version of a string.
Definition StringTools.hpp:181
enabler
Simple empty scoped class.
Definition TypeTools.hpp:36
bool lexical_cast(const std::string &input, T &output)
Integer conversion.
Definition TypeTools.hpp:1034
bool integral_conversion(const std::string &input, T &output) noexcept
Convert to a signed integral.
Definition TypeTools.hpp:932
constexpr std::enable_if< I==type_count_base< T >::value, int >::type tuple_type_size()
0 if the index > tuple size
Definition TypeTools.hpp:472
typename make_void< Ts... >::type void_t
A copy of std::void_t from C++17 - same reasoning as enable_if_t, it does not hurt to redefine.
Definition TypeTools.hpp:55
typename std::enable_if< B, T >::type enable_if_t
Definition TypeTools.hpp:47
typename std::conditional< B, T, F >::type conditional_t
A copy of std::conditional_t from C++14 - same reasoning as enable_if_t, it does not hurt to redefine...
Definition TypeTools.hpp:58
CLI11_INLINE std::wstring widen(const std::string &str)
Convert a narrow string to a wide string.
std::string type
Definition TypeTools.hpp:87
This can be specialized to override the type deduction for IsMember.
Definition TypeTools.hpp:81
T type
Definition TypeTools.hpp:82
typename std::pointer_traits< T >::element_type type
Definition TypeTools.hpp:120
not a pointer
Definition TypeTools.hpp:115
T type
Definition TypeTools.hpp:116
Definition TypeTools.hpp:125
typename element_type< T >::type::value_type type
Definition TypeTools.hpp:126
Definition TypeTools.hpp:260
Definition TypeTools.hpp:280
Definition TypeTools.hpp:292
typename std::remove_const< typename value_type::first_type >::type first_type
Definition TypeTools.hpp:153
static auto first(Q &&pair_value) -> decltype(std::get< 0 >(std::forward< Q >(pair_value)))
Get the first value (really just the underlying value)
Definition TypeTools.hpp:157
static auto second(Q &&pair_value) -> decltype(std::get< 1 >(std::forward< Q >(pair_value)))
Get the second value (really just the underlying value)
Definition TypeTools.hpp:161
typename T::value_type value_type
Definition TypeTools.hpp:152
typename std::remove_const< typename value_type::second_type >::type second_type
Definition TypeTools.hpp:154
Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost ...
Definition TypeTools.hpp:130
typename T::value_type value_type
Definition TypeTools.hpp:131
typename std::remove_const< value_type >::type second_type
Definition TypeTools.hpp:133
static auto second(Q &&pair_value) -> decltype(std::forward< Q >(pair_value))
Get the second value (really just the underlying value)
Definition TypeTools.hpp:140
typename std::remove_const< value_type >::type first_type
Definition TypeTools.hpp:132
static auto first(Q &&pair_value) -> decltype(std::forward< Q >(pair_value))
Get the first value (really just the underlying value)
Definition TypeTools.hpp:136
forward declare the subtype_count_min structure
Definition TypeTools.hpp:437
Set of overloads to get the type size of an object.
Definition TypeTools.hpp:434
This will only trigger for actual void type.
Definition TypeTools.hpp:408
static const int value
Definition TypeTools.hpp:409
This will only trigger for actual void type.
Definition TypeTools.hpp:440
static const int value
Definition TypeTools.hpp:441
typename T::value_type type
Definition TypeTools.hpp:404
template to get the underlying value type if it exists or use a default
Definition TypeTools.hpp:398
def type
Definition TypeTools.hpp:399
Check to see if something is bool (fail check by default)
Definition TypeTools.hpp:61
Check to see if something is copyable pointer.
Definition TypeTools.hpp:76
static bool const value
Definition TypeTools.hpp:77
Check to see if something is a shared pointer.
Definition TypeTools.hpp:67
A copy of std::void_t from C++17 (helper for C++11 and C++14)
Definition TypeTools.hpp:50
void type
Definition TypeTools.hpp:51