ArgParser.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <functional>
#include <iostream>
#include <memory>
#include <mutable/util/Diagnostic.hpp>
#include <mutable/util/macro.hpp>
#include <mutable/util/Pool.hpp>
#include <unordered_map>
#include <vector>
 
 
namespace m {
 
class M_EXPORT ArgParser
{
    /* Option for the ArgParser. */
    struct Option
    {
        Option(PooledOptionalString short_name, PooledOptionalString long_name, const char *description)
            : short_name(std::move(short_name))
            , long_name(std::move(long_name))
            , description(description)
        { }
 
        virtual ~Option() { }
 
        virtual void parse(const char **&argv) const = 0;
 
        PooledOptionalString short_name;
        PooledOptionalString long_name;
        const char *description;
    };
 
    template<typename T>
    struct OptionImpl : public Option
    {
        template<is_invocable<T> Callback>
        OptionImpl(PooledOptionalString short_name, PooledOptionalString long_name, const char* description, Callback &&callback)
            : Option(std::move(short_name), std::move(long_name), description)
            , callback(std::forward<Callback>(callback))
        { }
 
        void parse(const char **&argv) const override;
 
        std::function<void(T)> callback;
    };
 
    private:
    StringPool pool_;
    using options_t = std::vector<std::unique_ptr<const Option>>;
    options_t general_options_;
    std::unordered_map<PooledString, options_t> grouped_options_;
    std::vector<const char*> args_;
    std::unordered_map<PooledString, std::reference_wrapper<const Option>> key_map_;
    std::size_t short_len_ = 0;
    std::size_t long_len_  = 0;
 
    public:
    ArgParser() { }
    ~ArgParser() { }
 
    template<typename T, is_invocable<T> Callback>
    void add(const char *group_name, const char *short_name, const char *long_name, const char *description,
             Callback &&callback)
    {
        PooledOptionalString pooled_group_name, pooled_short_name, pooled_long_name;
        if (group_name) pooled_group_name  = pool_(group_name);
        if (short_name) pooled_short_name  = pool_(short_name);
        if (long_name)  pooled_long_name   = pool_(long_name);
 
        auto &options = group_name ? grouped_options_[pooled_group_name.assert_not_none()] : general_options_;
        options.push_back(std::make_unique<const OptionImpl<T>>(
            pooled_short_name, pooled_long_name, description, std::forward<Callback>(callback)
        ));
        auto it = std::prev(options.end());
 
        if (short_name) {
            auto res = key_map_.emplace(std::move(pooled_short_name), **it);
            M_insist(res.second, "name already in list");
            short_len_ = std::max(short_len_, strlen(short_name));
        }
 
        if (long_name) {
            auto res = key_map_.emplace(std::move(pooled_long_name), **it);
            M_insist(res.second, "name already in list");
            long_len_ = std::max(long_len_, strlen(long_name));
        }
    }
 
    template<typename T, is_invocable<T> Callback>
    void add(const char *short_name, const char *long_name, const char *description, Callback &&callback) {
        add<T>(nullptr, short_name, long_name, description, std::forward<Callback>(callback));
    }
 
    void print_args(std::ostream &out) const;
    void print_args() const { print_args(std::cout); }
 
    void parse_args(int argc, const char **argv);
 
    void operator()(int argc, const char **argv) { parse_args(argc, argv); }
 
    const std::vector<const char*> & args() const { return args_; }
};
 
M_LCOV_EXCL_START
inline std::ostream & operator<<(std::ostream &out, const ArgParser &AP)
{
    AP.print_args(out);
    return out;
}
M_LCOV_EXCL_STOP
 
}