argument_parser.hpp 9.05 KB
Newer Older
Paul's avatar
Paul committed
1
2
3
#ifndef MIGRAPHX_GUARD_RTGLIB_ARGUMENT_PARSER_HPP
#define MIGRAPHX_GUARD_RTGLIB_ARGUMENT_PARSER_HPP

Paul's avatar
Paul committed
4
5
6
7
#include <algorithm>
#include <functional>
#include <iostream>
#include <set>
Paul's avatar
Paul committed
8
#include <string>
Paul's avatar
Paul committed
9
#include <sstream>
Paul's avatar
Paul committed
10
11
#include <type_traits>
#include <unordered_map>
Paul's avatar
Paul committed
12
#include <utility>
Paul's avatar
Paul committed
13
14
#include <vector>

Paul's avatar
Paul committed
15
#include <migraphx/config.hpp>
Paul's avatar
Paul committed
16
17
#include <migraphx/requires.hpp>
#include <migraphx/type_name.hpp>
Paul's avatar
Paul committed
18
#include <migraphx/functional.hpp>
Paul's avatar
Paul committed
19
#include <migraphx/stringutils.hpp>
Paul's avatar
Paul committed
20
21
22
23

namespace migraphx {
namespace driver {
inline namespace MIGRAPHX_INLINE_NS {
Paul's avatar
Paul committed
24

Paul's avatar
Paul committed
25
26
27
28
29
30
#ifdef MIGRAPHX_USE_CLANG_TIDY
#define MIGRAPHX_DRIVER_STATIC
#else
#define MIGRAPHX_DRIVER_STATIC static
#endif

Paul's avatar
Paul committed
31
template <class T>
Paul's avatar
Paul committed
32
33
34
35
36
using bare = std::remove_cv_t<std::remove_reference_t<T>>;

namespace detail {

template <class T>
Paul's avatar
Paul committed
37
auto is_container(int, T&& x) -> decltype(x.insert(x.end(), *x.begin()), std::true_type{});
Paul's avatar
Paul committed
38
39
40
41
42
43
44
45
46
47
48
49
50

template <class T>
std::false_type is_container(float, T&&);

} // namespace detail

template <class T>
struct is_container : decltype(detail::is_container(int(0), std::declval<T>()))
{
};

template <class T>
using is_multi_value =
Paul's avatar
Paul committed
51
    std::integral_constant<bool, (is_container<T>{} and not std::is_convertible<T, std::string>{})>;
Paul's avatar
Paul committed
52

Paul's avatar
Paul committed
53
54
55
template <class T>
struct value_parser
{
Paul's avatar
Paul committed
56
    template <MIGRAPHX_REQUIRES(not std::is_enum<T>{} and not is_multi_value<T>{})>
Paul's avatar
Paul committed
57
58
59
60
61
62
63
64
65
66
67
    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;
    }

Paul's avatar
Paul committed
68
    template <MIGRAPHX_REQUIRES(std::is_enum<T>{} and not is_multi_value<T>{})>
Paul's avatar
Paul committed
69
70
71
72
73
74
75
76
77
78
    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);
    }
Paul's avatar
Paul committed
79
80
81
82
83
84
85
86
87

    template <MIGRAPHX_REQUIRES(is_multi_value<T>{} and not std::is_enum<T>{})>
    static T apply(const std::string& x)
    {
        T result;
        using value_type = typename T::value_type;
        result.insert(result.end(), value_parser<value_type>::apply(x));
        return result;
    }
Paul's avatar
Paul committed
88
89
};

Paul's avatar
Paul committed
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
template<class T>
struct type_name
{
    static const std::string& apply()
    {
        return migraphx::get_type_name<T>();
    }
};

template<>
struct type_name<std::string>
{
    static const std::string& apply()
    {
        static const std::string name = "std::string";
        return name;
    }
};

template<class T>
struct type_name<std::vector<T>>
{
    static const std::string& apply()
    {
        static const std::string name = "std::vector<" + type_name<T>::apply() + ">";
        return name;
    }
};

Paul's avatar
Paul committed
119
120
121
122
123
struct argument_parser
{
    struct argument
    {
        std::vector<std::string> flags;
Paul's avatar
Paul committed
124
        std::function<bool(argument_parser&, const std::vector<std::string>&)> action{};
Paul's avatar
Paul committed
125
126
127
        std::string type          = "";
        std::string help          = "";
        std::string metavar       = "";
Paul's avatar
Paul committed
128
        std::string default_value = "";
Paul's avatar
Paul committed
129
        unsigned nargs            = 1;
Paul's avatar
Paul committed
130
131
    };

Paul's avatar
Paul committed
132
    template <class T, MIGRAPHX_REQUIRES(is_multi_value<T>{})>
Paul's avatar
Paul committed
133
134
135
136
137
    std::string as_string_value(const T& x)
    {
        return to_string_range(x);
    }

Paul's avatar
Paul committed
138
    template <class T, MIGRAPHX_REQUIRES(not is_multi_value<T>{})>
Paul's avatar
Paul committed
139
140
141
142
143
    std::string as_string_value(const T& x)
    {
        return to_string(x);
    }

Paul's avatar
Paul committed
144
    template <class T, class... Fs>
Paul's avatar
Paul committed
145
    void operator()(T& x, const std::vector<std::string>& flags, Fs... fs)
Paul's avatar
Paul committed
146
    {
Paul's avatar
Paul committed
147
        arguments.push_back({flags, [&](auto&&, const std::vector<std::string>& params) {
Paul's avatar
Paul committed
148
149
150
151
152
                                 if(params.empty())
                                     throw std::runtime_error("Flag with no value.");
                                 x = value_parser<T>::apply(params.back());
                                 return false;
                             }});
Paul's avatar
Paul committed
153

Paul's avatar
Paul committed
154
        argument& arg     = arguments.back();
Paul's avatar
Paul committed
155
        arg.type          = type_name<T>::apply();
Paul's avatar
Paul committed
156
        arg.default_value = as_string_value(x);
Paul's avatar
Paul committed
157
158
159
        migraphx::each_args([&](auto f) { f(x, arg); }, fs...);
    }

Paul's avatar
Paul committed
160
    template <class... Fs>
Paul's avatar
Paul committed
161
    void operator()(std::nullptr_t x, std::vector<std::string> flags, Fs... fs)
Paul's avatar
Paul committed
162
    {
Paul's avatar
Paul committed
163
        arguments.push_back({std::move(flags)});
Paul's avatar
Paul committed
164
165
166

        argument& arg = arguments.back();
        arg.type      = "";
Paul's avatar
Paul committed
167
        arg.nargs     = 0;
Paul's avatar
Paul committed
168
169
170
        migraphx::each_args([&](auto f) { f(x, arg); }, fs...);
    }

Paul's avatar
Paul committed
171
    MIGRAPHX_DRIVER_STATIC auto nargs(unsigned n = 1)
Paul's avatar
Paul committed
172
    {
Paul's avatar
Paul committed
173
        return [=](auto&&, auto& arg) { arg.nargs = n; };
Paul's avatar
Paul committed
174
175
    }

Paul's avatar
Paul committed
176
    template <class F>
Paul's avatar
Paul committed
177
    MIGRAPHX_DRIVER_STATIC auto write_action(F f)
Paul's avatar
Paul committed
178
179
    {
        return [=](auto& x, auto& arg) {
Paul's avatar
Paul committed
180
            arg.action = [&, f](auto& self, const std::vector<std::string>& params) {
Paul's avatar
Paul committed
181
182
183
184
185
186
                f(self, x, params);
                return false;
            };
        };
    }

Paul's avatar
Paul committed
187
    template <class F>
Paul's avatar
Paul committed
188
    MIGRAPHX_DRIVER_STATIC auto do_action(F f)
Paul's avatar
Paul committed
189
190
    {
        return [=](auto&, auto& arg) {
Paul's avatar
Paul committed
191
            arg.nargs  = 0;
Paul's avatar
Paul committed
192
            arg.action = [&, f](auto& self, const std::vector<std::string>&) {
Paul's avatar
Paul committed
193
194
195
196
197
198
                f(self);
                return true;
            };
        };
    }

Paul's avatar
Paul committed
199
    MIGRAPHX_DRIVER_STATIC auto append()
Paul's avatar
Paul committed
200
    {
Paul's avatar
Paul committed
201
        return write_action([](auto&, auto& x, auto& params) {
Paul's avatar
Paul committed
202
            using type = typename bare<decltype(params)>::value_type;
Paul's avatar
Paul committed
203
            std::transform(params.begin(),
Paul's avatar
Paul committed
204
205
                           params.end(),
                           std::inserter(x, x.end()),
Paul's avatar
Paul committed
206
207
                           [](std::string y) { return value_parser<type>::apply(y); });
        });
Paul's avatar
Paul committed
208
209
    }

Paul's avatar
Paul committed
210
    MIGRAPHX_DRIVER_STATIC auto show_help(const std::string& msg = "")
Paul's avatar
Paul committed
211
    {
Paul's avatar
Paul committed
212
        return do_action([=](auto& self) {
Paul's avatar
Paul committed
213
            for(auto&& arg : self.arguments)
Paul's avatar
Paul committed
214
215
216
            {
                std::cout << std::endl;
                std::string prefix = "    ";
Paul's avatar
Paul committed
217
                if(arg.flags.empty())
Paul's avatar
Paul committed
218
219
220
221
                {
                    std::cout << prefix;
                    std::cout << arg.metavar;
                }
Paul's avatar
Paul committed
222
223
224
225
226
227
                for(const std::string& a : arg.flags)
                {
                    std::cout << prefix;
                    std::cout << a;
                    prefix = ", ";
                }
Paul's avatar
Paul committed
228
                if(not arg.type.empty())
Paul's avatar
Paul committed
229
                {
Paul's avatar
Paul committed
230
                    std::cout << " [" << arg.type << "]";
Paul's avatar
Paul committed
231
                    if(not arg.default_value.empty())
Paul's avatar
Paul committed
232
233
                        std::cout << " (Default: " << arg.default_value << ")";
                }
Paul's avatar
Paul committed
234
235
236
237
                std::cout << std::endl;
                std::cout << "        " << arg.help << std::endl;
            }
            std::cout << std::endl;
Paul's avatar
Paul committed
238
            if(not msg.empty())
Paul's avatar
Paul committed
239
                std::cout << msg << std::endl;
Paul's avatar
Paul committed
240
241
242
        });
    }

Paul's avatar
Paul committed
243
    MIGRAPHX_DRIVER_STATIC auto help(const std::string& help)
Paul's avatar
Paul committed
244
    {
Paul's avatar
Paul committed
245
        return [=](auto&, auto& arg) { arg.help = help; };
Paul's avatar
Paul committed
246
247
    }

Paul's avatar
Paul committed
248
    MIGRAPHX_DRIVER_STATIC auto metavar(const std::string& metavar)
Paul's avatar
Paul committed
249
250
251
252
    {
        return [=](auto&, auto& arg) { arg.metavar = metavar; };
    }

Paul's avatar
Paul committed
253
    template <class T>
Paul's avatar
Paul committed
254
    MIGRAPHX_DRIVER_STATIC auto set_value(T value)
Paul's avatar
Paul committed
255
256
    {
        return [=](auto& x, auto& arg) {
Paul's avatar
Paul committed
257
            arg.nargs  = 0;
Paul's avatar
Paul committed
258
            arg.type   = "";
Paul's avatar
Paul committed
259
            arg.action = [&, value](auto&, const std::vector<std::string>&) {
Paul's avatar
Paul committed
260
261
262
263
264
265
                x = value;
                return false;
            };
        };
    }

Paul's avatar
Paul committed
266
    bool parse(std::vector<std::string> args)
Paul's avatar
Paul committed
267
    {
Paul's avatar
Paul committed
268
        std::unordered_map<std::string, unsigned> keywords;
Paul's avatar
Paul committed
269
        for(auto&& arg : arguments)
Paul's avatar
Paul committed
270
        {
Paul's avatar
Paul committed
271
            for(auto&& flag : arg.flags)
Paul's avatar
Paul committed
272
                keywords[flag] = arg.nargs + 1;
Paul's avatar
Paul committed
273
        }
Paul's avatar
Paul committed
274
275
        auto arg_map =
            generic_parse(std::move(args), [&](const std::string& x) { return keywords[x]; });
Paul's avatar
Paul committed
276
        for(auto&& arg : arguments)
Paul's avatar
Paul committed
277
        {
Paul's avatar
Paul committed
278
            auto flags = arg.flags;
Paul's avatar
Paul committed
279
            if(flags.empty())
Paul's avatar
Paul committed
280
                flags = {""};
Paul's avatar
Paul committed
281
            for(auto&& flag : flags)
Paul's avatar
Paul committed
282
            {
Paul's avatar
Paul committed
283
                if(arg_map.count(flag) > 0)
Paul's avatar
Paul committed
284
                {
Paul's avatar
Paul committed
285
                    if(arg.action(*this, arg_map[flag]))
Paul's avatar
Paul committed
286
                        return true;
Paul's avatar
Paul committed
287
288
289
                }
            }
        }
Paul's avatar
Paul committed
290
        return false;
Paul's avatar
Paul committed
291
292
293
294
295
296
297
298
299
    }

    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;
Paul's avatar
Paul committed
300
        bool clear = false;
Paul's avatar
Paul committed
301
302
        for(auto&& x : as)
        {
Paul's avatar
Paul committed
303
304
            auto k = is_keyword(x);
            if(k > 0)
Paul's avatar
Paul committed
305
306
307
            {
                flag = x;
                result[flag]; // Ensure the flag exists
Paul's avatar
Paul committed
308
                if(k == 1)
Paul's avatar
Paul committed
309
                    flag = "";
Paul's avatar
Paul committed
310
                else if(k == 2)
Paul's avatar
Paul committed
311
312
313
                    clear = true;
                else
                    clear = false;
Paul's avatar
Paul committed
314
315
316
317
            }
            else
            {
                result[flag].push_back(x);
Paul's avatar
Paul committed
318
                if(clear)
Paul's avatar
Paul committed
319
320
                    flag = "";
                clear = false;
Paul's avatar
Paul committed
321
322
323
324
            }
        }
        return result;
    }
Paul's avatar
Paul committed
325

Paul's avatar
Paul committed
326
    private:
Paul's avatar
Paul committed
327
    std::vector<argument> arguments;
Paul's avatar
Paul committed
328
329
};

Paul's avatar
Paul committed
330
331
332
333
} // namespace MIGRAPHX_INLINE_NS
} // namespace driver
} // namespace migraphx

Paul's avatar
Paul committed
334
#endif