program.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_HPP__
#define SHORE_PROGRAM_HPP__

#include <algorithm>
#include <string>
#include <vector>

#include "shore/program/av_parser.hpp"

namespace shore {

class uncaught_handler;

class program
{
 public:

        typedef av_parser::usage_error usage_error;

        static std::string TMPDIR;
 
 private:

        friend class shore::uncaught_handler;

        std::string m_name;
        std::string m_title;
        std::string m_description;
        std::string m_usage_description;
        
        std::string m_conffile;
        bool m_conffileread;

        int m_status;

        av_parser m_optionparser;
        int m_ac;
        char **m_av;

        shore::uncaught_handler *m_uncaught_handler;

        std::string m_commandline;

        bool m_allow_mpi;

        bool m_showexthelp;
        bool m_showusagedesc;
        std::string m_helpcmd;


        void run();

        program(const program&);

 protected:

        void allow_mpi();

        virtual int main()=0;

        virtual void sanity_check() {}

        virtual void basic_sanity_check();

 public:

        program();

        virtual ~program()
        {}

        program &operator()(int ac,char** av);

        program &operator()(
          const std::string &command,const std::vector<std::string> &args);

        int status() const;

        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())
        {
                m_optionparser.add_option(longshort,conflicts_with,target,info,def,aux_info);
        }

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

        template<typename T>
        void add_residualargs(
          T *const target,
          const std::string &name="FILES",
          const std::string &conflicts_with=std::string(),
          const OptionFlags def=shore::OPT_NOTSET,
          typename boost::disable_if<boost::is_const<T> >::type *dummy=0)
        {
                m_optionparser.add_residualargs(target,name,conflicts_with,def);
        }

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

        void set_configfile(const std::string &fn);

        void set_optiongroup(const std::string &g=std::string());

        void set_description(const std::string &desc);

        virtual const std::string& get_description() const;

        void set_usage_description(const std::string &desc);
        void set_title(const std::string &t);

        void set_programname(const std::string& name);

        const std::string& get_programname() const;

        void set_helpcmd(const std::string& cmd);

        bool is_altered(const void*const ptr) const;

        size_t num_altered() const;

        const std::string& get_commandline() const;
        
        av_parser& get_optionparser();
        
        shore::uncaught_handler *get_uncaught_handler();

        const av_parser& get_optionparser() const;

        void set_show_extended_help(const bool f);
        void set_show_usage_description(const bool f);

        virtual void show_usage() const;

        std::string startup_message() const;
        std::string shutdown_message() const;
};

} // namespace shore

#endif // SHORE_PROGRAM_HPP__

// vim: sw=4:softtabstop=4:expandtab