Add better enum support in the library

Author: phlptp

examples/enum.cpp

@@ -1,15 +1,13 @@
 #include <CLI/CLI.hpp>
 #include <map>
-#include <sstream>
 
 enum class Level : int { High, Medium, Low };
 
 int main(int argc, char **argv) {
     CLI::App app;
 
-    std::map<std::string, Level> map = {{"High", Level::High}, {"Medium", Level::Medium}, {"Low", Level::Low}};
-
     Level level;
+    std::map<std::string, Level> map = {{"High", Level::High}, {"Medium", Level::Medium}, {"Low", Level::Low}};
 
     app.add_option("-l,--level", level, "Level settings")
         ->required()

include/CLI/StringTools.hpp

@@ -46,7 +46,7 @@ inline std::vector<std::string> split(const std::string &s, char delim) {
     std::vector<std::string> elems;
     // Check to see if empty string, give consistent result
     if(s.empty())
-        elems.emplace_back("");
+        elems.emplace_back();
     else {
         std::stringstream ss;
         ss.str(s);
@@ -70,6 +70,21 @@ template <typename T> std::string join(const T &v, std::string delim = ",") {
     return s.str();
 }
 
+/// Simple function to join a string from processed elements
+template <typename T,
+          typename Callable,
+          typename = typename std::enable_if<!std::is_constructible<std::string, Callable>::value>::type>
+std::string join(const T &v, Callable func, std::string delim = ",") {
+    std::ostringstream s;
+    size_t start = 0;
+    for(const auto &i : v) {
+        if(start++ > 0)
+            s << delim;
+        s << func(i);
+    }
+    return s.str();
+}
+
 /// Join a string in reverse order
 template <typename T> std::string rjoin(const T &v, std::string delim = ",") {
     std::ostringstream s;

include/CLI/TypeTools.hpp

@@ -3,6 +3,7 @@
 // Distributed under the 3-Clause BSD License.  See accompanying
 // file LICENSE or https://github.com/CLIUtils/CLI11 for details.
 
+#include "StringTools.hpp"
 #include <exception>
 #include <memory>
 #include <string>
@@ -140,9 +141,16 @@ template <typename T, enable_if_t<is_vector<T>::value, detail::enabler> = detail
 constexpr const char *type_name() {
     return "VECTOR";
 }
+/// Print name for enumeration types
+template <typename T, enable_if_t<std::is_enum<T>::value, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "ENUM";
+}
 
+/// Print for all other types
 template <typename T,
-          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value && !is_vector<T>::value,
+          enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value && !is_vector<T>::value &&
+                          !std::is_enum<T>::value,
                       detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "TEXT";
@@ -229,10 +237,22 @@ bool lexical_cast(std::string input, T &output) {
     return true;
 }
 
+/// enumerations
+template <typename T, enable_if_t<std::is_enum<T>::value, detail::enabler> = detail::dummy>
+bool lexical_cast(std::string input, T &output) {
+    typename std::underlying_type<T>::type val;
+    bool retval = detail::lexical_cast(input, val);
+    if(!retval) {
+        return false;
+    }
+    output = static_cast<T>(val);
+    return true;
+}
+
 /// Non-string parsable
 template <typename T,
           enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
-                          !std::is_assignable<T &, std::string>::value,
+                          !std::is_assignable<T &, std::string>::value && !std::is_enum<T>::value,
                       detail::enabler> = detail::dummy>
 bool lexical_cast(std::string input, T &output) {
     std::istringstream is;