path: root/vendor/github.com/dexon-foundation/mcl/include/cybozu/option.hpp

#pragma once
/**
    @file
    @brief command line parser

    @author MITSUNARI Shigeo(@herumi)
*/
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <iostream>
#include <limits>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <cybozu/exception.hpp>
#include <cybozu/atoi.hpp>

/*
    Option parser

    progName (opt1-name|opt2-name|...) param1 param2 ...
      param1:param1-help
      param2:param2-help
      -op1-name:opt1-help
      ...

    How to setup
    int num;
    -n num ; (optional) option => appendOpt(&x, <defaultValue>, "num", "num-help");
    -n num ; must option       => appendMust(&x, "num", "num-help");

    std::vector<int> v;
    -v s1 s2 s3 ...            => appendVec(&v, "v");

    Remark1: terminate parsing of v if argv begins with '-[^0-9]'
    Remark2: the begining character of opt-name is not a number ('0'...'9')
             because avoid conflict with minus number

    std::string file1;
    file1 is param             => appendParam(&file1, "input-file");
    file2 is optional param    => appendParamOpt(&file2, "output-file");

    How to use
    opt.parse(argc, argv);

    see sample/option_smpl.cpp
*/

namespace cybozu {

struct OptionError : public cybozu::Exception {
    enum Type {
        NoError = 0,
        BAD_OPT = 1,
        BAD_VALUE,
        NO_VALUE,
        OPT_IS_NECESSARY,
        PARAM_IS_NECESSARY,
        REDUNDANT_VAL,
        BAD_ARGC
    };
    Type type;
    int argPos;
    OptionError()
        : cybozu::Exception("OptionError", false)
        , type(NoError)
        , argPos(0)
    {
    }
    cybozu::Exception& set(Type _type, int _argPos = 0)
    {
        this->type = _type;
        this->argPos = _argPos;
        switch (_type) {
        case BAD_OPT:
            (*this) << "bad opt";
            break;
        case BAD_VALUE:
            (*this) << "bad value";
            break;
        case NO_VALUE:
            (*this) << "no value";
            break;
        case OPT_IS_NECESSARY:
            (*this) << "opt is necessary";
            break;
        case PARAM_IS_NECESSARY:
            (*this) << "param is necessary";
            break;
        case REDUNDANT_VAL:
            (*this) << "redundant argVal";
            break;
        case BAD_ARGC:
            (*this) << "bad argc";
        default:
            break;
        }
        return *this;
    }
};

namespace option_local {

template<class T>
bool convert(T* x, const char *str)
{
    std::istringstream is(str);
    is >> *x;
    return !!is;
}

template<>
inline bool convert(std::string* x, const char *str)
{
    *x = str;
    return true;
}

template<class T>
bool convertInt(T* x, const char *str)
{
    if (str[0] == '0' && str[1] == 'x') {
        bool b;
        *x = cybozu::hextoi(&b, str + 2);
        return b;
    }
    size_t len = strlen(str);
    int factor = 1;
    if (len > 1) {
        switch (str[len - 1]) {
        case 'k': factor = 1000; len--; break;
        case 'm': factor = 1000 * 1000; len--; break;
        case 'g': factor = 1000 * 1000 * 1000; len--; break;
        case 'K': factor = 1024; len--; break;
        case 'M': factor = 1024 * 1024; len--; break;
        case 'G': factor = 1024 * 1024 * 1024; len--; break;
        default: break;
        }
    }
    bool b;
    T y = cybozu::atoi(&b, str, len);
    if (!b) return false;
    if (factor > 1) {
        if ((std::numeric_limits<T>::min)() / factor <= y
            && y <= (std::numeric_limits<T>::max)() / factor) {
            *x = y * factor;
        } else {
            return false;
        }
    } else {
        *x = y;
    }
    return true;
}

#define CYBOZU_OPTION_DEFINE_CONVERT_INT(type) \
template<>inline bool convert(type* x, const char *str) { return convertInt(x, str); }

CYBOZU_OPTION_DEFINE_CONVERT_INT(int)
CYBOZU_OPTION_DEFINE_CONVERT_INT(long)
CYBOZU_OPTION_DEFINE_CONVERT_INT(long long)

CYBOZU_OPTION_DEFINE_CONVERT_INT(unsigned int)
CYBOZU_OPTION_DEFINE_CONVERT_INT(unsigned long)
CYBOZU_OPTION_DEFINE_CONVERT_INT(unsigned long long)

#undef CYBOZU_OPTION_DEFINE_CONVERT_INT

struct HolderBase {
    virtual ~HolderBase(){}
    virtual bool set(const char*) = 0;
    virtual HolderBase *clone() const = 0;
    virtual std::string toStr() const = 0;
    virtual const void *get() const = 0;
};

template<class T>
struct Holder : public HolderBase {
    T *p_;
    Holder(T *p) : p_(p) {}
    HolderBase *clone() const { return new Holder(p_); }
    bool set(const char *str) { return option_local::convert(p_, str); }
    std::string toStr() const
    {
        std::ostringstream os;
        os << *p_;
        return os.str();
    }
    const void *get() const { return (void*)p_; }
};

/*
    for gcc 7 with -fnew-ttp-matching
    this specialization is not necessary under -fno-new-ttp-matching
*/
template struct Holder<std::string>;

template<class T, class Alloc, template<class T_, class Alloc_>class Container>
struct Holder<Container<T, Alloc> > : public HolderBase {
    typedef Container<T, Alloc> Vec;
    Vec *p_;
    Holder(Vec *p) : p_(p) {}
    HolderBase *clone() const { return new Holder<Vec>(p_); }
    bool set(const char *str)
    {
        T t;
        bool b = option_local::convert(&t, str);
        if (b) p_->push_back(t);
        return b;
    }
    std::string toStr() const
    {
        std::ostringstream os;
        bool isFirst = true;
        for (typename Vec::const_iterator i = p_->begin(), ie = p_->end(); i != ie; ++i) {
            if (isFirst) {
                isFirst = false;
            } else {
                os << ' ';
            }
            os << *i;
        }
        return os.str();
    }
    const void *get() const { return (void*)p_; }
};

class Var {
    HolderBase *p_;
    bool isSet_;
public:
    Var() : p_(0), isSet_(false) { }
    Var(const Var& rhs) : p_(rhs.p_->clone()), isSet_(false) { }
    template<class T>
    explicit Var(T *x) : p_(new Holder<T>(x)), isSet_(false) { }

    ~Var() { delete p_; }

    void swap(Var& rhs) CYBOZU_NOEXCEPT
    {
        std::swap(p_, rhs.p_);
        std::swap(isSet_, rhs.isSet_);
    }
    void operator=(const Var& rhs)
    {
        Var v(rhs);
        swap(v);
    }
    bool set(const char *str)
    {
        isSet_ = true;
        return p_->set(str);
    }
    std::string toStr() const { return p_ ? p_->toStr() : ""; }
    bool isSet() const { return isSet_; }
    const void *get() const { return p_ ? p_->get() : 0; }
};

} // option_local

class Option {
    enum Mode { // for opt
        N_is0 = 0, // for bool by appendBoolOpt()
        N_is1 = 1,
        N_any = 2
    };
    enum ParamMode {
        P_exact = 0, // one
        P_optional = 1, // zero or one
        P_variable = 2 // zero or greater
    };
    struct Info {
        option_local::Var var;
        Mode mode; // 0 or 1 or any ; for opt, not used for Param
        bool isMust; // this option is must
        std::string opt; // option param name without '-'
        std::string help; // description of option

        Info() : mode(N_is0), isMust(false) {}
        template<class T>
        Info(T* pvar, Mode mode, bool isMust, const char *opt, const std::string& help)
            : var(pvar)
            , mode(mode)
            , isMust(isMust)
            , opt(opt)
            , help(help)
        {
        }
        friend inline std::ostream& operator<<(std::ostream& os, const Info& self)
        {
            os << self.opt << '=' << self.var.toStr();
            if (self.var.isSet()) {
                os << " (set)";
            } else {
                os << " (default)";
            }
            return os;
        }
        void put() const
        {
            std::cout << *this;
        }
        void usage() const
        {
            printf("  -%s %s%s\n", opt.c_str(), help.c_str(), isMust ? " (must)" : "");
        }
        void shortUsage() const
        {
            printf(" -%s %s", opt.c_str(), mode == N_is0 ? "" : mode == N_is1 ? "para" : "para...");
        }
        bool isSet() const { return var.isSet(); }
        const void *get() const { return var.get(); }
    };
    typedef std::vector<Info> InfoVec;
    typedef std::vector<std::string> StrVec;
    typedef std::map<std::string, size_t> OptMap;
    InfoVec infoVec_;
    InfoVec paramVec_;
    Info remains_;
    OptMap optMap_;
    bool showOptUsage_;
    ParamMode paramMode_;
    std::string progName_;
    std::string desc_;
    std::string helpOpt_;
    std::string help_;
    std::string usage_;
    StrVec delimiters_;
    StrVec *remainsAfterDelimiter_;
    int nextDelimiter_;
    template<class T>
    void appendSub(T *pvar, Mode mode, bool isMust, const char *opt, const std::string& help)
    {
        const char c = opt[0];
        if ('0' <= c && c <= '9') throw cybozu::Exception("Option::appendSub:opt must begin with not number") << opt;
        if (optMap_.find(opt) != optMap_.end()) {
            throw cybozu::Exception("Option::append:duplicate option") << opt;
        }
        optMap_[opt] = infoVec_.size();
        infoVec_.push_back(Info(pvar, mode, isMust, opt, help));
    }

    template<class T, class U>
    void append(T *pvar, const U& defaultVal, bool isMust, const char *opt, const std::string& help = "")
    {
        *pvar = defaultVal;
        appendSub(pvar, N_is1, isMust, opt, help);
    }
    /*
        don't deal with negative number as option
    */
    bool isOpt(const char *str) const
    {
        if (str[0] != '-') return false;
        const char c = str[1];
        if ('0' <= c && c <= '9') return false;
        return true;
    }
    void verifyParamMode()
    {
        if (paramMode_ != P_exact) throw cybozu::Exception("Option:appendParamVec:appendParam is forbidden after appendParamOpt/appendParamVec");
    }
    std::string getBaseName(const std::string& name) const
    {
        size_t pos = name.find_last_of("/\\");
        if (pos == std::string::npos) return name;
        return name.substr(pos + 1);
    }
    bool inDelimiters(const std::string& str) const
    {
        return std::find(delimiters_.begin(), delimiters_.end(), str) != delimiters_.end();
    }
public:
    Option()
        : showOptUsage_(true)
        , paramMode_(P_exact)
        , remainsAfterDelimiter_(0)
        , nextDelimiter_(-1)
    {
    }
    virtual ~Option() {}
    /*
        append optional option with default value
        @param pvar [in] pointer to option variable
        @param defaultVal [in] default value
        @param opt [in] option name
        @param help [in] option help
        @note you can use 123k, 56M if T is int/long/long long
        k : *1000
        m : *1000000
        g : *1000000000
        K : *1024
        M : *1024*1024
        G : *1024*1024*1024
    */
    template<class T, class U>
    void appendOpt(T *pvar, const U& defaultVal, const char *opt, const std::string& help = "")
    {
        append(pvar, defaultVal, false, opt, help);
    }
    /*
        default value of *pvar is false
    */
    void appendBoolOpt(bool *pvar, const char *opt, const std::string& help = "")
    {
        *pvar = false;
        appendSub(pvar, N_is0, false, opt, help);
    }
    /*
        append necessary option
        @param pvar [in] pointer to option variable
        @param opt [in] option name
        @param help [in] option help
    */
    template<class T>
    void appendMust(T *pvar, const char *opt, const std::string& help = "")
    {
        append(pvar, T(), true, opt, help);
    }
    /*
        append vector option
        @param pvar [in] pointer to option variable
        @param opt [in] option name
        @param help [in] option help
    */
    template<class T, class Alloc, template<class T_, class Alloc_>class Container>
    void appendVec(Container<T, Alloc> *pvar, const char *opt, const std::string& help = "")
    {
        appendSub(pvar, N_any, false, opt, help);
    }
    /*
        append parameter
        @param pvar [in] pointer to parameter
        @param opt [in] option name
        @param help [in] option help
    */
    template<class T>
    void appendParam(T *pvar, const char *opt, const std::string& help = "")
    {
        verifyParamMode();
        paramVec_.push_back(Info(pvar, N_is1, true, opt, help));
    }
    /*
        append optional parameter
        @param pvar [in] pointer to parameter
        @param defaultVal [in] default value
        @param opt [in] option name
        @param help [in] option help
        @note you can call appendParamOpt once after appendParam
    */
    template<class T, class U>
    void appendParamOpt(T *pvar, const U& defaultVal, const char *opt, const std::string& help = "")
    {
        verifyParamMode();
        *pvar = defaultVal;
        paramMode_ = P_optional;
        paramVec_.push_back(Info(pvar, N_is1, false, opt, help));
    }
    /*
        append remain parameter
        @param pvar [in] pointer to vector of parameter
        @param opt [in] option name
        @param help [in] option help
        @note you can call appendParamVec once after appendParam
    */
    template<class T, class Alloc, template<class T_, class Alloc_>class Container>
    void appendParamVec(Container<T, Alloc> *pvar, const char *name, const std::string& help = "")
    {
        verifyParamMode();
        paramMode_ = P_variable;
        remains_.var = option_local::Var(pvar);
        remains_.mode = N_any;
        remains_.isMust = false;
        remains_.opt = name;
        remains_.help = help;
    }
    void appendHelp(const char *opt, const std::string& help = ": show this message")
    {
        helpOpt_ = opt;
        help_ = help;
    }
    /*
        stop parsing after delimiter is found
        @param delimiter [in] string to stop
        @param remain [out] set remaining strings if remain
    */
    void setDelimiter(const std::string& delimiter, std::vector<std::string> *remain = 0)
    {
        delimiters_.push_back(delimiter);
        remainsAfterDelimiter_ = remain;
    }
    /*
        stop parsing after delimiter is found
        @param delimiter [in] string to stop to append list of delimiters
    */
    void appendDelimiter(const std::string& delimiter)
    {
        delimiters_.push_back(delimiter);
    }
    /*
        clear list of delimiters
    */
    void clearDelimiterList() { delimiters_.clear(); }
    /*
        return the next position of delimiter between [0, argc]
        @note return argc if delimiter is not set nor found
    */
    int getNextPositionOfDelimiter() const { return nextDelimiter_; }
    /*
        parse (argc, argv)
        @param argc [in] argc of main
        @param argv [in] argv of main
        @param startPos [in] start position of argc
        @param progName [in] used instead of argv[0]
    */
    bool parse(int argc, const char *const argv[], int startPos = 1, const char *progName = 0)
    {
        if (argc < 1 || startPos > argc) return false;
        progName_ = getBaseName(progName ? progName : argv[startPos - 1]);
        nextDelimiter_ = argc;
        OptionError err;
        for (int pos = startPos; pos < argc; pos++) {
            if (inDelimiters(argv[pos])) {
                nextDelimiter_ = pos + 1;
                if (remainsAfterDelimiter_) {
                    for (int i = nextDelimiter_; i < argc; i++) {
                        remainsAfterDelimiter_->push_back(argv[i]);
                    }
                }
                break;
            }
            if (isOpt(argv[pos])) {
                const std::string str = argv[pos] + 1;
                if (helpOpt_ == str) {
                    usage();
                    exit(0);
                }
                OptMap::const_iterator i = optMap_.find(str);
                if (i == optMap_.end()) {
                    err.set(OptionError::BAD_OPT, pos);
                    goto ERR;
                }

                Info& info = infoVec_[i->second];
                switch (info.mode) {
                case N_is0:
                    if (!info.var.set("1")) {
                        err.set(OptionError::BAD_VALUE, pos);
                        goto ERR;
                    }
                    break;
                case N_is1:
                    pos++;
                    if (pos == argc) {
                        err.set(OptionError::BAD_VALUE, pos) << (std::string("no value for -") + info.opt);
                        goto ERR;
                    }
                    if (!info.var.set(argv[pos])) {
                        err.set(OptionError::BAD_VALUE, pos) << (std::string(argv[pos]) + " for -" + info.opt);
                        goto ERR;
                    }
                    break;
                case N_any:
                default:
                    {
                        pos++;
                        int j = 0;
                        while (pos < argc && !isOpt(argv[pos])) {
                            if (!info.var.set(argv[pos])) {
                                err.set(OptionError::BAD_VALUE, pos) << (std::string(argv[pos]) + " for -" + info.opt) << j;
                                goto ERR;
                            }
                            pos++;
                            j++;
                        }
                        if (j > 0) {
                            pos--;
                        } else {
                            err.set(OptionError::NO_VALUE, pos) << (std::string("for -") + info.opt);
                            goto ERR;
                        }
                    }
                    break;
                }
            } else {
                bool used = false;
                for (size_t i = 0; i < paramVec_.size(); i++) {
                    Info& param = paramVec_[i];
                    if (!param.var.isSet()) {
                        if (!param.var.set(argv[pos])) {
                            err.set(OptionError::BAD_VALUE, pos) << (std::string(argv[pos]) + " for " + param.opt);
                            goto ERR;
                        }
                        used = true;
                        break;
                    }
                }
                if (!used) {
                    if (paramMode_ == P_variable) {
                        remains_.var.set(argv[pos]);
                    } else {
                        err.set(OptionError::REDUNDANT_VAL, pos) << argv[pos];
                        goto ERR;
                    }
                }
            }
        }
        // check whether must-opt is set
        for (size_t i = 0; i < infoVec_.size(); i++) {
            const Info& info = infoVec_[i];
            if (info.isMust && !info.var.isSet()) {
                err.set(OptionError::OPT_IS_NECESSARY) << info.opt;
                goto ERR;
            }
        }
        // check whether param is set
        for (size_t i = 0; i < paramVec_.size(); i++) {
            const Info& param = paramVec_[i];
            if (param.isMust && !param.var.isSet()) {
                err.set(OptionError::PARAM_IS_NECESSARY) << param.opt;
                goto ERR;
            }
        }
        // check whether remains is set
        if (paramMode_ == P_variable && remains_.isMust && !remains_.var.isSet()) {
            err.set(OptionError::PARAM_IS_NECESSARY) << remains_.opt;
            goto ERR;
        }
        return true;
    ERR:
        assert(err.type);
        printf("%s\n", err.what());
        return false;
    }
    /*
        show desc at first in usage()
    */
    void setDescription(const std::string& desc)
    {
        desc_ = desc;
    }
    /*
        show command line after desc
        don't put option message if not showOptUsage
    */
    void setUsage(const std::string& usage, bool showOptUsage = false)
    {
        usage_ = usage;
        showOptUsage_ = showOptUsage;
    }
    void usage() const
    {
        if (!desc_.empty()) printf("%s\n", desc_.c_str());
        if (usage_.empty()) {
            printf("usage:%s", progName_.c_str());
            if (!infoVec_.empty()) printf(" [opt]");
            for (size_t i = 0; i < infoVec_.size(); i++) {
                if (infoVec_[i].isMust) infoVec_[i].shortUsage();
            }
            for (size_t i = 0; i < paramVec_.size(); i++) {
                printf(" %s", paramVec_[i].opt.c_str());
            }
            if (paramMode_ == P_variable) {
                printf(" %s", remains_.opt.c_str());
            }
            printf("\n");
        } else {
            printf("%s\n", usage_.c_str());
            if (!showOptUsage_) return;
        }
        for (size_t i = 0; i < paramVec_.size(); i++) {
            const Info& param = paramVec_[i];
            if (!param.help.empty()) printf("  %s %s\n", paramVec_[i].opt.c_str(), paramVec_[i].help.c_str());
        }
        if (!remains_.help.empty()) printf("  %s %s\n", remains_.opt.c_str(), remains_.help.c_str());
        if (!helpOpt_.empty()) {
            printf("  -%s %s\n", helpOpt_.c_str(), help_.c_str());
        }
        for (size_t i = 0; i < infoVec_.size(); i++) {
            infoVec_[i].usage();
        }
    }
    friend inline std::ostream& operator<<(std::ostream& os, const Option& self)
    {
        for (size_t i = 0; i < self.paramVec_.size(); i++) {
            const Info& param = self.paramVec_[i];
            os << param.opt << '=' << param.var.toStr() << std::endl;
        }
        if (self.paramMode_ == P_variable) {
            os << "remains=" << self.remains_.var.toStr() << std::endl;
        }
        for (size_t i = 0; i < self.infoVec_.size(); i++) {
            os << self.infoVec_[i] << std::endl;
        }
        return os;
    }
    void put() const
    {
        std::cout << *this;
    }
    /*
        whether pvar is set or not
    */
    template<class T>
    bool isSet(const T* pvar) const
    {
        const void *p = static_cast<const void*>(pvar);
        for (size_t i = 0; i < paramVec_.size(); i++) {
            const Info& v = paramVec_[i];
            if (v.get() == p) return v.isSet();
        }
        if (remains_.get() == p) return remains_.isSet();
        for (size_t i = 0; i < infoVec_.size(); i++) {
            const Info& v = infoVec_[i];
            if (v.get() == p) return v.isSet();
        }
        throw cybozu::Exception("Option:isSet:no assigned var") << pvar;
    }
};

} // cybozu