av_parser.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * SHORE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_PROGRAM_AV_PARSER_HPP__
#define SHORE_PROGRAM_AV_PARSER_HPP__

#include <map>
#include <set>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include <unistd.h>
#include <getopt.h>

#include "shore/base/stringops.hpp"
#include "shore/datatype/coor.hpp"
#include "shore/base/mathops.hpp"

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits.hpp>

namespace shore {

enum OptionFlags
{
        OPT_NOTSET,
        OPT_SET,
        OPT_AUTO,
        OPT_MANDATORY
};

S_MAKE_ENUM_TRAITS(OptionFlags)

struct opt_base
{
        char shortopt;
        std::string longopt;
        std::string id;
        std::string label;

        bool is_switch;
        bool multiple;
        OptionFlags arg_default;
        std::string info;
        std::string aux_info;

        opt_base(const char sh,const std::string& lo);

        bool is_option() const;

        virtual ~opt_base() {}

        virtual void *ptr() const=0;

        virtual void store_arg(const char*const sval,const bool clear_arg)=0;

        virtual std::string argdefault_string() const=0;

        virtual std::string arg_format() const=0;
};

template<typename T>
std::string typestr(const T *const value,
  typename boost::disable_if<boost::is_integral<T> >::type *dummy_int=0,
  typename boost::disable_if<boost::is_float<T> >::type *dummy_float=0)
{
        return "STRING";
}

template<typename T>
std::string typestr(const T *const value,
  typename boost::enable_if<boost::is_integral<T> >::type *dummy_int=0)
{
        return "INT";
}

template<typename T>
std::string typestr(const T *const value,
  typename boost::enable_if<boost::is_float<T> >::type *dummy_float=0)
{
        return "FLOAT";
}

inline std::string typestr(const char *value)
{
        return "CHAR";
}

template<typename T>
std::string typestr(const shore::relabs<T> *const value)
{
        return typestr((T*)0)+"[%]";
}

template<typename T>
std::string typestr(const std::vector<T> *const value)
{
        return typestr((T*)0)+"[,...]";
}

template<typename T>
std::string typestr(const std::vector<std::vector<T> >*const value)
{
        return typestr((T*)0)+"[:...][,...]";
}

template<typename T>
std::string typestr(const std::set<T> *const value)
{
        return typestr((T*)0)+"[,...]";
}

template<typename T>
struct opt_base1
:public opt_base
{
        T* valueptr;

        opt_base1(const char sh,const std::string& lo,T*const ptr)
        :opt_base(sh,lo),valueptr(ptr)
        {}

        virtual void *ptr() const
        {
                return valueptr;
        }

        virtual std::string arg_format() const
        {
                return typestr((T*)0);
        }
};

template<typename T>
struct opt_base2
:public opt_base1<T>
{
        opt_base2(const char sh,const std::string& lo,T*const ptr)
        :opt_base1<T>(sh,lo,ptr)
        {}

        virtual void store_arg(const char*const sval,const bool clear_arg)
        {
                shore::parse_value(opt_base1<T>::valueptr,sval);
        }

        virtual std::string argdefault_string() const
        {
                return shore::to_string(*opt_base1<T>::valueptr,6);
        }
};

template<class T>
struct av_option
:public opt_base2<T>
{
        av_option(const char sh,const std::string& lo,T*const ptr)
        :opt_base2<T>(sh,lo,ptr)
        {}
};


class av_parser
{
 public:

        struct usage_error
        :public std::runtime_error
        {
                usage_error(const std::string& m=std::string());
        };

 private:

        struct opt_cmp
        {
                opt_base* o1;
                opt_cmp(opt_base* o);
                bool operator()(opt_base*const o2);
        };

        // setup variables
        bool m_posixly_correct;

        std::string m_currentGroup;

        std::vector<opt_base *> m_options;

        std::vector<std::string> m_groupnames;
        std::map<std::string,std::vector<const opt_base *> > m_opt_groups;

        std::vector<opt_base *> m_residualargs;
        std::vector<std::string> m_residualarg_names;

        std::map<const opt_base *,std::set<const opt_base *> > m_conflicts;
        std::map<const opt_base *,std::set<const opt_base *> > m_requirements;

        std::map<std::string,opt_base *> m_havespec;
        std::map<std::string,std::set<const opt_base *> > m_needspec_con;
        std::map<std::string,std::set<const opt_base *> > m_needspec_req;
        std::map<std::string,std::set<const opt_base *> > m_needspec_revreq;
        std::map<std::string,size_t> m_needspec_residual;

        // used by operator() / parse_conffile()
        std::set<const opt_base *> m_parsedOptions;
        std::set<const void *> m_alteredValues;

        std::map<const opt_base *,std::set<const opt_base *> > m_required;

        std::map<const opt_base *,std::set<const opt_base *> > m_forbidden;


        int m_ac;
        char** m_av;
        int m_new_ac;
        char** m_new_av;


        bool m_have_aux_info;

        av_parser(const av_parser&);

        void setup_dependencies(
          opt_base *const opt,const std::string &conflicts_with);

        std::set<const opt_base *> alternative_dependencies(
          const opt_base *opt,const opt_base *requiredby);

        void consistency_check();

        void update_dependencies(const opt_base *const opt);

 public:

        av_parser();
        ~av_parser();

        void set_posixly_correct(const bool p);

        std::string set_optiongroup(const std::string &grp=std::string());

        template<class T>
        void add_option(const std::string &longshort,
                        T *target,
                        const std::string &info,
                        const std::string &aux_info=std::string())
        {
                add_option(longshort,"",target,info,OPT_SET,aux_info);
        }

        template<class T>
        void add_option(const std::string& longshort,
                        T* target,
                        const std::string &info,
                        const OptionFlags def,
                        const std::string &aux_info=std::string())
        {
                add_option(longshort,"",target,info,def,aux_info);
        }

        template<class T>
        void add_option(const std::string &longshort,
                        const std::string &conflicts_with,
                        T *target,
                        const std::string &info,
                        const std::string &aux_info=std::string())
        {
                add_option(longshort,conflicts_with,target,info,OPT_SET,aux_info);
        }

        template<class T>
        void add_option(const std::string &longshort,
                        const std::string &conflicts_with,
                        T *target,
                        const std::string &info,
                        const OptionFlags def,
                        const std::string &aux_info=std::string())
        {
                std::vector<std::string> tok=shore::split(longshort,',');

                av_option<T>* opt;

                if(tok.size()==1)
                        opt=new av_option<T>(char(0),tok[0],target);
                else if((tok.size()==2)&&(tok[1].size()==1))
                        opt=new av_option<T>(tok[1][0],tok[0],target);
                else
                        throw std::logic_error("invalid option specification");

                const std::vector<opt_base *>::const_iterator conflspec=
                        std::find_if(m_options.begin(),m_options.end(),opt_cmp(opt));

                if(conflspec!=m_options.end())
                        throw std::logic_error("multiple or conflicting option"
                                               " specification: "
                                               +opt->label+" <-> "+(*conflspec)->label);

                opt->info=info;
                opt->aux_info=aux_info;
                opt->arg_default=def;

                setup_dependencies(opt,conflicts_with);

                m_options.push_back(opt);

                if(!(aux_info.empty()||m_currentGroup.empty()))
                        m_have_aux_info=true;

                if(m_opt_groups[m_currentGroup].empty())
                        m_groupnames.push_back(m_currentGroup);

                m_opt_groups[m_currentGroup].push_back(opt);
        }

        template<typename T>
        void add_residualargs(T *const target,
                              const std::string &name,
                              const OptionFlags def)
        {
                add_residualargs(target,name,"",def);
        }

        template<typename T>
        void add_residualargs(T *const target,
                              const std::string &name,
                              const std::string &conflicts_with=std::string(),
                              const OptionFlags def=OPT_NOTSET,
                              typename boost::disable_if<boost::is_const<T> >::type *dummy=0)
        {
                m_residualargs.push_back(new av_option<T>(char(0),"",target));
                m_residualargs.back()->arg_default=def;
                m_residualargs.back()->id='@'+name;
                m_residualargs.back()->label=name;
                m_residualarg_names.push_back(name);

                setup_dependencies(m_residualargs.back(),conflicts_with);
        }

        void add_residualargs(const std::string &opt_id,const std::string &name);

        bool allows_options() const;

        bool allows_residualargs() const;

        bool have_aux_info() const;

        void operator()(int ac,char* av[]);

        void parse_conffile(const std::string &fn,const std::string &section,
                            const std::set<std::string> &noinclude=std::set<std::string>());

        void dependency_check();

        int get_argc() const;

        char **get_argv() const;

        int get_residual_argc() const;

        char **get_residual_argv() const;

        bool is_altered(const void*const ptr) const;

        void set_altered(const void*const ptr);

        size_t num_altered() const;

        enum SummaryType
        {
                SUMMARY_STD,
                SUMMARY_COMPACT,
                SUMMARY_VERBOSE
        };

        std::string get_optionsummary(const SummaryType typ=SUMMARY_STD) const;

        std::string get_usagestring() const;
};


template<class T,class U>
struct av_option<std::pair<T,U> >
:public opt_base1<std::pair<T,U> >
{
        av_option(const char sh,const std::string& lo,std::pair<T,U>*const ptr)
        :opt_base1<std::pair<T,U> >(sh,lo,ptr)
        {}

        virtual void store_arg(const char*const sval,const bool clear_arg)
        {
                const std::vector<std::string> svv=shore::split(sval,',');

                if(svv.size()!=2)
                        throw std::runtime_error(
                          "arg is an invalid pair"\
                          " - exactly two values separated by a comma required");

                opt_base1<std::pair<T,U> >::valueptr->first=shore::parse_value<T>(svv[0]);
                opt_base1<std::pair<T,U> >::valueptr->second=shore::parse_value<U>(svv[1]);
        }

        virtual std::string argdefault_string() const
        {
                return shore::to_string(opt_base1<std::pair<T,U> >::valueptr->first,6)
                        +","+shore::to_string(opt_base1<std::pair<T,U> >::valueptr->second,6);
        }

        virtual std::string arg_format() const
        {
                return typestr((T*)0)+','+typestr((U*)0);
        }
};

template<class T>
struct av_option<std::vector<T> >
:public opt_base1<std::vector<T> >
{
        av_option(const char sh,const std::string& lo,std::vector<T>*const ptr)
        :opt_base1<std::vector<T> >(sh,lo,ptr)
        {
                opt_base1<std::vector<T> >::multiple=true;
        }

        virtual void store_arg(const char*const sval,const bool clear_arg)
        {
                // temporary result, only store if parsing succeeds
                const T parsed=shore::parse_value<T>(sval);

                if(clear_arg) opt_base1<std::vector<T> >::valueptr->clear();
                opt_base1<std::vector<T> >::valueptr->push_back(parsed);
        }

        virtual std::string argdefault_string() const
        {
                return shore::join(*opt_base1<std::vector<T> >::valueptr,",");
        }
};

template<class T>
struct av_option<std::set<T> >
:public opt_base1<std::set<T> >
{
        av_option(const char sh,const std::string& lo,std::set<T>*const ptr)
        :opt_base1<std::set<T> >(sh,lo,ptr)
        {
                opt_base1<std::set<T> >::multiple=true;
        }

        virtual void store_arg(const char*const sval,const bool clear_arg)
        {
                // temporary result, only store if parsing succeeds
                const T parsed=shore::parse_value<T>(sval);

                if(clear_arg) opt_base1<std::set<T> >::valueptr->clear();
                opt_base1<std::set<T> >::valueptr->insert(parsed);
        }

        virtual std::string argdefault_string() const
        {
                return shore::join(opt_base1<std::set<T> >::valueptr->begin(),
                                opt_base1<std::set<T> >::valueptr->end(),",");
        }
};

template<class T>
struct av_option<std::vector<std::vector<T> > >
:public opt_base1<std::vector<std::vector<T> > >
{
        av_option(const char sh,const std::string& lo,
          std::vector<std::vector<T> >*const ptr)
        :opt_base1<std::vector<std::vector<T> > >(sh,lo,ptr)
        {
                opt_base1<std::vector<std::vector<T> > >::multiple=true;
        }

        virtual void store_arg(const char*const sval,const bool clear_arg)
        {
                // temporary results, only store if parsing succeeds
                const std::vector<std::string> items=shore::split(sval,':');
                std::vector<T> iv;

                for(size_t j=0;j<items.size();++j)
                {
                        if(!items[j].empty()) iv.push_back(shore::parse_value<T>(items[j]));
                }

                if(clear_arg) opt_base1<std::vector<std::vector<T> > >::valueptr->clear();
                opt_base1<std::vector<std::vector<T> > >::valueptr->push_back(iv);
        }

        virtual std::string argdefault_string() const
        {
                std::vector<std::string> ret;
                for(size_t i=0;i<opt_base1<std::vector<std::vector<T> > >::valueptr->size();++i)
                        ret.push_back(shore::join((*opt_base1<std::vector<std::vector<T> > >::valueptr)[i],":"));
                return shore::join(ret,",");
        }
};

template<>
struct av_option<bool>
:public opt_base2<bool>
{
        av_option(const char sh,const std::string& lo,bool*const ptr)
        :opt_base2<bool>(sh,lo,ptr)
        {
                opt_base2<bool>::is_switch=true;
        }

        virtual void store_arg(const char*const sval,const bool clear_arg)
        {
                if(sval==0) (*opt_base2<bool>::valueptr)=true;
                else opt_base2<bool>::store_arg(sval,clear_arg);
        }

        virtual std::string argdefault_string() const
        {
                return (*opt_base2<bool>::valueptr)?"*":"";
        }
};

struct unary
{
        int n;
        unary(): n(0) {}

        unary(const int k): n(k) {}

        unary(const bool b): n(b?1:0) {}

        operator bool() const
        {
                return n>0;
        }

        operator int() const
        {
                return n;
        }
};

template<>
struct av_option<unary>
:public opt_base1<unary>
{
        av_option(const char sh,const std::string& lo,unary*const ptr)
        :opt_base1<unary>(sh,lo,ptr)
        {
                opt_base1<unary>::is_switch=true;
                opt_base1<unary>::multiple=true;
        }

        virtual void store_arg(const char*const sval,const bool clear_arg)
        {
                if(clear_arg) opt_base1<unary>::valueptr->n=0;
                if(sval==0) ++(opt_base1<unary>::valueptr->n);
                else shore::parse_value(&opt_base1<unary>::valueptr->n,sval);
        }

        virtual std::string argdefault_string() const
        {
                return ((opt_base1<unary>::valueptr->n)>0)?
                        std::string(opt_base1<unary>::valueptr->n,'*'):"";
        }
};

} // namespace shore

#endif // SHORE_PROGRAM_AV_PARSER_HPP__