126 lines
3.7 KiB
C
126 lines
3.7 KiB
C
|
// Copyright (C) 2001 Claus Dr<44>by
|
|||
|
|
// Terms of use are in the file COPYING
|
|||
|
|
#ifndef __UNITPP__OPTMAP_H
|
|||
|
|
#define __UNITPP__OPTMAP_H
|
|||
|
|
#include <string>
|
|||
|
|
#include <map>
|
|||
|
|
#include <vector>
|
|||
|
|
#include <stdexcept>
|
|||
|
|
/**
|
|||
|
|
* The home of \Ref{optmap}. This is a unified way of handling commang line
|
|||
|
|
* arguments, and suitable usage replies when things goes badly.
|
|||
|
|
*/
|
|||
|
|
namespace options_utils {
|
|||
|
|
/**
|
|||
|
|
* A argument option handler, based on the Command pattern. Each option is
|
|||
|
|
* associated with a handling command object.
|
|||
|
|
*
|
|||
|
|
* The map keeps the reverse association as well, to allow printing of a
|
|||
|
|
* using line.
|
|||
|
|
*/
|
|||
|
|
class optmap {
|
|||
|
|
public:
|
|||
|
|
/**
|
|||
|
|
* The base for all option handlers.
|
|||
|
|
*
|
|||
|
|
* To handle a new kind of commands, just derive a class from this an
|
|||
|
|
* overload the methods to do the work.
|
|||
|
|
*/
|
|||
|
|
struct cmd {
|
|||
|
|
/**
|
|||
|
|
* Performing the work associated with the option.
|
|||
|
|
*
|
|||
|
|
* To obtain an argument see \Ref{get_arg}
|
|||
|
|
* @return true if the parsing was succesfull
|
|||
|
|
*/
|
|||
|
|
virtual bool do_cmd(optmap* om) = 0;
|
|||
|
|
/// return the name of the argument needed by \Ref{usage}
|
|||
|
|
virtual std::string arg() { return std::string(); }
|
|||
|
|
virtual ~cmd() {}
|
|||
|
|
};
|
|||
|
|
/**
|
|||
|
|
* The very simple constructor for an optmap object. Please note that
|
|||
|
|
* copying of optmaps are not supported.
|
|||
|
|
* @param usage The tail of the usage string to follow the options
|
|||
|
|
*/
|
|||
|
|
optmap(const char* usage = "");
|
|||
|
|
~optmap();
|
|||
|
|
/**
|
|||
|
|
* Adds an option that invokes the command handler.
|
|||
|
|
*
|
|||
|
|
* This is the low level work horse for all the add methods. All the
|
|||
|
|
* other adds works by adding appropriate cmd objects for doing the work.
|
|||
|
|
*
|
|||
|
|
* @param o
|
|||
|
|
* The option name. If the length of the option is 1 it will be an old
|
|||
|
|
* fashion option, otherwise it will be a GNU stype long option
|
|||
|
|
* (--long-opt).
|
|||
|
|
* @param h
|
|||
|
|
* The pointer to the handler. The optmap assumes ownership of the
|
|||
|
|
* pointer and delete it in the destructor.
|
|||
|
|
*
|
|||
|
|
* @return *this
|
|||
|
|
*/
|
|||
|
|
optmap& add(const char* o, cmd* h);
|
|||
|
|
/// Adds an alias for an option.
|
|||
|
|
optmap& alias(const char* new_opt, const char* old_opt);
|
|||
|
|
/**
|
|||
|
|
* Parse the command line.
|
|||
|
|
* @return true if the parse is valid, false otherwise.
|
|||
|
|
*/
|
|||
|
|
bool parse(int argc, const char** argv);
|
|||
|
|
/// Gets the index for the first non option argument
|
|||
|
|
int n() { return i; }
|
|||
|
|
/// display a usage string and abort()
|
|||
|
|
void usage(bool abort = true);
|
|||
|
|
/// get the argument of an option; mainly for cmd implementations.
|
|||
|
|
const char* get_arg();
|
|||
|
|
private:
|
|||
|
|
int i;
|
|||
|
|
const char* prog;
|
|||
|
|
int argc;
|
|||
|
|
const char** argv;
|
|||
|
|
bool multichar; // doing a multichar, -pdf --> -p -d -f
|
|||
|
|
bool first_multi;
|
|||
|
|
optmap(const optmap& o);
|
|||
|
|
optmap& operator=(const optmap&);
|
|||
|
|
bool do_cmd(const std::string& opt);
|
|||
|
|
std::string tail;
|
|||
|
|
typedef std::map<std::string, cmd*> cmds_t;
|
|||
|
|
cmds_t cmds;
|
|||
|
|
typedef std::vector<cmd*> gvec_t;
|
|||
|
|
gvec_t gvec;
|
|||
|
|
typedef std::map<cmd*, std::vector<std::string> > group_t;
|
|||
|
|
group_t group;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/// A cmd handler that can set a boolean flag.
|
|||
|
|
class opt_flag : public optmap::cmd {
|
|||
|
|
bool& flg;
|
|||
|
|
public:
|
|||
|
|
/// Just give it the bool you want set if the flag is present.
|
|||
|
|
opt_flag(bool& flg) : flg(flg) {}
|
|||
|
|
virtual bool do_cmd(optmap*) { flg = true; return true; }
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/// A cmd handler that can get an integer value.
|
|||
|
|
class opt_int : public optmap::cmd {
|
|||
|
|
int& val;
|
|||
|
|
public:
|
|||
|
|
/// just give it an int variable that the flag argument can be assigned to.
|
|||
|
|
opt_int(int& val) : val(val) {}
|
|||
|
|
virtual bool do_cmd(optmap* om);
|
|||
|
|
virtual std::string arg() { return std::string("<int>"); }
|
|||
|
|
};
|
|||
|
|
/// A cmd handler for a string
|
|||
|
|
class opt_string : public optmap::cmd {
|
|||
|
|
std::string& val;
|
|||
|
|
public:
|
|||
|
|
/// Give it a string that the flag arg should be assigned to.
|
|||
|
|
opt_string(std::string& val) : val(val) {}
|
|||
|
|
virtual bool do_cmd(optmap* om);
|
|||
|
|
virtual std::string arg() { return std::string("<string>"); }
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
#endif
|