Options.hpp

Go to the documentation of this file.

 
#ifndef _POWERDXX_NIH_OPTIONS_HPP_
#define _POWERDXX_NIH_OPTIONS_HPP_
 
#include "utility.hpp"  /* utility::literals */
 
#include <cstddef>      /* size_t */
#include <type_traits>  /* std::true_type, std::void_t */
#include <cassert>      /* assert() */
 
namespace nih {
 
template <class OptionT, class = void>
struct enum_has_members :  std::false_type {};
 
template <class OptionT>
struct enum_has_members<OptionT, std::void_t<decltype(OptionT::OPT_UNKNOWN),
                                             decltype(OptionT::OPT_NOOPT),
                                             decltype(OptionT::OPT_DASH),
                                             decltype(OptionT::OPT_LDASH),
                                             decltype(OptionT::OPT_DONE)>> : std::true_type {};
 
template <class OptionT>
struct Parameter {
    OptionT option;
 
    char sparam;
 
    char const * lparam;
 
    char const * args;
 
    char const * usage;
};
 
template <class OptionT>
size_t argCount(Parameter<OptionT> const & def) {
    if (!def.args || !def.args[0]) { return 0; }
    size_t argc = 1;
    for (char const * pch = def.args; *pch; ++pch) {
        argc += (*pch == ',' ? 1 : 0);
    }
    return argc;
}
 
template <class OptionT, size_t DefCount>
class Options {
    static_assert(enum_has_members<OptionT>::value,
                  "The enum must have the members OPT_UNKNOWN, OPT_NOOPT, OPT_DASH, OPT_LDASH and OPT_DONE");
    private:
    int const argc;
 
    char const * const * const argv;
 
    char const * const usageStr;
 
    Parameter<OptionT> const (& defs)[DefCount];
 
    Parameter<OptionT> const opt_unknown{
        OptionT::OPT_UNKNOWN, 0, nullptr, nullptr, nullptr
    };
 
    Parameter<OptionT> const opt_noopt{
        OptionT::OPT_NOOPT, 0, nullptr, nullptr, nullptr
    };
 
    Parameter<OptionT> const opt_dash{
        OptionT::OPT_DASH, 0, nullptr, nullptr, nullptr
    };
 
    Parameter<OptionT> const opt_ldash{
        OptionT::OPT_LDASH, 0, nullptr, nullptr, nullptr
    };
 
    int argi;
 
    char const * argp;
 
    Parameter<OptionT> const * current;
 
    int mutable showi;
 
    static char const * removePath(char const * const file) {
        auto result = file;
        for (auto ptr = file; *ptr; ++ptr) {
            if (*ptr == '/' || *ptr == '\\') {
                result = ptr + 1;
            }
        }
        return result;
    }
 
    static bool match(char const * const lstr, char const * const rstr) {
        size_t i = 0;
        for (; lstr[i] && rstr[i]; ++i) {
            if (lstr[i] != rstr[i]) { return false; }
        }
        return lstr[i] == rstr[i];
    }
 
    static bool bmatch(char const * const str,
                       char const * const prefix) {
        size_t i = 0;
        for (; str[i] && prefix[i]; ++i) {
            if (str[i] != prefix[i]) { return false; }
        }
        return !prefix[i];
    }
 
    Parameter<OptionT> const & get(char const ch) {
        for (auto const & def : this->defs) {
            if (def.sparam == ch) {
                return def;
            }
        }
        return this->opt_unknown;
    }
 
    Parameter<OptionT> const & get(char const * const str) {
        for (auto const & def : this->defs) {
            if (match(str, def.lparam)) {
                return def;
            }
        }
        return this->opt_unknown;
    }
 
    public:
    Options(int const argc, char const * const * const argv,
            char const * const usage,
            Parameter<OptionT> const (& defs)[DefCount]) :
        argc{argc}, argv{argv}, usageStr{usage}, defs{defs},
        argi{0}, argp{nullptr}, current{nullptr}, showi{0} {}
 
    Options & operator ()() {
        /* reset what to show() */
        this->showi = 0;
 
        /*
         * point argi and argp to the appropriate places
         */
        if (this->current) {
            /* this is not the first call */
            if (this->argp && this->argp[0] && this->argp[1]) {
                /* argp is set and does not point to the end
                 * of an argument */
                if (argCount(*this->current) == 0) {
                    /* proceed to the next short option */
                    ++this->argp;
                } else {
                    /* the chained characters were an
                     * option argument */
                    this->argp = nullptr;
                    this->argi += argCount(*this->current);
                }
            } else {
                /* point forward for the option stand alone
                 * case */
                this->argp = nullptr;
                this->argi += argCount(*this->current) + 1;
            }
        } else {
            /* no current state, start with the first argument */
            this->argi = 1;
            this->argp = nullptr;
        }
 
        /*
         * match the current option
         */
        /* ran out of options */
        if (this->argi >= this->argc) {
            /* reset state */
            this->current = nullptr;
            return *this;
        }
        /* continue short option chain */
        if (this->argp) {
            this->current = &get(this->argp[0]);
            return *this;
        }
        /* long option */
        if (bmatch(this->argv[this->argi], "--")) {
            if (!this->argv[this->argi][2]) {
                this->current = &this->opt_ldash;
                return *this;
            }
            this->current = &get(this->argv[this->argi] + 2);
            return *this;
        }
        /* short option */
        if (this->argv[this->argi][0] == '-') {
            if (!this->argv[this->argi][1]) {
                this->current = &this->opt_dash;
                return *this;
            }
            this->argp = this->argv[this->argi] + 1;
            this->current = &get(this->argp[0]);
            return *this;
        }
        /* not an option */
        this->current = &this->opt_noopt;
        return *this;
    }
 
    operator OptionT() const {
        return this->current
               ? this->current->option
               : OptionT::OPT_DONE;
    }
 
    char const * operator [](int const i) const {
        /* show() the latest requested argument */
        this->showi = i;
 
        /* argument is in the same string as option */
        if (this->argp && this->argp[0] && this->argp[1] && i > 0) {
            if (this->argi + i - 1 >= this->argc) {
                return "";
            }
            if (i == 1) {
                return this->argp + 1;
            }
            return this->argv[this->argi + i - 1];
        }
        /* read in front of arguments */
        if (this->argi + i < 0) {
            return "";
        }
        /* argument is in the string following the option */
        if (this->argi + i < this->argc) {
            return this->argv[this->argi + i];
        }
        /* read beyond end of arguments */
        return "";
    }
 
    std::string usage() const {
        using namespace utility::literals;
        auto result = "usage: %s %s\n\n"_fmt
            (removePath(this->argv[0]), this->usageStr);
 
        /* get column sizes */
        size_t lparam_max = 0;  /* length of the longest option */
        size_t args_max = 0;    /* length of the longest argument */
        for (auto const & def : this->defs) {
            if (def.lparam) {
                auto const len = std::string{def.lparam}.size();
                lparam_max =
                    lparam_max >= len ? lparam_max : len;
            }
            auto const len = std::string{def.args}.size();
            args_max = args_max >= len ? args_max : len;
        }
        /* print columns */
        for (auto const & def : this->defs) {
            /* get option */
            auto const sparam = def.sparam ? def.sparam : ' ';
            auto const sdash = def.sparam ? '-' : ' ';
            auto const lparam = def.lparam ? def.lparam : "";
            auto const ldash = lparam[0] ? '-' : ' ';
            auto const sep = def.sparam && lparam[0] ? ',' : ' ';
            result += "  %c%c%c %c%c%-*s  "_fmt
                (sdash, sparam, sep,
                 ldash, ldash, lparam_max, lparam);
            /* get arguments */
            auto len = args_max;
            for (auto it = def.args; it && *it; ++it, --len) {
                result += *it == ',' ? ' ' : *it;
            }
            result += "%-*s  %s\n"_fmt(len, "", def.usage);
        }
        return result;
    }
 
    utility::Underlined show(int const i, int const n = 1) const {
        using utility::highlight;
        using std::string;
 
        /* select a whole argument */
        char const * const select = (*this)[i];
        /* if the current option (i == 0) is requested, pick
         * up the pointer to the current short option character */
        char const * const argp = i == 0 ? this->argp : nullptr;
        string cmd;             /* command and arguments string */
        ptrdiff_t offset = -1;  /* the underline byte-offset */
        ptrdiff_t length = 1;   /* the underline byte-length */
        int remaining = 0;      /* #args left to underline */
        /* build cmd string */
        for (int p = 0; p < this->argc; ++p) {
            /* build each argument character wise */
            for (auto it = this->argv[p]; *it; ++it) {
                /* underline short option */
                if (argp && it == argp) {
                    remaining = n > 0 ? n : -1;
                    it[1] && --remaining;
                    offset = cmd.size();
                }
                /* underline long option / argument */
                if (!argp && it == select) {
                    remaining = n > 0 ? n : -1;
                    offset = cmd.size();
                }
                /* regular character */
                cmd += *it;
            }
            /* update the underline length */
            remaining && (length = cmd.size() - offset);
            remaining > 0 && --remaining;
            /* space separate arguments */
            cmd += ' ';
        }
        /* the selected argument must be behind the last argument,
         * e.g. because the last parameter is missing an argument
         * or the state is OPT_DONE */
        offset >= 0 || i < 0 || (offset = cmd.size());
        return highlight(cmd, offset, length);
    }
 
    std::string show() const {
        return show(this->showi);
    }
 
    int offset() const {
        return this->argi;
    }
};
 
} /* namespace nih */
 
#endif /* _POWERDXX_NIH_OPTIONS_HPP_ */