Add argument parser class

src/driver/argument_parser.hpp

+#ifndef MIGRAPHX_GUARD_RTGLIB_ARGUMENT_PARSER_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ARGUMENT_PARSER_HPP
+
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+#include <migraphx/requires.hpp>
+#include <migraphx/type_name.hpp>
+#include <migraphx/each_args.hpp>
+
+template <class T>
+struct value_parser
+{
+    template <MIGRAPHX_REQUIRES(not std::is_enum<T>{})>
+    static T apply(const std::string& x)
+    {
+        T result;
+        std::stringstream ss;
+        ss.str(x);
+        ss >> result;
+        if(ss.fail())
+            throw std::runtime_error("Failed to parse: " + x);
+        return result;
+    }
+
+    template <MIGRAPHX_REQUIRES(std::is_enum<T>{})>
+    static T apply(const std::string& x)
+    {
+        std::ptrdiff_t i;
+        std::stringstream ss;
+        ss.str(x);
+        ss >> i;
+        if(ss.fail())
+            throw std::runtime_error("Failed to parse: " + x);
+        return static_cast<T>(i);
+    }
+};
+
+struct argument_parser
+{
+    struct argument
+    {
+        std::vector<std::string> flags;
+        std::function<bool(const std::vector<std::string>&)> action;
+        std::string type = "";
+        std::string help = "";
+    };
+
+    template <class T, class... Fs>
+    void add(T& x, std::vector<std::string> flags, Fs... fs)
+    {
+        arguments.emplace_back(flags, [&](auto&&, const std::vector<std::string>& params) {
+            if (params.empty())
+                throw std::runtime_error("Flag with no value.");
+            x = value_parser<T>::apply(params.back());
+            return false;
+        });
+
+        argument& arg   = arguments.back();
+        arg.type        = migraphx::get_type_name<T>();
+        migraphx::each_args([&](auto f) { f(x, arg); }, fs...);
+    }
+
+    template<class F>
+    static auto write_action(F f)
+    {
+        return [=](auto& x, auto& arg) {
+            arg.action = [f, &](auto& self, const std::vector<std::string>& params) {
+                f(self, x, params);
+                return false;
+            };
+        };
+    }
+
+    template<class F>
+    static auto do_action(F f)
+    {
+        return [=](auto&, auto& arg) {
+            arg.action = [f, &](auto& self, const std::vector<std::string>&) {
+                f(self);
+                return true;
+            };
+        };
+    }
+
+    static auto write_range()
+    {
+        return write_action([](auto& self, auto& x, auto& params) {
+            std::transform(param.begin(), params.end(), std::inserter(x, x.end()), [](std::string y) {
+                return value_parser<T>::apply(params.back());
+            });
+        })
+    }
+
+    static auto show_help()
+    {
+        return do_action([](auto& self) {
+            for(auto&& arg:self.arguments) 
+            {
+                std::cout << std::endl;
+                std::string prefix = "    ";
+                for(const std::string& a : arg.flags)
+                {
+                    std::cout << prefix;
+                    std::cout << a;
+                    prefix = ", ";
+                }
+                if (not arg.type.empty())
+                    std::cout << " [" << arg.type << "]";
+                std::cout << std::endl;
+                std::cout << "        " << arg.help << std::endl;
+            }
+            std::cout << std::endl;
+        });
+    }
+
+    static auto help(std::string help)
+    {
+        return [=](auto&, auto& arg) {
+            arg.help = help;
+        };
+    }
+
+    template<class T>
+    static auto set_value(T value)
+    {
+        return [=](auto& x, auto& arg) {
+            arg.type = "";
+            arg.action = [value, &](auto& self, const std::vector<std::string>& params) {
+                x = value;
+                return false;
+            };
+        };
+    }
+
+    void parse(std::vector<std::string> args)
+    {
+        std::set<std::string> keywords;
+        for(auto&& arg:arguments)
+        {
+            keywords.insert(arg.flags.begin(), arg.flags.end());
+        }
+        auto arg_map = generic_parse(as, [&](std::string x) {
+            return (keywords.count(x) > 0);
+        });
+        for(auto&& arg:arguments)
+        {
+            for(auto&& flag:arg.flags)
+            {
+                if (arg_map.count(flag) > 0) 
+                {
+                    if (arg.action(*this, arg_map[flag]))
+                        return;
+                }
+            }
+        }
+    }
+
+    using string_map = std::unordered_map<std::string, std::vector<std::string>>;
+    template <class IsKeyword>
+    static string_map generic_parse(std::vector<std::string> as, IsKeyword is_keyword)
+    {
+        string_map result;
+
+        std::string flag;
+        for(auto&& x : as)
+        {
+            if(is_keyword(x))
+            {
+                flag = x;
+                result[flag]; // Ensure the flag exists
+            }
+            else
+            {
+                result[flag].push_back(x);
+            }
+        }
+        return result;
+    }
+    private:
+        std::vector<argument> arguments;
+};
+
+#endif