Factor out type utilities, single version of IsMember code

Author: henryiii

include/CLI/TypeTools.hpp

@@ -13,6 +13,16 @@ namespace CLI {
 
 // Type tools
 
+// Utilities for type enabling
+namespace detail {
+// Based generally on https://rmf.io/cxx11/almost-static-if
+/// Simple empty scoped class
+enum class enabler {};
+
+/// An instance to use in EnableIf
+constexpr enabler dummy = {};
+} // namespace detail
+
 /// A copy of enable_if_t from C++14, compatible with C++11.
 ///
 /// We could check to see if C++14 is being used, but it does not hurt to redefine this
@@ -44,13 +54,24 @@ template <typename T> struct is_copyable_ptr {
     static bool const value = is_shared_ptr<T>::value || std::is_pointer<T>::value;
 };
 
-namespace detail {
-// Based generally on https://rmf.io/cxx11/almost-static-if
-/// Simple empty scoped class
-enum class enabler {};
+/// Handy helper to access the element_type generically. This is not part of is_copyable_ptr because it requires that
+/// pointer_traits<T> be valid.
+template <typename T> struct element_type {
+    using type =
+        typename std::conditional<is_copyable_ptr<T>::value, typename std::pointer_traits<T>::element_type, T>::type;
+};
 
-/// An instance to use in EnableIf
-constexpr enabler dummy = {};
+/// Combination of the element type and value type - remove pointer (including smart pointers) and get the value_type of
+/// the container
+template <typename T> struct element_value_type { using type = typename element_type<T>::type::value_type; };
+
+/// This can be specialized to override the type deduction for IsMember.
+template <typename T> struct IsMemberType { using type = T; };
+
+/// The main custom type needed here is const char * should be a string.
+template <> struct IsMemberType<const char *> { using type = std::string; };
+
+namespace detail {
 
 // Type name print
 

include/CLI/Validators.hpp

@@ -8,6 +8,7 @@
 
 #include <functional>
 #include <iostream>
+#include <memory>
 #include <string>
 
 // C standard library
@@ -264,11 +265,16 @@ class Range : public Validator {
     template <typename T> explicit Range(T max) : Range(static_cast<T>(0), max) {}
 };
 
-/// This can be specialized to override the type deduction for IsMember.
-template <typename T> struct IsMemberType { using type = T; };
+namespace detail {
+template <typename T, enable_if_t<is_copyable_ptr<T>::value, detail::enabler> = detail::dummy>
+auto smart_deref(T value) -> decltype(*value) {
+    return *value;
+}
 
-/// The main custom type needed here is const char * should be a string.
-template <> struct IsMemberType<const char *> { using type = std::string; };
+template <typename T, enable_if_t<!is_copyable_ptr<T>::value, detail::enabler> = detail::dummy> T smart_deref(T value) {
+    return value;
+}
+} // namespace detail
 
 /// Verify items are in a set
 class IsMember : public Validator {
@@ -280,26 +286,18 @@ class IsMember : public Validator {
     explicit IsMember(std::initializer_list<T> values, Args &&... args)
         : IsMember(std::vector<T>(values), std::forward<Args>(args)...) {}
 
-    /// This checks to see if an item is in a set: pointer version. (Empty function)
-    template <typename T, enable_if_t<is_copyable_ptr<T>::value, detail::enabler> = detail::dummy>
-    explicit IsMember(T set)
-        : IsMember(std::move(set),
-                   std::function<typename IsMemberType<typename std::pointer_traits<T>::element_type::value_type>::type(
-                       typename IsMemberType<typename std::pointer_traits<T>::element_type::value_type>::type)>{}) {}
-
-    /// This checks to see if an item is in a set: copy version. (Empty function)
-    template <typename T, enable_if_t<!is_copyable_ptr<T>::value, detail::enabler> = detail::dummy>
+    /// This checks to see if an item is in a set (empty function)
+    template <typename T>
     explicit IsMember(T set)
         : IsMember(std::move(set),
-                   std::function<typename IsMemberType<typename T::value_type>::type(
-                       typename IsMemberType<typename T::value_type>::type)>()) {}
+                   std::function<typename IsMemberType<typename element_value_type<T>::type>::type(
+                       typename IsMemberType<typename element_value_type<T>::type>::type)>()) {}
 
-    /// This checks to see if an item is in a set: pointer version. You can pass in a function that will filter
+    /// This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter
     /// both sides of the comparison before computing the comparison.
-    template <typename T, typename F, enable_if_t<is_copyable_ptr<T>::value, detail::enabler> = detail::dummy>
-    explicit IsMember(T set, F filter_function) {
+    template <typename T, typename F> explicit IsMember(T set, F filter_function) {
         // Get the type of the contained item - requires a container have ::value_type
-        using item_t = typename std::pointer_traits<T>::element_type::value_type;
+        using item_t = typename element_value_type<T>::type;
         using local_item_t = typename IsMemberType<item_t>::type;
 
         // Make a local copy of the filter function, using a std::function if not one already
@@ -308,62 +306,14 @@ class IsMember : public Validator {
         // This is the type name for help, it will take the current version of the set contents
         tname_function = [set]() {
             std::stringstream out;
-            out << detail::type_name<item_t>() << " in {" << detail::join(*set, ",") << "}";
+            out << detail::type_name<item_t>() << " in {" << detail::join(detail::smart_deref(set), ",") << "}";
             return out.str();
         };
 
         // This is the function that validates
         // It stores a copy of the set pointer-like, so shared_ptr will stay alive
         func = [set, filter_fn](std::string &input) {
-            for(const item_t &v : *set) {
-                local_item_t a = v;
-                local_item_t b;
-                if(!detail::lexical_cast(input, b))
-                    throw ValidationError(input); // name is added later
-
-                // The filter function might be empty, so don't filter if it is.
-                if(filter_fn) {
-                    a = filter_fn(a);
-                    b = filter_fn(b);
-                }
-
-                if(a == b) {
-                    // Make sure the version in the input string is identical to the one in the set
-                    // Requires std::stringstream << be supported on T.
-                    if(filter_fn) {
-                        std::stringstream out;
-                        out << v;
-                        input = out.str();
-                    }
-
-                    // Return empty error string (success)
-                    return std::string();
-                }
-            }
-
-            // If you reach this point, the result was not found
-            return input + " not in {" + detail::join(*set, ",") + "}";
-        };
-    }
-
-    /// This checks to see if an item is in a set: copy version.
-    template <typename T, typename F, enable_if_t<!is_copyable_ptr<T>::value, detail::enabler> = detail::dummy>
-    explicit IsMember(T set, F filter_function) {
-        // Get the type of the contained item - requires a container have ::value_type
-        using item_t = typename T::value_type;
-        using local_item_t = typename IsMemberType<item_t>::type;
-
-        // Make a local copy of the filter function, using a std::function if not one already
-        std::function<local_item_t(local_item_t)> filter_fn = filter_function;
-
-        // This is the type name for help, since the set contents can't change, we just capture this
-        std::stringstream out;
-        out << detail::type_name<item_t>() << " in {" << detail::join(set, ",") << "}";
-        tname = out.str();
-
-        // This is the function that validates
-        func = [set, filter_fn](std::string &input) {
-            for(const item_t &v : set) {
+            for(const item_t &v : detail::smart_deref(set)) {
                 local_item_t a = v;
                 local_item_t b;
                 if(!detail::lexical_cast(input, b))
@@ -390,7 +340,7 @@ class IsMember : public Validator {
             }
 
             // If you reach this point, the result was not found
-            return input + " not in {" + detail::join(set, ",") + "}";
+            return input + " not in {" + detail::join(detail::smart_deref(set), ",") + "}";
         };
     }