From a5733080690b2246de83531add1a2b0367a88918 Mon Sep 17 00:00:00 2001
From: Philip Top <phlptp@gmail.com>
Date: Mon, 10 Feb 2020 07:46:55 -0800
Subject: [PATCH] try to work through some issues with complex and other
 containers.

---
 include/CLI/App.hpp       |  23 ++++-
 include/CLI/TypeTools.hpp | 178 ++++++++++++++++++++++++++++----------
 tests/HelpersTest.cpp     |  16 ++--
 tests/NewParseTest.cpp    |   1 +
 tests/OptionTypeTest.cpp  |   8 +-
 tests/OptionalTest.cpp    |   9 +-
 6 files changed, 179 insertions(+), 56 deletions(-)

diff --git a/include/CLI/App.hpp b/include/CLI/App.hpp
index 3622da957..39dcdaa42 100644
--- a/include/CLI/App.hpp
+++ b/include/CLI/App.hpp
@@ -613,6 +613,27 @@ class App {
         return opt;
     }
 
+    /// Add option for assigning to a variable
+    template <typename AssignTo,
+        enable_if_t<!std::is_const<AssignTo>::value, detail::enabler> = detail::dummy>
+        Option *add_option_no_stream(std::string option_name,
+            AssignTo &variable, ///< The variable to set
+            std::string option_description = "") {
+
+        auto fun = [&variable](const CLI::results_t &res) { // comment for spacing
+            return detail::lexical_conversion<AssignTo,AssignTo>(res, variable);
+        };
+
+        Option *opt = add_option(option_name, fun, option_description, false, []() {
+            return std::string{};
+            });
+        opt->type_name(detail::type_name<AssignTo>());
+        opt->type_size(detail::type_count<AssignTo>::value);
+        opt->expected(detail::expected_count<AssignTo>::value);
+        opt->run_callback_for_default();
+        return opt;
+    }
+
     /// Add option for a callback of a specific type
     template <typename T>
     Option *add_option_function(std::string option_name,
@@ -746,7 +767,7 @@ class App {
     /// Other type version accepts all other types that are not vectors such as bool, enum, string or other classes
     /// that can be converted from a string
     template <typename T,
-              enable_if_t<!detail::is_container<T>::value && !std::is_const<T>::value &&
+              enable_if_t<!detail::is_mutable_container<T>::value && !std::is_const<T>::value &&
                               (!std::is_integral<T>::value || is_bool<T>::value) &&
                               !std::is_constructible<std::function<void(int)>, T>::value,
                           detail::enabler> = detail::dummy>
diff --git a/include/CLI/TypeTools.hpp b/include/CLI/TypeTools.hpp
index 6896356a5..dfb6dbb7f 100644
--- a/include/CLI/TypeTools.hpp
+++ b/include/CLI/TypeTools.hpp
@@ -183,6 +183,17 @@ template <typename T, typename S = std::istringstream> class is_istreamable {
     static constexpr bool value = decltype(test<T, S>(0))::value;
 };
 
+    /// Check for complex
+    template <typename T> class is_complex {
+        template <typename TT>
+        static auto test(int) -> decltype(std::declval<TT>().real(), std::declval<TT>().imag(), std::true_type());
+
+        template <typename> static auto test(...)->std::false_type;
+
+    public:
+        static constexpr bool value = decltype(test<T>(0))::value;
+    };
+
 /// Templated operation to get a value from a stream
 template <typename T, enable_if_t<is_istreamable<T>::value, detail::enabler> = detail::dummy>
 bool from_stream(const std::string &istring, T &obj) {
@@ -197,14 +208,14 @@ bool from_stream(const std::string & /*istring*/, T & /*obj*/) {
     return false;
 }
 
-// check to see if an object is a container (fail by default)
-template <typename T, typename _ = void> struct is_container : std::false_type {};
+// check to see if an object is a mutable container (fail by default)
+template <typename T, typename _ = void> struct is_mutable_container : std::false_type {};
 
 /// type trait to test if a type is a container meaning it has a value_type, it has an iterator, a clear, and an en end
 /// methods and an insert function.  And for our purposes we exclude std::string and types that can be constructed from
 /// a std::string
 template <typename T>
-struct is_container<
+struct is_mutable_container<
     T,
     conditional_t<false,
                   void_t<typename T::value_type,
@@ -216,6 +227,22 @@ struct is_container<
                   void>>
     : public conditional_t<std::is_constructible<T, std::string>::value, std::false_type, std::true_type> {};
 
+// check to see if an object is a mutable container (fail by default)
+template <typename T, typename _ = void> struct is_readable_container : std::false_type {};
+
+/// type trait to test if a type is a container meaning it has a value_type, it has an iterator, a clear, and an en end
+/// methods and an insert function.  And for our purposes we exclude std::string and types that can be constructed from
+/// a std::string
+template <typename T>
+struct is_readable_container<
+    T,
+    conditional_t<false,
+    void_t<decltype(std::declval<T>().end()),
+    decltype(std::declval<T>().begin())>,
+    void>>
+    : public std::true_type{};
+
+
 // check to see if an object is a wrapper (fail by default)
 template <typename T, typename _ = void> struct is_wrapper : std::false_type {};
 
@@ -261,22 +288,23 @@ std::string to_string(T &&value) {
 }
 
 /// If conversion is not supported, return an empty string (streaming is not supported for that type)
-template <typename T,
-          enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
-                          !is_container<typename std::remove_reference<typename std::remove_const<T>::type>::type>::value,
-                      detail::enabler> = detail::dummy>
+template <
+    typename T,
+    enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
+                    !is_readable_container<typename std::remove_const<T>::type>::value,
+                detail::enabler> = detail::dummy>
 std::string to_string(T &&) {
     return std::string{};
 }
 
 /// convert a vector to a string
-template <typename T,
-          enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
-                          is_container<typename std::remove_reference<typename std::remove_const<T>::type>::type>::value,
-                      detail::enabler> = detail::dummy>
+template <
+    typename T,
+    enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
+                    is_readable_container<typename std::remove_const<T>::type>::value,
+                detail::enabler> = detail::dummy>
 std::string to_string(T &&variable) {
     std::vector<std::string> defaults;
-    defaults.reserve(variable.size());
     auto cval = variable.begin();
     auto end = variable.end();
     while(cval != end) {
@@ -330,21 +358,21 @@ template <typename T> struct type_count<T, typename std::enable_if<is_tuple_like
 /// Type size for regular object types that do not look like a tuple
 template <typename T>
 struct type_count<T,
-                  typename std::enable_if<!is_container<T>::value && !is_wrapper<T>::value &&
+                  typename std::enable_if<!is_mutable_container<T>::value && !is_wrapper<T>::value &&
                                           !is_tuple_like<T>::value && !std::is_void<T>::value>::type> {
     static constexpr int value{1};
 };
 
 /// Type size of types that look like a container
-template <typename T> struct type_count<T, typename std::enable_if<is_container<T>::value>::type> {
-    static constexpr int value{is_container<typename T::value_type>::value ? expected_max_vector_size
+template <typename T> struct type_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr int value{is_mutable_container<typename T::value_type>::value ? expected_max_vector_size
                                                                            : type_count<typename T::value_type>::value};
 };
 
 /// Type size for wrapper type that are not containers
 template <typename T>
 struct type_count<T,
-                  typename std::enable_if<!is_container<T>::value && is_wrapper<T>::value && !is_tuple_like<T>::value &&
+                  typename std::enable_if<!is_mutable_container<T>::value && is_wrapper<T>::value && !is_tuple_like<T>::value &&
                                           !std::is_void<T>::value>::type> {
     static constexpr int value{type_count<typename T::value_type>::value};
 };
@@ -354,11 +382,11 @@ template <typename T, typename Enable = void> struct expected_count { static con
 
 /// For most types the number of expected items is 1
 template <typename T>
-struct expected_count<T, typename std::enable_if<!is_container<T>::value && !std::is_void<T>::value>::type> {
+struct expected_count<T, typename std::enable_if<!is_mutable_container<T>::value && !std::is_void<T>::value>::type> {
     static constexpr int value{1};
 };
 /// number of expected items in a vector
-template <typename T> struct expected_count<T, typename std::enable_if<is_container<T>::value>::type> {
+template <typename T> struct expected_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
     static constexpr int value{expected_max_vector_size};
 };
 
@@ -372,6 +400,7 @@ enum class object_category : int {
     number_constructible = 12,
     double_constructible = 14,
     integer_constructible = 16,
+    complex_number=22,
     tuple_value = 35,
     wrapper_value = 39,
     container_value = 40,
@@ -435,13 +464,17 @@ template <typename T> struct classify_object<T, typename std::enable_if<std::is_
     static constexpr object_category value{object_category::enumeration};
 };
 
+template <typename T> struct classify_object<T, typename std::enable_if<is_complex<T>::value>::type> {
+    static constexpr object_category value{ object_category::complex_number };
+};
+
 /// Handy helper to contain a bunch of checks that rule out many common types (integers, string like, floating point,
 /// vectors, and enumerations
 template <typename T> struct uncommon_type {
     using type = typename std::conditional<!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_container<T>::value && !std::is_enum<T>::value,
+                                               !std::is_constructible<T, std::string>::value && !is_complex<T>::value &&
+                                               !is_mutable_container<T>::value && !std::is_enum<T>::value,
                                            std::true_type,
                                            std::false_type>::type;
     static constexpr bool value = type::value;
@@ -449,36 +482,35 @@ template <typename T> struct uncommon_type {
 
 /// wrapper type
 template <typename T>
-struct classify_object<
-    T,
-    typename std::enable_if<(!is_container<T>::value && is_wrapper<T>::value && !is_tuple_like<T>::value &&
-        uncommon_type<T>::value)>::type> {
-    static constexpr object_category value{ object_category::wrapper_value };
+struct classify_object<T,
+                       typename std::enable_if<(!is_mutable_container<T>::value && is_wrapper<T>::value &&
+                                                !is_tuple_like<T>::value && uncommon_type<T>::value)>::type> {
+    static constexpr object_category value{object_category::wrapper_value};
 };
 
 /// Assignable from double or int
 template <typename T>
 struct classify_object<T,
-    typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 && !is_wrapper<T>::value &&
-    is_direct_constructible<T, double>::value &&
-    is_direct_constructible<T, int>::value>::type> {
-    static constexpr object_category value{ object_category::number_constructible };
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1  &&
+                                               !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
+                                               is_direct_constructible<T, int>::value>::type> {
+    static constexpr object_category value{object_category::number_constructible};
 };
 
 /// Assignable from int
 template <typename T>
 struct classify_object<T,
-    typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 && !is_wrapper<T>::value &&
-    !is_direct_constructible<T, double>::value &&
-    is_direct_constructible<T, int>::value>::type> {
-    static constexpr object_category value{ object_category::integer_constructible };
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1  &&
+                                               !is_wrapper<T>::value && !is_direct_constructible<T, double>::value &&
+                                               is_direct_constructible<T, int>::value>::type> {
+    static constexpr object_category value{object_category::integer_constructible};
 };
 
 /// Assignable from double
 template <typename T>
 struct classify_object<T,
-                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 && !is_wrapper<T>::value &&
-                                               is_direct_constructible<T, double>::value &&
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
+                                               !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
                                                !is_direct_constructible<T, int>::value>::type> {
     static constexpr object_category value{object_category::double_constructible};
 };
@@ -486,7 +518,7 @@ struct classify_object<T,
 /// Tuple type
 template <typename T>
 struct classify_object<T,
-                       typename std::enable_if<(type_count<T>::value >= 2 && !is_wrapper<T>::value) ||
+                       typename std::enable_if<(type_count<T>::value >= 2 && !is_wrapper<T>::value ) ||
                                                (is_tuple_like<T>::value && uncommon_type<T>::value &&
                                                 !is_direct_constructible<T, double>::value &&
                                                 !is_direct_constructible<T, int>::value)>::type> {
@@ -494,7 +526,7 @@ struct classify_object<T,
 };
 
 /// container type
-template <typename T> struct classify_object<T, typename std::enable_if<is_container<T>::value>::type> {
+template <typename T> struct classify_object<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
     static constexpr object_category value{object_category::container_value};
 };
 
@@ -541,6 +573,13 @@ constexpr const char *type_name() {
     return "BOOLEAN";
 }
 
+/// Print name for enumeration types
+template <typename T,
+    enable_if_t<classify_object<T>::value == object_category::complex_number, detail::enabler> = detail::dummy>
+    constexpr const char *type_name() {
+    return "COMPLEX";
+}
+
 /// Print for all other types
 template <typename T,
           enable_if_t<classify_object<T>::value >= object_category::string_assignable, detail::enabler> = detail::dummy>
@@ -703,6 +742,41 @@ bool lexical_cast(const std::string &input, T &output) {
     }
 }
 
+/// complex
+template <typename T,
+    enable_if_t<classify_object<T>::value == object_category::complex_number, detail::enabler> = detail::dummy>
+    bool lexical_cast(const std::string &input, T &output) {
+    using XC=typename conditional_t<is_wrapper<T>::value, typename T::value_type, double>;
+    XC x, y;
+    auto str1 = input;
+    bool worked = false;
+    auto nloc = str1.find_last_of('-');
+    if (nloc != std::string::npos && nloc > 0) {
+        worked = detail::lexical_cast(str1.substr(0, nloc), x);
+        str1 = str1.substr(nloc);
+        if (str1.back() == 'i' || str1.back() == 'j')
+            str1.pop_back();
+        worked = worked && detail::lexical_cast(str1, y);
+    }
+    else {
+        if (str1.back() == 'i' || str1.back() == 'j') {
+            str1.pop_back();
+            worked = detail::lexical_cast(str1, y);
+            x = XC{ 0 };
+        }
+        else {
+            worked = detail::lexical_cast(str1, x);
+            y = XC{ 0 };
+        }
+    }
+    if (worked)
+    {
+        output = T{ x,y };
+        return worked;
+    }
+    return from_stream(input, output);
+}
+
 /// String and similar direct assignment
 template <typename T,
           enable_if_t<classify_object<T>::value == object_category::string_assignable, detail::enabler> = detail::dummy>
@@ -735,12 +809,11 @@ bool lexical_cast(const std::string &input, T &output) {
 
 /// wrapper types
 template <typename T,
-    enable_if_t<classify_object<T>::value == object_category::wrapper_value, detail::enabler> = detail::dummy>
-    bool lexical_cast(const std::string &input, T &output) {
+          enable_if_t<classify_object<T>::value == object_category::wrapper_value, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
     typename T::value_type val;
-    if (lexical_cast(input, val))
-    {
-        output = T{ val };
+    if(lexical_cast(input, val)) {
+        output = T{val};
         return true;
     }
     return from_stream(input, output);
@@ -856,8 +929,9 @@ bool lexical_assign(const std::string &input, T &output) {
 /// Lexical conversion if there is only one element
 template <typename T,
           typename XC,
-          enable_if_t<!is_tuple_like<T>::value && !is_tuple_like<XC>::value && !is_container<T>::value &&
-                          !is_container<XC>::value,
+          enable_if_t<!is_tuple_like<T>::value && !is_tuple_like<XC>::value && !is_mutable_container<T>::value &&
+                          !(classify_object<XC>::value == object_category::wrapper_value ||
+                            classify_object<XC>::value == object_category::container_value),
                       detail::enabler> = detail::dummy>
 bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
     return lexical_assign<T, XC>(strings[0], output);
@@ -880,6 +954,20 @@ bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
     return retval;
 }
 
+/// wrapper types
+template <typename T,
+          class XC,
+          enable_if_t<classify_object<XC>::value == object_category::wrapper_value && type_count<XC>::value == 1,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, T &output) {
+    typename XC::value_type val;
+    if(lexical_conversion<typename XC::value_type, typename XC::value_type>(strings, val)) {
+        output = XC{val};
+        return true;
+    }
+    return false;
+}
+
 /// Lexical conversion of a vector types
 template <class T,
           class XC,
@@ -945,7 +1033,7 @@ bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
 /// Lexical conversion if there is only one element but the conversion type is a vector
 template <typename T,
           typename XC,
-          enable_if_t<!is_tuple_like<T>::value && !is_container<T>::value && is_container<XC>::value, detail::enabler> =
+          enable_if_t<!is_tuple_like<T>::value && !is_mutable_container<T>::value && is_mutable_container<XC>::value, detail::enabler> =
               detail::dummy>
 bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
 
diff --git a/tests/HelpersTest.cpp b/tests/HelpersTest.cpp
index 8dc64e700..7e7e84aa7 100644
--- a/tests/HelpersTest.cpp
+++ b/tests/HelpersTest.cpp
@@ -1178,11 +1178,17 @@ static_assert(CLI::detail::is_wrapper<std::vector<std::string>>::value, "vector
 static_assert(CLI::detail::is_wrapper<std::string>::value, "string should be a wrapper");
 static_assert(!CLI::detail::is_wrapper<double>::value, "double should not be a wrapper");
 
-static_assert(CLI::detail::is_container<std::vector<double>>::value, "vector class should be a container");
-static_assert(CLI::detail::is_container<std::vector<std::string>>::value, "vector class should be a container");
-static_assert(!CLI::detail::is_container<std::string>::value, "string should be a container");
-static_assert(!CLI::detail::is_container<double>::value, "double should not be a container");
-static_assert(!CLI::detail::is_container<std::array<double, 5>>::value, "array should not be a container");
+static_assert(CLI::detail::is_mutable_container<std::vector<double>>::value, "vector class should be a container");
+static_assert(CLI::detail::is_mutable_container<std::vector<std::string>>::value, "vector class should be a container");
+static_assert(!CLI::detail::is_mutable_container<std::string>::value, "string should be a container");
+static_assert(!CLI::detail::is_mutable_container<double>::value, "double should not be a container");
+static_assert(!CLI::detail::is_mutable_container<std::array<double, 5>>::value, "array should not be a container");
+
+static_assert(CLI::detail::is_mutable_container<std::vector<int>>::value, "vector int should be a container");
+
+static_assert(CLI::detail::is_readable_container<std::vector<int> &>::value, "vector int & should be a readable container");
+static_assert(CLI::detail::is_readable_container<const std::vector<int>>::value, "const vector int should be a readable container");
+static_assert(CLI::detail::is_readable_container<const std::vector<int> &>::value, "const vector int & should be a readable container");
 
 TEST(FixNewLines, BasicCheck) {
     std::string input = "one\ntwo";
diff --git a/tests/NewParseTest.cpp b/tests/NewParseTest.cpp
index 6d7a48733..8e9e62c1e 100644
--- a/tests/NewParseTest.cpp
+++ b/tests/NewParseTest.cpp
@@ -318,6 +318,7 @@ TEST_F(TApp, AddingComplexParserDetail) {
     } catch(...) {
         skip_tests = true;
     }
+    static_assert(CLI::detail::is_complex<cx>::value, "complex should register as complex in this situation");
     if(!skip_tests) {
         cx comp{0, 0};
         app.add_option("-c,--complex", comp, "add a complex number option");
diff --git a/tests/OptionTypeTest.cpp b/tests/OptionTypeTest.cpp
index 55a353b7e..18b27a37e 100644
--- a/tests/OptionTypeTest.cpp
+++ b/tests/OptionTypeTest.cpp
@@ -565,12 +565,12 @@ TEST_F(TApp, vectorVector) {
     EXPECT_THROW(run(), CLI::ConversionError);
 }
 
-static_assert(CLI::detail::is_container<std::set<std::string>>::value, "set should be a container");
-static_assert(CLI::detail::is_container<std::map<std::string, std::string>>::value, "map should be a container");
-static_assert(CLI::detail::is_container<std::unordered_map<std::string, double>>::value,
+static_assert(CLI::detail::is_mutable_container<std::set<std::string>>::value, "set should be a container");
+static_assert(CLI::detail::is_mutable_container<std::map<std::string, std::string>>::value, "map should be a container");
+static_assert(CLI::detail::is_mutable_container<std::unordered_map<std::string, double>>::value,
               "unordered_map should be a container");
 
-static_assert(CLI::detail::is_container<std::list<std::pair<int, std::string>>>::value, "list should be a container");
+static_assert(CLI::detail::is_mutable_container<std::list<std::pair<int, std::string>>>::value, "list should be a container");
 
 static_assert(CLI::detail::type_count<std::set<std::string>>::value == 1, "set should have a type size of 1");
 static_assert(CLI::detail::type_count<std::set<std::tuple<std::string, int, int>>>::value == 3,
diff --git a/tests/OptionalTest.cpp b/tests/OptionalTest.cpp
index f325db614..47a9f5a7d 100644
--- a/tests/OptionalTest.cpp
+++ b/tests/OptionalTest.cpp
@@ -165,12 +165,18 @@ TEST_F(TApp, BoostOptionalStringTest) {
     EXPECT_TRUE(opt);
     EXPECT_EQ(*opt, "strv");
 }
+namespace boost
+{
+    using CLI::enums::operator<<;
+}
+
 
 TEST_F(TApp, BoostOptionalEnumTest) {
+    
     enum class eval : char { val0 = 0, val1 = 1, val2 = 2, val3 = 3, val4 = 4 };
     boost::optional<eval> opt,opt2;
     auto optptr = app.add_option<decltype(opt), eval>("-v,--val", opt);
-   // app.add_option("-e,--eval", opt2);
+   app.add_option_no_stream("-e,--eval", opt2);
     optptr->capture_default_str();
 
     auto dstring = optptr->get_default_str();
@@ -187,6 +193,7 @@ TEST_F(TApp, BoostOptionalEnumTest) {
     run();
     EXPECT_TRUE(opt);
     EXPECT_TRUE(*opt == eval::val1);
+
 }
 
 TEST_F(TApp, BoostOptionalVector) {