main page namespaces classes files
BIU home

src/biu/OptionParser.hh

Go to the documentation of this file.

// OptionParser.h: Schnittstelle für die Klasse COptionParser.
/*

    <author>    Martin Mann                 </author>
    <created>   9.10.2005                   </created>

    <info>                                  </info>
*/
//

#if !defined(IT_OPTIONPARSER_H__INCLUDED)
#define IT_OPTIONPARSER_H__INCLUDED

#include <vector>
#include <string>
#include <sstream>

#include "biu/HashMap.hh"


namespace biu {

class COption {

public:

    static std::string DEF_INIT;

    std::string option;         
    bool optional;              
    int retType;                
    std::string description;    
    std::string strValue;       
    std::string defValue;       
    bool exist;                 

    enum TYPES { STRING, CHAR, INT, FLOAT, DOUBLE, BOOL , TYPES_SIZE};
    
    static std::vector<std::string> initTypeNames() {
        std::vector<std::string> ret = std::vector<std::string>(TYPES_SIZE, "TYPE");

        ret[STRING] = "str ";
        ret[CHAR]   = "char";
        ret[INT]    = "int ";
        ret[FLOAT]  = "flt ";
        ret[DOUBLE] = "dbl ";
        ret[BOOL]   = "bool";

        return ret;
    }
    static std::vector<std::string> TYPE_NAME;

    COption (std::string _option, bool _optional, int _retType, std::string _description, std::string _defaultValue=DEF_INIT) :
        option(_option),
        optional(_optional),
        retType(_retType),
        description(_description),
        strValue(_defaultValue),
        defValue(_defaultValue),
        exist(false)
        {}

    ~COption() {}
};


// TYPEDEFS

typedef std::vector<COption> OptionMap;
typedef OptionMap::const_iterator OptionMapIt;

class COptionParser {
    
private:

#ifdef HAVE_GNU_HASH_MAP

    struct hash_string {
        size_t operator()(const std::string& str) const
        {
            size_t hash = 5381;

            for (size_t i = 0; i < str.size(); i++) {
                hash = ((hash << 5) + hash) + (size_t)str[i]; // hash * 33 + str[i]
            }

            return hash;
        }
             
    };

    typedef __gnu_cxx::hash_map< std::string, int, hash_string > STR2INT_MAP;
#else
    typedef std::map< std::string, int > STR2INT_MAP;
#endif

    OptionMap opt;              
    std::string programName;    
    std::string infoText;       

    bool errorOccured;          
    unsigned int maxOName;
    STR2INT_MAP mopt;   

    enum ERRORS { ERR_NO_OPT, ERR_WR_USE, ERR_WR_VAL, ERR_NO_ARG };

    void coutError(int error, std::string optionName, std::string errormsg);

    bool isCastable(std::string val, int type) const;

    void parseOpt(int argc, char** argv);

    void coutLineBreaking(std::string text, std::ostream &os,const int emptyHeadSize,const int lineLength) const;

public:

    static int OUTPUT_LINE_LENGTH;

    COptionParser(OptionMap _options, int argc, char** argv, std::string infoText);

    bool noErrors();

    void coutUsage() const;

    bool argExist(std::string option);

    // Parse-Funktionen

    std::string getStrVal(std::string arg);
    char    getCharVal(std::string arg);
    int     getIntVal(std::string arg);
    float   getFloatVal(std::string arg);
    double  getDoubleVal(std::string arg);
    bool    getBoolVal(std::string arg);

};

} // namespace biu


#endif // !defined(IT_OPTIONPARSER_H__INCLUDED)

/*  Beispiel

int main(int argc, char ** argv) {

    OptionMap allowedArgs;
    allowedArgs.push_back(COption("text", false, COption::STRING, "input sequence file with given degeneration"));
    allowedArgs.push_back(COption("max", false, COption::INT, "maximal degeneration that is used"));
    ...

    COptionParser opts = COptionParser(allowedArgs, argc, argv, "infotext");

    if (opts.noErrors()) {
        std::string text = opts.getStrVal("text");

        ...

        return 0;

    } else {

        ...

        return -1;
    }
}

*/