OptionParser.h

Go to the documentation of this file.

//
//      $Id$
//
//************************************************************************
//                              *
//           Copyright (C)  2004            *
//     University Corporation for Atmospheric Research      *
//           All Rights Reserved            *
//                              *
//************************************************************************/
//
//  File:
//
//  Author:     John Clyne
//          National Center for Atmospheric Research
//          PO 3000, Boulder, Colorado
//
//  Date:       Wed Oct  6 10:49:44 MDT 2004
//
//  Description:    A class for parsing command line options.  This
//                  class  manages a resource data base of valid command line
//                  options. Valid options may be merged into the data base
//                  at any time and later extracted with their
//                  coresponding values as determined by the command line.
//
//
 
#ifndef _OptionParser_h_
#define _OptionParser_h_
 
#include <string>
#include <cmath>
#include <vector>
#include <vapor/MyBase.h>
#include <vapor/common.h>
 
#ifdef WIN32
    // Silence an annoying and unnecessary compiler warning
    #pragma warning(disable : 4251)
#endif
using namespace std;
 
namespace Wasp {
 
//
//
class COMMON_API OptionParser : public MyBase {
public:
    //
    //
    typedef struct _OptDescRec {
        const char *option;
        int         arg_count;
        const char *value;
        const char *help;
    } OptDescRec_T;
 
    //
    //  structure for returning the value of an option
    //
    typedef struct _DPOption {
        const char *option_name;    // the options name
 
        //
        // option type converter
        //
        int (*type_conv)(const char *from, void *to);
 
        void *offset;    // offset of return address
        int   size;      // size of option in bytes
    } Option_T;
 
    typedef struct _EnvOpt {
        const char *option;     // option name
        const char *env_var;    // coresponding enviroment var
    } EnvOpt_T;
 
    typedef int Boolean_T;
    typedef struct Dimension2D_ {
        int nx, ny;
    } Dimension2D_T;
 
    typedef struct Dimension3D_ {
        int nx, ny, nz;
    } Dimension3D_T;
 
    // Converter type for CvtToIntRange()
    //
    typedef struct IntRange_ {
        int min, max;
    } IntRange_T;
 
    OptionParser();
    ~OptionParser();
 
    //
    //
    int AppendOptions(const OptDescRec_T *odr);
 
    //
    int  ParseOptions(int *argc, char **argv, Option_T *opts);
    int  ParseOptions(const EnvOpt_T *envv, Option_T *opts);
    void RemoveOptions(std::vector<string> options);
    void PrintOptionHelp(FILE *fp, int linelimit = 80, bool docopyright = true);
 
    typedef struct _OptRec {
        const char *option;           // name of option without preceeding '-'
        const char *value;            // current val for the argument
        const char *default_value;    // default val for the argument
        const char *help;             // help string for option
        int         arg_count;        // num args expected by option
    } _OptRec_T;
 
private:
    vector<struct _OptRec *> _optTbl;
 
    _OptRec_T *_get_option(const char *name);
    int        _parse_options(const Option_T *opts);
 
    friend bool opt_cmp(OptionParser::_OptRec_T *a, OptionParser::_OptRec_T *b);
};
 
COMMON_API int CvtToInt(const char *from, void *to);
 
COMMON_API int CvtToFloat(const char *from, void *to);
 
COMMON_API int CvtToDouble(const char *from, void *to);
 
COMMON_API int CvtToChar(const char *from, void *to);
 
COMMON_API int CvtToBoolean(const char *from, void *to);
 
COMMON_API int CvtToString(const char *from, void *to);
 
COMMON_API int CvtToCPPStr(const char *from, void *to);
 
COMMON_API int CvtToDimension2D(const char *from, void *to);
 
COMMON_API int CvtToDimension3D(const char *from, void *to);
 
// convert a colon delimited ascii string to vector of C++
// STL strings: (vector <string> *)
//
COMMON_API int CvtToStrVec(const char *from, void *to);
 
// convert a colon delimited ascii string to vector of C++
// STL ints: (vector <int> *)
//
COMMON_API int CvtToIntVec(const char *from, void *to);
 
// convert a colon delimited ascii string to vector of C++
// STL size_t: (vector <size_t> *)
//
COMMON_API int CvtToSize_tVec(const char *from, void *to);
 
// convert a colon delimited ascii string to vector of C++
// STL ints: (vector <float> *)
//
COMMON_API int CvtToFloatVec(const char *from, void *to);
 
COMMON_API int CvtToDoubleVec(const char *from, void *to);
 
// Convert a colon-delimited pair of integers to a IntRange_T type
//
COMMON_API int CvtToIntRange(const char *from, void *to);
 
};    // namespace Wasp
 
#endif