option_parser.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <sstream>
#include <vector>
#include "interop/util/exception.h"
#include "interop/util/unique_ptr.h"

namespace illumina { namespace interop { namespace util
{

    class abstract_option
    {
    public:
        abstract_option(const std::string &flag, const std::string &help) : m_flag(flag), m_help(help)
        { }
        virtual ~abstract_option(){}

    public:
        virtual void set_value(const std::string& str) = 0;
        virtual std::string get_value()const = 0;

    public:
        const std::string &flag() const
        {
            return m_flag;
        }
        const std::string &help() const
        {
            return m_help;
        }

    private:
        std::string m_flag;
        std::string m_help;
    };
    class option_exception : public std::runtime_error
    {
    public:
        option_exception(const std::string& msg) : std::runtime_error(msg){}
    };
    class invalid_option_value_exception : public option_exception
    {
    public:
        invalid_option_value_exception(const std::string& msg) : option_exception(msg){}
    };
    class invalid_option_exception : public option_exception
    {
    public:
        invalid_option_exception(const std::string& msg) : option_exception(msg){}
    };
    template<typename T>
    class value_container
    {
    public:
        typedef T value_type;
        value_container(T* ptr) : m_ptr(ptr)
        {
        }

        void set_value(const value_type& val)const
        {
            *m_ptr = val;
        }
        const T& get()const
        {
            return *m_ptr;
        }

    private:
        T* m_ptr;
    };

    template<typename T, typename R, typename P1>
    class value_container< R (T::* )(P1) >
    {
        typedef R (T::* function_pointer )(P1);
    public:
        typedef P1 value_type;
        value_container(T* ptr_obj, function_pointer ptr_func) : m_obj(ptr_obj), m_func(ptr_func){}

        void set_value(const value_type& val)const
        {
            ((*m_obj).*m_func)(val);
        }
        std::string get()const
        {
            return "";
        }

    private:
        T* m_obj;
        function_pointer m_func;
    };
    template<typename T, typename R, typename P1>
    inline value_container< R (T::* )(P1) > wrap_setter(T& obj, R (T::* func)(P1))
    {
        return value_container< R (T::* )(P1) >(&obj, func);
    }



    template<typename T>
    class option : public abstract_option
    {
    public:
        option(const value_container<T>& value, const std::string &flag, const std::string &help) : abstract_option(flag, help), m_value(
                value)
        { }
        virtual ~option(){}

    public:
        void set_value(const std::string& str)
        {
            std::istringstream iss(str);
            typename value_container<T>::value_type val;
            iss >> val;
            m_value.set_value(val);
            int ch;
            if(!iss.eof() && (ch=iss.get()) != ' ')
            {
                INTEROP_THROW(invalid_option_value_exception, "Failed to parse character: " << static_cast<char>(ch));
            }
        }
        std::string get_value()const
        {
            std::ostringstream oss;
            oss << m_value.get();
            return oss.str();
        }

    private:
        value_container<T> m_value;
    };

    class option_parser
    {
        typedef stdbp::unique_ptr<abstract_option> option_pointer;
        typedef std::vector <option_pointer> option_vector;
    public:
        template<typename T>
        option_parser &operator()(T &value, const std::string &flag, const std::string &help)
        {
            m_options.push_back(option_pointer(new option<T>(&value, flag, help)));
            return *this;
        }
        template<typename T>
        option_parser &operator()(const value_container<T> &value, const std::string &flag, const std::string &help)
        {
            m_options.push_back(option_pointer(new option<T>(value, flag, help)));
            return *this;
        }
        bool is_help_requested(int argc, const char **argv)
        {
            const std::string help1 = "-help";
            const std::string help2 = "--help";
            const std::string help3 = "-h";
            for(int i=1;i<argc;++i)
            {
                if(help1 == argv[i]) return true;
                if(help2 == argv[i]) return true;
                if(help3 == argv[i]) return true;
            }
            return false;
        }
        void parse(int &argc, const char **argv)
        {
            for(int i=1;i<argc;++i)
            {
                if(!is_option(argv[i])) continue;
                if(parse_option(argv[i]))
                {
                    // Remove argument from command line
                    for (int j = i; j != argc; ++j) {
                        argv[j] = argv[j + 1];
                    }

                    // Decrements the argument count.
                    --argc;
                    --i;
                }
            }
        }
        void check_for_unknown_options(const int argc, const char **argv)
        {
            for(int i=1;i<argc;++i)
            {
                if(is_option(argv[i]))
                {
                    INTEROP_THROW(invalid_option_exception, "Unexpected option: " << argv[i]);
                }
            }
        }
        void display_help(std::ostream &out, const char* prefix="\t", const char* sep=": ", const char* postfix="\n")
        {
            for(size_t i=0;i<m_options.size();++i)
                out << prefix << "--"<< m_options[i]->flag() << "[" << m_options[i]->get_value() << "]" << sep << m_options[i]->help() << postfix;
        }

    private:
        bool is_option(const char* argv)
        {
            if(argv[0] == '\0' || argv[1] == '\0' ) return false;
            if(argv[0] != '-' || argv[1] != '-') return false;
            return true;
        }
        bool parse_option(const std::string& option)
        {
            std::string::size_type n;
            if((n=option.find('=')) == std::string::npos)
                INTEROP_THROW(invalid_option_exception, "Option must be of the form --option=value");
            for(size_t i=0;i<m_options.size();++i)
            {
                if(m_options[i]->flag() == option.substr(2, n-2) )
                {
                    m_options[i]->set_value(option.substr(n+1));
                    return true;
                }
            }
            return false;
        }

    private:
        option_vector m_options;
    };


}}}