cmdlineparser.hh

Go to the documentation of this file.

/* -*- mia-c++  -*-
 *
 * This file is part of MIA - a toolbox for medical image analysis 
 * Copyright (c) Leipzig, Madrid 1999-2017 Gert Wollny
 *
 * MIA 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.
 *
 * This program 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 MIA; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef mia_core_cmdlineparser_hh
#define mia_core_cmdlineparser_hh

//#include <miaconfig.h>
#include <vector>
#include <map>
#include <memory>
#include <sstream>
#include <iostream>
#include <string>
#include <iterator>
#include <mia/core/cmdparamoption.hh>
#include <mia/core/dictmap.hh>
#include <mia/core/flagstring.hh>
#include <mia/core/handlerbase.hh>
#include <mia/core/selftestcmdoption.hh>

NS_MIA_BEGIN

extern EXPORT_CORE const char *g_help_optiongroup; 

typedef std::map<std::string, std::string> CHistoryRecord;

typedef std::pair<std::string, CHistoryRecord> CHistoryEntry;

enum EProgramDescriptionEntry {
        pdi_group = 0, /*<! The group the program belongs to, in the help the program will be described in this section */ 
        pdi_short = 1,  /*<! A sgort description of the program, this will be the head line in the unix man page. */
        pdi_description = 2, /*<! The full description of the program */ 
        pdi_example_descr = 3, /*<! description of the example that follows */
        pdi_example_code = 4,   /*<! The example command line without the program name */
        pdi_author = 5 /*<! Author name (if other than main MIA contributer(s) */
}; 

extern const std::map<EProgramDescriptionEntry, const char *> g_DescriptionEntryNames; 

typedef std::map<EProgramDescriptionEntry, const char *>  SProgramDescription; 




class CCmdFlagOption: public  CCmdOption{

public:
        CCmdFlagOption(int& val, const CFlagString& map, char short_opt, const char *long_opt,
                       const char *long_help, const char *short_help, 
                       CCmdOptionFlags flags  = CCmdOptionFlags::none);
private:
        virtual bool do_set_value(const char *str_value);
        virtual size_t do_get_needed_args() const;
        virtual void do_write_value(std::ostream& os) const;
        virtual void do_get_long_help(std::ostream& os) const;
        virtual const std::string do_get_value_as_string() const;
        int& m_value;
        const CFlagString m_map;
};


class EXPORT_CORE CCmdOptionList {
public:

        enum EHelpRequested {
                hr_no = 0,    
                hr_help,      
                hr_help_xml,  
                hr_usage,     
                hr_version,   
                hr_copyright, 
                hr_selftest   
        };

        CCmdOptionList(const SProgramDescription& description); 

        ~CCmdOptionList();

        void add(PCmdOption opt);

        void add(const std::string& group, PCmdOption opt);

        void add_selftest(int& test_result, CSelftestCallback *callback);

        EHelpRequested parse(size_t argc, char *args[], const std::string& additional_type, 
                const CPluginHandlerBase *additional_help = NULL) 
                __attribute__((warn_unused_result));

        EHelpRequested parse(size_t argc, const char *args[], const std::string& additional_type, 
                             const CPluginHandlerBase *additional_help = NULL) 
                __attribute__((warn_unused_result));

        EHelpRequested parse(size_t argc, char *args[]) __attribute__((warn_unused_result));
        
        EHelpRequested parse(size_t argc, const char *args[]) __attribute__((warn_unused_result));
        
        const std::vector<std::string>& get_remaining() const;

        CHistoryRecord get_values() const;

        void set_group(const std::string& group); 
        
        void set_logstream(std::ostream& os); 


        void set_stdout_is_result(); 
private:
        EHelpRequested do_parse(size_t argc, const char *args[], bool has_additional, 
                                const CPluginHandlerBase *additional_help) 
                __attribute__((warn_unused_result));
        int handle_shortargs(const char *arg, size_t argc, const char *args[]);
        struct CCmdOptionListData *m_impl;
};


// implementation of template classes and functions


template <typename T>
PCmdOption make_opt(T& value, const char *long_opt, char short_opt, 
                    const char *help, CCmdOptionFlags flags = CCmdOptionFlags::none)
{
        bool required = has_flag(flags, CCmdOptionFlags::required); 
        return PCmdOption(new CParamOption( short_opt, long_opt, new CTParameter<T>(value, required, help))); 
}

template <typename T>
PCmdOption make_opt(T& value, EParameterBounds bflags, const std::vector<T>& bounds, 
                    const char *long_opt, char short_opt, 
                    const char *help, CCmdOptionFlags flags = CCmdOptionFlags::none)
{
        bool required = has_flag(flags, CCmdOptionFlags::required); 
        return PCmdOption(new CParamOption( short_opt, long_opt, 
                                            new TBoundedParameter<T>(value, bflags, bounds, required, help)));
}

PCmdOption make_opt(bool& value, const char *long_opt, char short_opt, const char *help, 
                    CCmdOptionFlags flags = CCmdOptionFlags::none); 

template <typename T>
PCmdOption make_opt(T& value, const TDictMap<T>& map, 
                    const char *long_opt, char short_opt, const char *help)
{
        return PCmdOption(new CParamOption( short_opt, long_opt, 
                                            new CDictParameter<T>(value, map, help)));
}


PCmdOption   make_opt(int& value, const CFlagString& map, const char *long_opt,
                                 char short_opt, const char *long_help, 
                                 const char *short_help, 
                                 CCmdOptionFlags flags = CCmdOptionFlags::none);


PCmdOption  make_opt(std::string& value, const char *long_opt, char short_opt, const char *long_help, 
                     CCmdOptionFlags flags = CCmdOptionFlags::none, const CPluginHandlerBase *plugin_hint = NULL); 



template <typename T> 
PCmdOption  make_opt(T& value, const std::set<T>& valid_set,
                     const char *long_opt, char short_opt, 
                     const char *help, 
                     CCmdOptionFlags flags = CCmdOptionFlags::none)
{
        bool required = has_flag(flags, CCmdOptionFlags::required);
        return PCmdOption(new CParamOption( short_opt, long_opt, 
                                            new  CSetParameter<T>(value, valid_set, help, required))); 
}


template <typename T>
PCmdOption make_opt(typename std::shared_ptr<T>& value, const char *default_value, const char *long_opt, 
                    char short_opt,  const char *help,  
                    CCmdOptionFlags flags = CCmdOptionFlags::none)
{
        bool required = has_flag(flags, CCmdOptionFlags::required);
        typedef typename FactoryTrait<T>::type F;  
        return PCmdOption(new CParamOption( short_opt, long_opt, 
                                            new TFactoryParameter<F>(value, default_value, required, help))); 
}

template <typename T>
PCmdOption make_opt(typename std::unique_ptr<T>& value, const char *default_value, const char *long_opt, 
                    char short_opt,  const char *help, CCmdOptionFlags flags = CCmdOptionFlags::none)
{
        bool required = has_flag(flags, CCmdOptionFlags::required);
        typedef typename FactoryTrait<T>::type F;  
        return PCmdOption(new CParamOption( short_opt, long_opt, 
                                            new TFactoryParameter<F>(value, default_value, required, help))); 
}


NS_MIA_END

#endif