Change conversion interface

README.md

@@ -151,7 +151,7 @@ The below lists features of the `argparse` module that this implementation suppo
       * [x] `'+'` (as `one_or_more`)
    * [x] `const` (renamed to `const_` due to keyword clash)
    * [x] `default` (renamed to `default_` due to keyword clash; only for optional arguments and with no string parsing)
-   * [x] `type` (built-in (except for `bool`) and user-defined types (via overloading `from_string` function))
+   * [x] `type` (built-in (except for `bool`) and user-defined types (via specialising `argparse::Converter` class template))
    * [x] `choices`
    * [x] `required`
    * [x] `help`

include/argparse.hpp

@@ -99,25 +99,51 @@ namespace argparse
         return static_cast<int>(lhs) & static_cast<int>(rhs);
     }
 
-    inline auto from_string(std::string const & s, auto & t) -> bool
+    template<typename T>
+    class Converter
     {
-        auto iss = std::istringstream(s);
-        iss >> t;
+        public:
+            auto from_string(std::string const & s, T & t) const -> bool
+            {
+                auto iss = std::istringstream(s);
+                iss >> t;
 
-        return !iss.fail() && (iss.eof() || iss.peek() == std::istringstream::traits_type::eof());
-    }
+                return !iss.fail() && (iss.eof() || iss.peek() == std::istringstream::traits_type::eof());
+            }
+
+            auto to_string(T const & t) const -> std::string
+            {
+                auto ostr = std::ostringstream();
+                ostr << t;
+
+                return ostr.str();
+            }
 
-    inline auto to_string(auto const & t) -> std::string
+            auto are_equal(T const & lhs, T const & rhs) const -> bool
+            {
+                return lhs == rhs;
+            }
+    };
+
+    template<typename T>
+    inline auto from_string(std::string const & s, T & t) -> bool
     {
-        auto ostr = std::ostringstream();
-        ostr << t;
+        auto const conv = Converter<T>();
+        return conv.from_string(s, t);
+    }
 
-        return ostr.str();
+    template<typename T>
+    inline auto to_string(T const & t) -> std::string
+    {
+        auto const conv = Converter<T>();
+        return conv.to_string(t);
     }
 
-    inline auto are_equal(auto const & lhs, auto const & rhs) -> bool
+    template<typename T>
+    inline auto are_equal(T const & lhs, T const & rhs) -> bool
     {
-        return lhs == rhs;
+        auto const conv = Converter<T>();
+        return conv.are_equal(lhs, rhs);
     }
 
     class ArgumentParser
@@ -520,9 +546,8 @@ namespace argparse
                         }
                         else
                         {
-                            using argparse::from_string;
                             auto value = T();
-                            if (from_string(string, value))
+                            if (argparse::from_string(string, value))
                             {
                                 return std::any(value);
                             }
@@ -541,14 +566,13 @@ namespace argparse
                         }
                         else
                         {
-                            using argparse::to_string;
-                            return to_string(std::any_cast<T>(value));
+                            return argparse::to_string(std::any_cast<T>(value));
                         }
                     }
 
                     auto compare(std::any const & lhs, std::any const & rhs) const -> bool override
                     {
-                        return are_equal(std::any_cast<T>(lhs), std::any_cast<T>(rhs));
+                        return argparse::are_equal(std::any_cast<T>(lhs), std::any_cast<T>(rhs));
                     }
 
                     auto transform(std::vector<std::any> const & values) const -> std::any override

test/unittest/custom_a.h

@@ -1,6 +1,7 @@
 #ifndef CUSTOMA_H
 #define CUSTOMA_H
 
+#include "argparse.hpp"
 #include <string>
 
 
@@ -20,23 +21,28 @@ namespace foo
     };
 }
 
-namespace foo
-{
-inline auto operator==(Custom const & lhs, Custom const & rhs) -> bool
-{
-    return lhs.m_text == rhs.m_text;
-}
-
-inline auto from_string(std::string const & s, Custom & c) -> bool
+namespace argparse
 {
-    c = Custom(s);
-    return true;
-}
-
-inline auto to_string(Custom const& c) -> std::string
+template<>
+class Converter<foo::Custom>
 {
-    return "<Custom: " + c.m_text + ">";
-}
+    public:
+        auto from_string(std::string const & s, foo::Custom & t) const -> bool
+        {
+            t = foo::Custom(s);
+            return true;
+        }
+
+        auto to_string(foo::Custom const & t) const -> std::string
+        {
+            return "<Custom: " + t.m_text + ">";
+        }
+
+        auto are_equal(foo::Custom const & lhs, foo::Custom const & rhs) const -> bool
+        {
+            return lhs.m_text == rhs.m_text;
+        }
+};
 }
 
 #endif /* CUSTOMA_H */

test/unittest/custom_b.h

@@ -1,6 +1,7 @@
 #ifndef CUSTOMB_H
 #define CUSTOMB_H
 
+#include "argparse.hpp"
 #include <string>
 
 
@@ -23,23 +24,25 @@ namespace bar
 namespace argparse
 {
 template<>
-inline auto from_string(std::string const & s, bar::Custom & c) -> bool
+class Converter<bar::Custom>
 {
-    c = bar::Custom(s);
-    return true;
-}
-
-template<>
-inline auto to_string(bar::Custom const & t) -> std::string
-{
-    return "<Custom: " + t.m_text + ">";
-}
-
-template<>
-inline auto are_equal(bar::Custom const & lhs, bar::Custom const & rhs) -> bool
-{
-    return lhs.m_text == rhs.m_text;
-}
+    public:
+        auto from_string(std::string const & s, bar::Custom & t) const -> bool
+        {
+            t = bar::Custom(s);
+            return true;
+        }
+
+        auto to_string(bar::Custom const & t) const -> std::string
+        {
+            return "<Custom: " + t.m_text + ">";
+        }
+
+        auto are_equal(bar::Custom const & lhs, bar::Custom const & rhs) const -> bool
+        {
+            return lhs.m_text == rhs.m_text;
+        }
+};
 }
 
 #endif /* CUSTOMB_H */

test/unittest/test_parsing_optional.cpp

@@ -12,6 +12,13 @@
 
 using namespace std::string_literals;
 
+namespace foo
+{
+inline auto operator==(Custom const & lhs, Custom const & rhs) -> bool
+{
+    return lhs.m_text == rhs.m_text;
+}
+}
 namespace bar
 {
 inline auto operator==(Custom const & lhs, Custom const & rhs) -> bool

test/unittest/test_parsing_positional.cpp

@@ -12,6 +12,13 @@
 
 using namespace std::string_literals;
 
+namespace foo
+{
+inline auto operator==(Custom const & lhs, Custom const & rhs) -> bool
+{
+    return lhs.m_text == rhs.m_text;
+}
+}
 namespace bar
 {
 inline auto operator==(Custom const & lhs, Custom const & rhs) -> bool

tutorial/custom1.cpp

@@ -21,25 +21,27 @@ namespace geometry
 namespace argparse
 {
 template<>
-inline auto from_string(std::string const & s, geometry::Point & p) -> bool
+class Converter<geometry::Point>
 {
-    std::istringstream iss(s);
-    char comma;
-    iss >> p.x >> comma >> p.y;
-    return true;
-}
+    public:
+        auto from_string(std::string const & s, geometry::Point & p) const -> bool
+        {
+            std::istringstream iss(s);
+            char comma;
+            iss >> p.x >> comma >> p.y;
+            return true;
+        }
 
-template<>
-inline auto to_string(geometry::Point const & p) -> std::string
-{
-    return std::to_string(p.x) + "," + std::to_string(p.y);
-}
+        auto to_string(geometry::Point const & p) const -> std::string
+        {
+            return std::to_string(p.x) + "," + std::to_string(p.y);
+        }
 
-template<>
-inline auto are_equal(geometry::Point const & l, geometry::Point const & r) -> bool
-{
-    return l.x == r.x && l.y == r.y;
-}
+        auto are_equal(geometry::Point const & l, geometry::Point const & r) const -> bool
+        {
+            return l.x == r.x && l.y == r.y;
+        }
+};
 }
 
 auto main(int argc, char * argv[]) -> int

tutorial/custom2.cpp

@@ -21,25 +21,27 @@ namespace geometry
 namespace argparse
 {
 template<>
-inline auto from_string(std::string const & s, geometry::Point & p) -> bool
+class Converter<geometry::Point>
 {
-    std::istringstream iss(s);
-    char comma;
-    iss >> p.x >> comma >> p.y;
-    return !iss.fail();
-}
+    public:
+        auto from_string(std::string const & s, geometry::Point & p) const -> bool
+        {
+            std::istringstream iss(s);
+            char comma;
+            iss >> p.x >> comma >> p.y;
+            return !iss.fail();
+        }
 
-template<>
-inline auto to_string(geometry::Point const & p) -> std::string
-{
-    return std::to_string(p.x) + "," + std::to_string(p.y);
-}
+        auto to_string(geometry::Point const & p) const -> std::string
+        {
+            return std::to_string(p.x) + "," + std::to_string(p.y);
+        }
 
-template<>
-inline auto are_equal(geometry::Point const & l, geometry::Point const & r) -> bool
-{
-    return l.x == r.x && l.y == r.y;
-}
+        auto are_equal(geometry::Point const & l, geometry::Point const & r) const -> bool
+        {
+            return l.x == r.x && l.y == r.y;
+        }
+};
 }
 
 auto main(int argc, char * argv[]) -> int

tutorial/custom3.cpp

@@ -21,25 +21,27 @@ namespace geometry
 namespace argparse
 {
 template<>
-inline auto from_string(std::string const & s, geometry::Point & p) -> bool
+class Converter<geometry::Point>
 {
-    std::istringstream iss(s);
-    char comma;
-    iss >> p.x >> comma >> p.y;
-    return !iss.fail();
-}
+    public:
+        auto from_string(std::string const & s, geometry::Point & p) const -> bool
+        {
+            std::istringstream iss(s);
+            char comma;
+            iss >> p.x >> comma >> p.y;
+            return !iss.fail();
+        }
 
-template<>
-inline auto to_string(geometry::Point const & p) -> std::string
-{
-    return std::to_string(p.x) + "," + std::to_string(p.y);
-}
+        auto to_string(geometry::Point const & p) const -> std::string
+        {
+            return std::to_string(p.x) + "," + std::to_string(p.y);
+        }
 
-template<>
-inline auto are_equal(geometry::Point const & l, geometry::Point const & r) -> bool
-{
-    return l.x == r.x && l.y == r.y;
-}
+        auto are_equal(geometry::Point const & l, geometry::Point const & r) const -> bool
+        {
+            return l.x == r.x && l.y == r.y;
+        }
+};
 }
 
 auto main(int argc, char * argv[]) -> int