---

Option.h

Go to the documentation of this file.

#ifndef OPTION_H_INCLUDED
#define OPTION_H_INCLUDED

#ifndef ERR_H
#include "Err.h"
#endif

#ifndef __LIST__
#include <list>
#endif

namespace rs {

    namespace cmdline {

        // --------------------------------------------------------------------------------
        //     class CmdLineHelpText
        // --------------------------------------------------------------------------------
        class CmdLineHelpText : rs_boost::noncopyable {
            std::string helptext; // helptext printed out by '-?'
        protected:
            CmdLineHelpText(const char *helptext_) {
                helptext = helptext_;
            }
            virtual ~CmdLineHelpText() {}
        public:
            virtual std::string get_helptext() const { return helptext; }
        };

        // --------------------------------------------------------------------------------
        //     class CmdLineOption
        // --------------------------------------------------------------------------------
        class CmdLineOption : public virtual CmdLineHelpText {
            bool used;          // was option given on command line or set via set()?
            char optChar;       // the option character ('c' for option '-c')
        public:
            CmdLineOption(char optChar_, const char *helptext_);
            virtual ~CmdLineOption();

            operator bool() const { return used; }

            virtual bool reallyUsed() const { return (bool)*this; }

            void set() { used = true; }

            virtual void clear() { used = false; }

            char get_optChar() const { return optChar; }

        protected:
            friend class ProgramInfo;
            virtual void print(std::ostream& out) const;
            virtual bool takes_argument() const { return false; }
        };

        // --------------------------------------------------------------------------------
        //     class CmdLineArgument
        // --------------------------------------------------------------------------------
        class CmdLineArgument : public virtual CmdLineHelpText {
            std::string name;   // name of argument (as referred in helptext_)
            std::string value;  // argument given on command line
            bool        has_default_value; // if argument has a default value
            bool        really_used; // if argument was given on command line

        public:
            CmdLineArgument(const char *name_, const char *helptext_, const char *value_=0, bool is_real_arg=true);
            virtual ~CmdLineArgument();

            bool value_is_set() const { return value.length()>0; }

            operator bool() const { return value_is_set(); }

            virtual bool reallyUsed() const { return really_used; }

            virtual std::string get() { return value; }

            virtual int getNumeric();

            virtual double getDouble();

            virtual void set(std::string value_, bool set_default_value=false) {
                value = value_;
                really_used = !set_default_value;
            }

            void clear() {
                if (value_is_set()) {
                    value = "";
                    has_default_value = false;
                    really_used = false;
                }
            }

            virtual std::string get_name() const { return std::string("<")+name+'>'; }

        protected:
            friend class ProgramInfo;

            bool has_default() const { return has_default_value; }
            void set_has_default() { if (value_is_set()) has_default_value = true; }

            virtual std::string get_helptext() const {
                if (!has_default()) return CmdLineHelpText::get_helptext();
                return CmdLineHelpText::get_helptext() + " [Default='" + value + "']";
            }
        };

        typedef bool (*CmdLineArgumentPredicate)(const std::string *arg);

        //  -----------------------------------------------------------------
        //      class RepeatableCmdLineArgument : public CmdLineArgument
        //  -----------------------------------------------------------------
        class RepeatableCmdLineArgument : public CmdLineArgument {
        private:
            int                      min_occur;
            int                      max_occur;
            std::list<std::string>   repeated_values;
            std::list<std::string>   seen_values;
            CmdLineArgumentPredicate isArg;
            int                      count; // arguments scanned

        protected:
            RepeatableCmdLineArgument(const char *name_, const char *helptext_, int min_occur_, int max_occur_, CmdLineArgumentPredicate isArg_, bool is_real_arg);
        public:
            virtual ~RepeatableCmdLineArgument() {}

            std::string get();

            virtual void set(std::string value_, bool set_default_value=false) {
                if (value_is_set()) repeated_values.push_back(value_);
                else CmdLineArgument::set(value_, set_default_value);
                ++count;
            }

            void reset();

            virtual std::string get_name() const;

        protected:
            friend class ProgramInfo;

            int get_min_occur() const { return min_occur; }
            int get_max_occur() const { return max_occur; }
            int get_count() const { return count; }
        };

        bool acceptAnyArgument(const std::string *arg);

        //  -------------------------------------------------------------------------
        //      class OptionalCmdLineArgument : public RepeatableCmdLineArgument
        //  -------------------------------------------------------------------------
        class OptionalCmdLineArgument : public RepeatableCmdLineArgument {
        public:
            OptionalCmdLineArgument(const char *name_, const char *helptext_, CmdLineArgumentPredicate isArg_ = acceptAnyArgument, int max_occur_=1)
                : RepeatableCmdLineArgument(name_, helptext_, 0, max_occur_, isArg_, true)
                , CmdLineHelpText(helptext_)
            {}
            virtual ~OptionalCmdLineArgument() {}
        };

        //  -------------------------------------------------------------------------
        //      class RepeatedCmdLineArgument : public RepeatableCmdLineArgument
        //  -------------------------------------------------------------------------
        class RepeatedCmdLineArgument : public RepeatableCmdLineArgument {
        public:
            RepeatedCmdLineArgument(const char *name_, const char *helptext_, CmdLineArgumentPredicate isArg_, int min_occur_=1, int max_occur_=-1)
                : RepeatableCmdLineArgument(name_, helptext_, min_occur_, max_occur_, isArg_, true)
                , CmdLineHelpText(helptext_)
            {}

            virtual ~RepeatedCmdLineArgument() {}
        };


        // --------------------------------------------------------------------------------
        //     class CmdLineArgumentOption : public CmdLineOption, public CmdLineArgument
        // --------------------------------------------------------------------------------
        class CmdLineArgumentOption : public CmdLineOption, public CmdLineArgument {
        public:
            CmdLineArgumentOption(char optChar_, const char *argname_, const char *helptext_, const char *value_=0);
            virtual ~CmdLineArgumentOption();

            virtual void set(std::string value_, bool set_default_value=false) {
                CmdLineOption::set();
                CmdLineArgument::set(value_, set_default_value); // set default argument
            }

            virtual void clear() {
                CmdLineOption::clear();
                CmdLineArgument::clear();
            }

            virtual bool reallyUsed() const { return CmdLineArgument::reallyUsed(); }

        protected:
            virtual void print(std::ostream& out) const;
            virtual bool takes_argument() const { return true; }
//             virtual string get_helptext() const { return CmdLineHelpText::get_helptext(); }
        };

        // ----------------------------------------------------------------------------------------------------
        //      class RepeatedCmdLineArgumentOption
        // ----------------------------------------------------------------------------------------------------
        class RepeatedCmdLineArgumentOption : public CmdLineOption, public RepeatableCmdLineArgument {
        private:
            char separator;

        public:
            RepeatedCmdLineArgumentOption(char optChar_, const char *argname_, char separator_, const char *helptext_, const char *value_=0);
            virtual ~RepeatedCmdLineArgumentOption() {}

            virtual void set(std::string value_, bool set_default_value=false);

            std::string get() { return RepeatableCmdLineArgument::get(); }

            virtual void clear() {
                CmdLineOption::clear();
                RepeatableCmdLineArgument::clear();
            }

            virtual std::string get_name() const;

            virtual bool reallyUsed() const { return CmdLineArgument::reallyUsed(); }

        protected:
            virtual void print(std::ostream& out) const;
            virtual bool takes_argument() const { return true; }
//             virtual string get_helptext() const { return CmdLineHelpText::get_helptext(); }
        };


        typedef CmdLineOption** CmdLineOptionArray;


        // --------------------------------------------------------------------------------
        //     class CmdLineAnnotation
        // --------------------------------------------------------------------------------
        class CmdLineAnnotation : public virtual CmdLineHelpText {
        private:
            int print_infrontof_option;
            bool spaced; // print empty lines above and below
        public:
            CmdLineAnnotation(const char *helptext_="", bool spaced_=false);
            virtual ~CmdLineAnnotation() {}

        protected:
            friend class ProgramInfo;
            int get_print_infrontof_option() const { return print_infrontof_option; }
            bool print_spaced() const { return spaced; }
        };


        // --------------------------------------------------------------------------------
        //     class ProgramInfo
        // --------------------------------------------------------------------------------
        class ProgramInfo : rs_boost::singleton<ProgramInfo> {
            std::string program_name;
            int         main_version;
            int         sub_version;
            std::string program_description;
            std::string creation_date;

            bool any_option_given;

            void setProgramPaths(const char *argv0);

            std::string program_path; // home directory of the program
            std::string call_path; // the directory the program was called from

        public:
            ProgramInfo(const char *program_name_, int main_version_, int sub_version_,
                        const char *program_description_, const char *creation_date_ = __DATE__);
            ~ProgramInfo() {}

            void init(int argc_, char* argv_[]); // do not change!

            void exclude(CmdLineOptionArray opt1, CmdLineOptionArray opt2);
            void exclude(CmdLineOption& opt1, CmdLineOptionArray opt2) {
                CmdLineOption *optList1[] = { &opt1, 0 };
                exclude(optList1, opt2);
            }
            void exclude(CmdLineOptionArray opt1, CmdLineOption& opt2) {
                CmdLineOption *optList2[] = { &opt2, 0 };
                exclude(opt1, optList2);
            }
            void exclude(CmdLineOption& opt1, CmdLineOption& opt2) {
                CmdLineOption *optList1[] = { &opt1, 0 };
                CmdLineOption *optList2[] = { &opt2, 0 };
                exclude(optList1, optList2);
            }


            void needOne(CmdLineOptionArray options);

            void neededBy(const CmdLineOption& drug, const CmdLineOption& addict);

            void infos(std::ostream& out) const;

            bool optionsSpecified() const { return any_option_given; }

            void throw_Error(const std::string& msg) const;

            const std::string& CallPath() const;

            const std::string& ProgramPath() const;
        };

    };
};

#else
#error Option.h included twice
#endif

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002