/home/renji/Data/projects/zenlang/sources/zbl/CmdLine.hpp

Go to the documentation of this file.

#pragma once

namespace zbl {
    namespace {

        template <typename T>
        inline void setValue(const z::string& str, T& val);

        template <>
        inline void setValue<bool>(const z::string& str, bool& val) {
            unused(str);
            val = true;
        }

        template <>
        inline void setValue<int>(const z::string& str, int& val) {
            val = str.toLong();
        }

        template <>
        inline void setValue<z::string>(const z::string& str, z::string& val) {
            val = str;
        }

        template <>
        inline void setValue<z::stringlist>(const z::string& str, z::stringlist& val) {
            val.append(str);
        }
    }


    template <typename ObjT, typename T>
    struct callMethod {
        static inline void call(const z::string& str, ObjT& (ObjT::*fn)(const T& val), ObjT& obj);
    };

    template <typename ObjT>
    struct callMethod<ObjT, bool> {
        static inline void call(const z::string& str, ObjT& (ObjT::*fn)(const bool& val), ObjT& obj) {
            unused(str);
            (obj.*fn)(true);
        }
    };

    template <typename ObjT>
    struct callMethod<ObjT, int> {
        static inline void call(const z::string& str, ObjT& (ObjT::*fn)(const int& val), ObjT& obj) {
            (obj.*fn)(str.toLong());
        }
    };

    template <typename ObjT>
    struct callMethod<ObjT, z::string> {
        static inline void call(const z::string& str, ObjT& (ObjT::*fn)(const z::string& val), ObjT& obj) {
            (obj.*fn)(str);
        }
    };

    namespace {

        template <typename T>
        inline bool shouldInc(const bool& val) {
            return val;
        }

        template <>
        inline bool shouldInc<bool>(const bool& val) {
            unused(val);
            return false;
        }
    }


    class OptionBase {
    public:
        inline OptionBase(const z::string& sname, const z::string& lname, const z::string& desc) : _sname(sname), _lname(lname), _desc(desc){}

    public:
        virtual void handle(const bool& isOption, z::stringlist::iterator& it) = 0;

        inline  void show(z::stream& str, const int& w = 32) const;

    private:
        z::string _sname;

        z::string _lname;

        z::string _desc;
    };

    template <typename T>
    class OptionVar : public OptionBase {
    public:
        inline OptionVar(const z::string& sname, const z::string& lname, const z::string& desc, T& val) : OptionBase(sname, lname, desc), _val(val) {}

    public:
        virtual void handle(const bool& isOption, z::stringlist::iterator& it) {
            if(shouldInc<T>(isOption))
                ++it;
            if(!it.end())
                setValue<T>(*it, _val);
        }

    private:
        T& _val;
    };

    template <typename ObjT, typename T>
    class OptionCall : public OptionBase {
    public:
        inline OptionCall(const z::string& sname, const z::string& lname, const z::string& desc, ObjT& (ObjT::*fn)(const T& val), ObjT& obj)
          : OptionBase(sname, lname, desc), _fn(fn), _obj(obj) {}

    public:
        virtual void handle(const bool& isOption, z::stringlist::iterator& it) {
            if(shouldInc<T>(isOption))
                ++it;
            if(!it.end()) {
                callMethod<ObjT, T>::call(*it, _fn, _obj);
            }
        }

    private:
        ObjT& (ObjT::*_fn)(const T& val);

        ObjT& _obj;
    };

    inline void OptionBase::show(z::stream& str, const int& w) const {
        if((_sname.length() > 0) && (_lname.length() > 0)) {
            z::string rv = _sname + z::string(", ") + _lname;
            str << "  " << rv.leftJustified(w) << _desc << z::end();
        } else {
            str << "  " << _desc << z::end();
        }
    }

    class CmdLine {
    private:
        typedef z::sharedptr<OptionBase> OptPtr_t;

        typedef z::list<OptPtr_t> OptList_t;

        typedef z::dict<z::string, OptionBase* > Map_t;

        typedef z::list<OptionBase* > List_t;

    public:
        class Command {
        public:
            inline Command() : _value(0), _posArg(0) {}

        private:
            template <typename T>
            inline OptionBase& createVar(const z::string& sname, const z::string& lname, const z::string& desc, T& val);

            template <typename ObjT, typename T>
            inline OptionBase& createCall(const z::string& sname, const z::string& lname, const z::string& desc, ObjT& (ObjT::*fn)(const T& val), ObjT& obj );

        public:
            template <typename T>
            inline void addOptionVar(const z::string& sname, const z::string& lname, const z::string& desc, T& val);

            template <typename ObjT, typename T>
            inline void addOptionCall(const z::string& sname, const z::string& lname, const z::string& desc, ObjT& (ObjT::*fn)(const T& val), ObjT& obj );

            template <typename T>
            inline void addParameterVar(const z::string& desc, T& val);

            inline void addParameterListVar(const z::string& desc, z::stringlist& list);

            template <typename ObjT>
            inline void addParameterListCall(const z::string& desc, ObjT& (ObjT::*fn)(const z::string& val), ObjT& obj);

        public:
            OptList_t _optList;

            z::string _key;

            z::string _desc;

            int _value;

        public:
            Map_t _map;

            List_t _list;

        public:
            OptionBase* _posArg;
        };

    private:
        typedef z::dict<z::string, Command > CmdMap_t;

        typedef z::list<Command* > CmdList_t;

    public:
        CmdLine(const z::string& desc) : _desc(desc) {}

    public:
        inline Command& addCommand(const z::string& cmd, int value, const z::string& desc);

    public:
        inline const int& getCommand() const;

        inline const z::string& getError() const;

    public:
        inline int parse(int argc, char* argv[]);

        inline int parse(const z::stringlist& args);

        inline void show(z::stream& str) const;

    private:
        inline const Command* hasCommandMap(z::stringlist::iterator& it);

        inline const Command& getCommandMap(z::stringlist::iterator& it);

    private:
        CmdMap_t _cmdMap;

        CmdList_t _cmdList;

    private:
        z::string _appName;

        int _command;

        z::string _desc;

        z::string _error;
    };

    template <typename T>
    inline OptionBase& CmdLine::Command::createVar(const z::string& sname, const z::string& lname, const z::string& desc, T& val) {
        OptPtr_t opt(new OptionVar<T>(sname, lname, desc, val));
        _optList.append(opt);
        return *opt;
    }

    template <typename ObjT, typename T>
    inline OptionBase& CmdLine::Command::createCall(const z::string& sname, const z::string& lname, const z::string& desc, ObjT& (ObjT::*fn)(const T& val), ObjT& obj ) {
        OptPtr_t opt(new OptionCall<ObjT, T>(sname, lname, desc, fn, obj));
        _optList.append(opt);
        return *opt;
    }

    template <typename T>
    inline void CmdLine::Command::addOptionVar(const z::string& sname, const z::string& lname, const z::string& desc, T& val) {
        OptionBase& opt = createVar(sname, lname, desc, val);
        _map[sname] = ptr(opt);
        _map[lname] = ptr(opt);
    }

    template <typename ObjT, typename T>
    inline void CmdLine::Command::addOptionCall(const z::string& sname, const z::string& lname, const z::string& desc, ObjT& (ObjT::*fn)(const T& val), ObjT& obj ) {
        OptionBase& opt = createCall(sname, lname, desc, fn, obj);
        _map[sname] = ptr(opt);
        _map[lname] = ptr(opt);
    }

    template <typename T>
    inline void CmdLine::Command::addParameterVar(const z::string& desc, T& val) {
        OptionBase& par = createVar(z::string(""), z::string(""), desc, val);
        _list.append(ptr(par));
    }

    inline void CmdLine::Command::addParameterListVar(const z::string& desc, z::stringlist& list) {
        assert(0 == _posArg);
        OptionBase& par = createVar(z::string(""), z::string(""), desc, list);
        _posArg = ptr(par);
    }

    template <typename ObjT>
    inline void CmdLine::Command::addParameterListCall(const z::string& desc, ObjT& (ObjT::*fn)(const z::string& val), ObjT& obj) {
        assert(0 == _posArg);
        OptionBase& par = createCall(z::string(""), z::string(""), desc, fn, obj);
        _posArg = ptr(par);
    }

    inline const int& CmdLine::getCommand() const {
        assert(_cmdMap.size() > 0);
        return _command;
    }

    inline const z::string& CmdLine::getError() const {
        return _error;
    }

    inline CmdLine::Command& CmdLine::addCommand(const z::string& cmd, int value, const z::string& desc) {
        assert(!_cmdMap.has(cmd));
        Command& cmdd = _cmdMap[cmd];
        cmdd._key  = cmd;
        cmdd._desc = desc;
        cmdd._value = value;
        _cmdList.append(ptr(cmdd));
        return cmdd;
    }

    inline void CmdLine::show(z::stream& str) const {
        // check if there is at least 1 non-empty command
        bool hasCmd = false;
        for(CmdList_t::iterator cit(_cmdList); !cit.end();++cit) {
            const Command& cmd = ref(*cit);
            if(cmd._key.length() > 0) {
                hasCmd = true;
                break;
            }
        }
        str << _appName << " <command> <options> " << z::end();
        if(_desc.length() > 0) {
            str << _desc << z::end();
        }

        if(hasCmd) {
            str << "commands: ";
            z::string sep = z::string("");
            for(CmdList_t::iterator cit(_cmdList); !cit.end();++cit) {
                const Command& cmd = ref(*cit);
                str << sep << ((cmd._key.length() > 0)?(cmd._key):z::string("<none>"));
                sep = z::string(", ");
            }
            str << z::end();
            str << z::end();
        }

        for(CmdList_t::iterator cit(_cmdList); !cit.end();++cit) {
            const Command& cmd = ref(*cit);
            if(cmd._key.length() > 0) {
                str << cmd._key << ": " << cmd._desc << z::end();
            }

            for(OptList_t::iterator it(cmd._optList); !it.end(); ++it) {
                const OptionBase& opt = **it;
                opt.show(str);
            }
            str << z::end();
        }
    }

    inline const CmdLine::Command* CmdLine::hasCommandMap(z::stringlist::iterator& it) {
        if (it.end()) {
            // if 'it' is at end of list, return true if we have a def command
            if(_cmdMap.has(z::string("")))
                return ptr(_cmdMap[z::string("")]);
            return 0;
        }

        // assume *it is a command, find it in _cmdMap
        CmdMap_t::found f1 = _cmdMap.find(*it);
        if(f1) {
            ++it;
            return ptr(*f1);
        }

        // if *it not found, but we have a def command, return true.
        CmdMap_t::found f2 = _cmdMap.find(z::string(""));
        if(f2) {
            return ptr(*f2);
        }

        return 0;
    }

    inline const CmdLine::Command& CmdLine::getCommandMap(z::stringlist::iterator& it) {
        // if command is not found and there is a default, use that.
        if (it.end()) {
            // if there is no default, we should reach this point at all.
            assert(_cmdMap.has(z::string("")));
            return _cmdMap[z::string("")];
        }

        assert(!it.end());
        z::string command = *it;

        if((!_cmdMap.has(command)) && (_cmdMap.has(z::string("")))) {
            return _cmdMap[z::string("")];
        }

        assert(_cmdMap.has(command));
        ++it;
        return _cmdMap[command];
    }

    inline int CmdLine::parse(const z::stringlist& args) {
        z::stringlist::iterator it(args);

        // first argument is app name
        _appName = *it;
        ++it;

        // next is command
        const Command* cmd = hasCommandMap(it);
        if (!cmd) {
            _error = z::string("Invalid command: ") + ((!it.end())?*it:z::string(""));
            return 1;
        }

        _command = ref(cmd)._value;

        // parse all options
        while(!it.end()) {
            const z::string& str = *it;
            Map_t::found found = ref(cmd)._map.find(str);
            if(!found) {
                if(str.at(0) == '-') {
                    // it can -x, --x or ---x (where <x> is any option)
                    _error = z::string("Invalid option: ") + str;
                    return 1;
                }
                break;
            }

            OptionBase* opt = *found;
            opt->handle(true, it);
            if(!it.end())
                ++it;
        }

        // parse positional parameters
        for(List_t::iterator pit(ref(cmd)._list); !pit.end() && (!it.end()); ++pit) {
            OptionBase* opt = *pit;
            opt->handle(false, it);
            if(!it.end())
                ++it;
        }


        if(ref(cmd)._posArg != 0) {
            // rest of arguments
            while(!it.end()) {
                ref(cmd)._posArg->handle(false, it);
                if(!it.end())
                    ++it;
            }
        }

        if(!it.end()) {
            _error = z::string("Unknown parameters");
            return 1;
        }

        return 0;
    }

    inline int CmdLine::parse(int argc, char* argv[]) {
        z::stringlist args;
        for(int i = 0; i < argc; ++i) {
            z::string arg(argv[i]);
            args.append(arg);
        }
        return parse(args);
    }
}