Marc Wäckerlin
21 years ago
parent
93696ef645
commit
eb6daf08ba
13 changed files with 1104 additions and 42 deletions
@ -0,0 +1,686 @@ |
|||||||
|
#include <mrw/exception.hpp> |
||||||
|
#include <mrw/stacktrace.hpp> |
||||||
|
#include <mrw/smartpointer.hpp> |
||||||
|
#include <mrw/simpletrace.hpp> |
||||||
|
#include <stdlib.h> // exit |
||||||
|
#include <string> |
||||||
|
#include <vector> |
||||||
|
#include <set> |
||||||
|
#include <list> |
||||||
|
#include <exception> |
||||||
|
#include <stdexcept> |
||||||
|
#include <sstream> |
||||||
|
#include <iostream> |
||||||
|
|
||||||
|
namespace mrw { |
||||||
|
|
||||||
|
/** @defgroup arguments C++ Evaluation of Command Line Arguments
|
||||||
|
|
||||||
|
@brief These classes do simple and easy command line argment evaluation |
||||||
|
in C++. |
||||||
|
|
||||||
|
Features: |
||||||
|
- every argument has a long and a short option |
||||||
|
- all arguments are optional and provide a default value |
||||||
|
- the order of options is not important |
||||||
|
- every option can take any (fixed) number of additional parameter of |
||||||
|
type |
||||||
|
- string |
||||||
|
- integer |
||||||
|
- boolean (@c "yes", @c "on", @c "true" evaluates to @c true) |
||||||
|
- short options can be combined, instead of |
||||||
|
@c -a @c -b @c -c @c 15 you can simply write @c -abc @c 15 |
||||||
|
- automated help display (support for option @c -h) |
||||||
|
|
||||||
|
@c mrw::Args is the main user interface class that represents |
||||||
|
all command line options with their arguments. It is implemented |
||||||
|
as singleton, so the same instance can be accessed from |
||||||
|
everywhere in the code. It mst be setup just in the beginning of |
||||||
|
the @c main() function. |
||||||
|
|
||||||
|
The other important class for the end user is @c mrw::Opt, one |
||||||
|
possible option with additional parameter. The end user needs @c |
||||||
|
mrw::Opt to setup all allowed command line options in the |
||||||
|
beginning, bevore evaluation of the user given command line is |
||||||
|
done (before @c argc and @c argv is shifted into @c mrw::Args. |
||||||
|
|
||||||
|
The third class a user should know is @c mrw::Param. It |
||||||
|
represents the arguments to one option. Every instance of @c |
||||||
|
mrw::Opt owns one instance of @c mrw::Param that is either empty |
||||||
|
or list of (mandatory) arguments of type @c std::string, @c int |
||||||
|
or @c bool. |
||||||
|
|
||||||
|
The classes are normally used this way: |
||||||
|
|
||||||
|
@code |
||||||
|
// this program may be called e.g. with the following arguments:
|
||||||
|
// ./a.out --coordinates 13 1 -vo out.txt -n MyName
|
||||||
|
int main(int argv, const char * const * const argv) { |
||||||
|
try { |
||||||
|
mrw::Args::instance() |
||||||
|
// setup the possible options
|
||||||
|
<<mrw::Opt('h', "--help", "Show this help text") |
||||||
|
<<mrw::Opt('v', "--verbose", "print more information") |
||||||
|
<<mrw::Opt('q', "--quiet", "be quiet") |
||||||
|
<<mrw::Opt('n', "--name", mrw::Param()<<"MRW", "name of the user") |
||||||
|
<<mrw::Opt('o', "--output-file", mrw::Param()<<"", "file to load") |
||||||
|
<<mrw::Opt('c', "--coordinates", mrw::Param()<<0<<0, "X, Y coordinate") |
||||||
|
// set a description text for help
|
||||||
|
<<"This is a testprogram for argument evaluation in C++" |
||||||
|
// define the help option
|
||||||
|
<<'h' |
||||||
|
// shift in the command line arguments
|
||||||
|
<<argc<<argv; |
||||||
|
... |
||||||
|
// example usage of simple option
|
||||||
|
if (mrw::Args::instance().find('v')) // be verbose here
|
||||||
|
... |
||||||
|
// example usage of option with (one) parameter
|
||||||
|
ifstream file(mrw::Args::instance().find('o').toString().c_str()); |
||||||
|
... |
||||||
|
return 0 |
||||||
|
} |
||||||
|
} catch (mrw::exception& x) { |
||||||
|
// trace error, print help or mention option -h
|
||||||
|
} |
||||||
|
} |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
//@{
|
||||||
|
|
||||||
|
/** @brief List of additional (mandatory) parameter to one command
|
||||||
|
line argument. |
||||||
|
@pre #include<mrw/arg.hpp> |
||||||
|
|
||||||
|
A new mandatory parameter is added to the list of parameter, by |
||||||
|
shifting the default value into the instance of @c |
||||||
|
mrw::Param. E.g. add a string, that defaults to @c "noname", an |
||||||
|
integer, that defaults to @c 4, another integer that defaults to |
||||||
|
@2 and a boolean that defaults to @c "true": |
||||||
|
|
||||||
|
@code |
||||||
|
// if you need the instance as variable:
|
||||||
|
mrw::Param p(); |
||||||
|
p<<"noname"<<4<<2<<true; |
||||||
|
// or in an expression:
|
||||||
|
mrw::Opt o('e', "--example", mrw::Param()<<"noname"<<4<<2<<true, ""); |
||||||
|
@endcode |
||||||
|
|
||||||
|
To access a value at a given position, simply use @c |
||||||
|
operator[]. Then use @c mrw::Value::toString, @c |
||||||
|
mrw::Value::toInt or @c mrw::Value::toBool to get the value of |
||||||
|
that parameter. Of course yo must know the correct type of a |
||||||
|
parameter at a given position, but since you are the programmer |
||||||
|
you know it, or you can get it by running your program with the |
||||||
|
help option, mostly @c -h. To retrieve the parameters setup in |
||||||
|
the example above (connected to option @c -e or @c --example), |
||||||
|
either the default value, or the value overwritten by the user, |
||||||
|
simply type: |
||||||
|
|
||||||
|
@code |
||||||
|
mrw::Args& args = mrw::Args::instance(); |
||||||
|
std::string theString = args[0]->toString(); |
||||||
|
int firstInteger = args[1]->toInt(); |
||||||
|
int secondInteger = args[2]->toInt(); |
||||||
|
bool theBoolean = args[3]->toBool(); |
||||||
|
@endcode |
||||||
|
|
||||||
|
@section argParts Setup Command Line from Different Program Parts |
||||||
|
|
||||||
|
If your software is large and splitted into different parts (or |
||||||
|
sub projects or modules, ...), all with their own parameter, you |
||||||
|
can use the following trick: Statical variables are initialized |
||||||
|
before the @c main() function is called. |
||||||
|
|
||||||
|
In part Abc write in a code file (not in a header file): |
||||||
|
|
||||||
|
@code |
||||||
|
class AbcArguments { |
||||||
|
public: |
||||||
|
AbcArguments() { |
||||||
|
mrw::Args::instance() |
||||||
|
<<mrw::Opt('n', "--name", mrw::Param()<<"MRW", "name of the user") |
||||||
|
<<mrw::Opt('o', "--output-file", mrw::Param()<<"", "file to load") |
||||||
|
<<mrw::Opt('c', "--coordinates", mrw::Param()<<0<<0, |
||||||
|
"X, Y coordinate") |
||||||
|
<<"Description text for part Abc, will be added to the\n" |
||||||
|
"overall documentation"; |
||||||
|
} |
||||||
|
}; |
||||||
|
static AbcArgument abcArgumentInitializer; |
||||||
|
@endcode |
||||||
|
|
||||||
|
Do the same for all other parts Then the @c main() function reduces to: |
||||||
|
|
||||||
|
@code |
||||||
|
int main(int argc, const char * const * const argv) { |
||||||
|
// set the help and evaluate the user given arguments
|
||||||
|
mrw::Args::instance() |
||||||
|
<<mrw::Opt('h', "--help", "Show this help text") |
||||||
|
<<'h'<<argc<<argv; |
||||||
|
... |
||||||
|
} |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
class Param { |
||||||
|
|
||||||
|
public: |
||||||
|
|
||||||
|
/** @brief Abstract base class to represent one single parameter value.
|
||||||
|
@pre #include<mrw/arg.hpp> |
||||||
|
*/ |
||||||
|
class Value { |
||||||
|
|
||||||
|
public: |
||||||
|
|
||||||
|
virtual ~Value() {} |
||||||
|
|
||||||
|
/** @brief If the instance is a @c std::string, return that
|
||||||
|
string, otherwise throw an exception. |
||||||
|
@throw mrw::bad_cast if the instance is not a string |
||||||
|
@return the string, if the instance is a string |
||||||
|
*/ |
||||||
|
virtual const std::string& toString() const throw(mrw::exception) { |
||||||
|
throw mrw::bad_cast(); |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief If the instance is an @c int, return that integer,
|
||||||
|
otherwise throw an exception. |
||||||
|
@throw mrw::bad_cast if the instance is not a integer |
||||||
|
@return the integer, if the instance is a integer |
||||||
|
*/ |
||||||
|
virtual int toInt() const throw(mrw::exception) { |
||||||
|
throw mrw::bad_cast(); |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief If the instance is an @c bool, return that boolean,
|
||||||
|
otherwise throw an exception. |
||||||
|
@note the following typings are converted to @c true: |
||||||
|
- true |
||||||
|
- yes |
||||||
|
- on |
||||||
|
Everything else is converted to @c false. |
||||||
|
@throw mrw::bad_cast if the instance is not a boolean |
||||||
|
@return the boolean, if the instance is a boolean |
||||||
|
*/ |
||||||
|
virtual bool toBool() const throw(mrw::exception) { |
||||||
|
throw mrw::bad_cast(); |
||||||
|
} |
||||||
|
|
||||||
|
/// @brief returns a printable representation of the value
|
||||||
|
virtual std::string printable() const throw(mrw::bad_exception) = 0; |
||||||
|
|
||||||
|
/// @brief returns a printable typename of the value
|
||||||
|
virtual const std::string& typestr() const throw(mrw::bad_exception)=0; |
||||||
|
|
||||||
|
protected: |
||||||
|
friend class Args; // allow assign for Param
|
||||||
|
virtual void operator=(const std::string&) throw(mrw::exception) = 0; |
||||||
|
}; |
||||||
|
|
||||||
|
private: |
||||||
|
|
||||||
|
class StringValue: public Value { |
||||||
|
public: |
||||||
|
virtual ~StringValue() {} |
||||||
|
StringValue(const std::string& s) throw(mrw::bad_exception): _s(s) { |
||||||
|
} |
||||||
|
virtual const std::string& toString() const throw(mrw::exception) { |
||||||
|
return _s; |
||||||
|
} |
||||||
|
virtual const std::string& typestr() const throw(mrw::bad_exception) { |
||||||
|
static std::string name("string"); |
||||||
|
return name; |
||||||
|
} |
||||||
|
virtual std::string printable() const throw(mrw::bad_exception) { |
||||||
|
return _s; |
||||||
|
} |
||||||
|
protected: |
||||||
|
virtual void operator=(const std::string& s) throw(mrw::exception) { |
||||||
|
_s = s; |
||||||
|
} |
||||||
|
private: |
||||||
|
std::string _s; |
||||||
|
}; |
||||||
|
|
||||||
|
class IntValue: public Value { |
||||||
|
public: |
||||||
|
virtual ~IntValue() {} |
||||||
|
IntValue(int i) throw(mrw::bad_exception): _i(i) { |
||||||
|
} |
||||||
|
virtual int toInt() const throw(mrw::exception) { |
||||||
|
return _i; |
||||||
|
} |
||||||
|
virtual const std::string& typestr() const throw(mrw::bad_exception) { |
||||||
|
static std::string name("integer"); |
||||||
|
return name; |
||||||
|
} |
||||||
|
virtual std::string printable() const throw(mrw::bad_exception) { |
||||||
|
return ((std::stringstream&)(std::stringstream()<<_i)).str(); |
||||||
|
} |
||||||
|
protected: |
||||||
|
virtual void operator=(const std::string& s) throw(mrw::exception) { |
||||||
|
if (!(std::stringstream(s)>>_i)) throw mrw::bad_cast(); |
||||||
|
} |
||||||
|
private: |
||||||
|
int _i; |
||||||
|
}; |
||||||
|
|
||||||
|
class BoolValue: public Value { |
||||||
|
public: |
||||||
|
virtual ~BoolValue() {} |
||||||
|
BoolValue(bool b) throw(mrw::bad_exception): _b(b) { |
||||||
|
} |
||||||
|
virtual bool toBool() const throw(mrw::exception) { |
||||||
|
return _b; |
||||||
|
} |
||||||
|
virtual const std::string& typestr() const throw(mrw::bad_exception) { |
||||||
|
static std::string name("boolean (\"yes\" or \"no\")"); |
||||||
|
return name; |
||||||
|
} |
||||||
|
virtual std::string printable() const throw(mrw::bad_exception) { |
||||||
|
return _b?"yes":"no"; |
||||||
|
} |
||||||
|
protected: |
||||||
|
virtual void operator=(const std::string& s) throw(mrw::exception) { |
||||||
|
_b = s=="true" || s=="yes" || s=="on"; |
||||||
|
} |
||||||
|
private: |
||||||
|
bool _b; |
||||||
|
}; |
||||||
|
|
||||||
|
typedef std::vector< mrw::SmartPointer<Value> > Params; |
||||||
|
Params _params; |
||||||
|
|
||||||
|
public: |
||||||
|
|
||||||
|
/// @brief returns the number of (mandatory) parameter
|
||||||
|
int size() const throw(std::bad_exception) { |
||||||
|
return _params.size(); |
||||||
|
} |
||||||
|
|
||||||
|
/// @brief add one more mandatory string parameter
|
||||||
|
Param& operator<<(const char* const s) throw(mrw::bad_exception) { |
||||||
|
_params.push_back(new StringValue(s)); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
/// @brief add one more mandatory string parameter
|
||||||
|
Param& operator<<(const std::string& s) throw(mrw::bad_exception) { |
||||||
|
_params.push_back(new StringValue(s)); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
/// @brief add one more mandatory integer parameter
|
||||||
|
Param& operator<<(int i) throw(mrw::bad_exception) { |
||||||
|
_params.push_back(new IntValue(i)); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
// @brief add one more mandatory boolean parameter
|
||||||
|
Param& operator<<(bool b) throw(mrw::bad_exception) { |
||||||
|
_params.push_back(new BoolValue(b)); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief get parameter number @i
|
||||||
|
@throw mrw::out_of_range if @c i is too big */ |
||||||
|
const mrw::SmartPointer<Value>& operator[](unsigned int i) const |
||||||
|
throw(mrw::exception) { |
||||||
|
if (i<_params.size()) return _params[i]; |
||||||
|
throw mrw::out_of_range |
||||||
|
(((std::stringstream&) |
||||||
|
(std::stringstream()<<"check failed: " |
||||||
|
<<i<<'<'<<_params.size())).str()); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
|
||||||
|
friend class Args; // allow set
|
||||||
|
mrw::SmartPointer<Value>& setable(unsigned int i) |
||||||
|
throw(mrw::exception) { |
||||||
|
if (i<_params.size()) return _params[i]; |
||||||
|
throw mrw::out_of_range |
||||||
|
(((std::stringstream&) |
||||||
|
(std::stringstream()<<"check failed: " |
||||||
|
<<i<<'<'<<_params.size())).str()); |
||||||
|
} |
||||||
|
|
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief this class represents one command line option
|
||||||
|
@pre #include<mrw/arg.hpp> |
||||||
|
|
||||||
|
The library user needs this class when setting up the list of |
||||||
|
supported command line ooptions: Simply shift one instance of @c |
||||||
|
mrw::Opt per supported command line option into @c |
||||||
|
mrw::Args::instance(), e.g.: |
||||||
|
|
||||||
|
@code |
||||||
|
mrw::Args::instance() |
||||||
|
<<mrw::Opt('h', "--help", "Show this help text"); |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
class Opt { |
||||||
|
|
||||||
|
public: |
||||||
|
|
||||||
|
/** @brief create an @c mrw::Opt with additional parameter
|
||||||
|
@param shortname short name of the option |
||||||
|
@param longname long name of the option, must start with "--" |
||||||
|
@param param the additional parameter |
||||||
|
@param help the help string for this option |
||||||
|
*/ |
||||||
|
Opt::Opt(const char shortname, const std::string& longname, |
||||||
|
const Param& param, const std::string& help) |
||||||
|
throw(mrw::bad_exception): |
||||||
|
_set(false), _shortname(shortname), _longname(longname), |
||||||
|
_param(param), _help(help) { |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief create a simple @c mrw::Opt
|
||||||
|
|
||||||
|
This option is either set or not set, there are no additional |
||||||
|
parameter. |
||||||
|
|
||||||
|
@param shortname short name of the option |
||||||
|
@param longname long name of the option, must start with "--" |
||||||
|
@param help the help string for this option |
||||||
|
*/ |
||||||
|
Opt::Opt(const char shortname, const std::string& longname, |
||||||
|
const std::string& help) |
||||||
|
throw(mrw::bad_exception): |
||||||
|
_set(false), _shortname(shortname), _longname(longname), |
||||||
|
_help(help) { |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief get the help text for this option */ |
||||||
|
const std::string& help() const throw(mrw::bad_exception) { |
||||||
|
return _help; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief find out, whether this option was set by the user
|
||||||
|
|
||||||
|
Example: Check whether the user has set the @c -v option for |
||||||
|
verbose output: |
||||||
|
|
||||||
|
@code |
||||||
|
if (mrw::Args::instance().find('v')) // -v is set
|
||||||
|
@endcode |
||||||
|
|
||||||
|
@return |
||||||
|
- @c true if the user has started the program with this option |
||||||
|
- @c false if the user has not set this option |
||||||
|
*/ |
||||||
|
operator bool() const throw(std::bad_exception) {return _set;} |
||||||
|
|
||||||
|
/** @brief get one of the additional parameter
|
||||||
|
|
||||||
|
If this option has additional parameter, get the @c i-th of them. |
||||||
|
|
||||||
|
@throw mrw::out_of_range if @c i is too big |
||||||
|
@param i number of the additional parameter to get (starting with @c 0) |
||||||
|
@return a smart pointer to the value (default or given by the user) |
||||||
|
*/ |
||||||
|
const mrw::SmartPointer<Param::Value>& operator[](unsigned int i) const |
||||||
|
throw(mrw::exception) { |
||||||
|
return _param[i]; |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
|
||||||
|
friend class Args; // is allowed to set values
|
||||||
|
void set() const throw(mrw::bad_exception) { |
||||||
|
_set = true; |
||||||
|
} |
||||||
|
Param& args() const throw(mrw::bad_exception) { |
||||||
|
return _param; |
||||||
|
} |
||||||
|
mutable bool _set; |
||||||
|
char _shortname; |
||||||
|
std::string _longname; |
||||||
|
mutable Param _param; |
||||||
|
std::string _help; |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief handle command line arguments
|
||||||
|
@pre #include<mrw/arg.hpp> |
||||||
|
|
||||||
|
This class handles command line arguments. It is a |
||||||
|
singleton. Get the one and only instance of this class with @c |
||||||
|
mrw::Args::instance(). It is setup by shifting values into this |
||||||
|
class. The order is important, be sure that you shift in @c argc |
||||||
|
and @c argv as last parameters. |
||||||
|
|
||||||
|
Example setup: |
||||||
|
|
||||||
|
@code |
||||||
|
mrw::Args::instance() |
||||||
|
<<mrw::Opt('h', "--help", "Show this help text") |
||||||
|
<<mrw::Opt('v', "--verbose", "print more information") |
||||||
|
<<"This is a testprogram for argument evaluation in C++" |
||||||
|
<<'h'<<argc<<argv; |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
class Args { |
||||||
|
|
||||||
|
public: |
||||||
|
|
||||||
|
typedef std::list<std::string> OtherArgs; |
||||||
|
|
||||||
|
/// @brief get the one and only instance
|
||||||
|
static Args& instance() throw(mrw::bad_exception) { // singleton
|
||||||
|
static Args _instance; |
||||||
|
return _instance; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief setup an acceptable option
|
||||||
|
|
||||||
|
Setup an acceptable user option. |
||||||
|
|
||||||
|
Example: |
||||||
|
|
||||||
|
@code |
||||||
|
mrw::Args::instance() |
||||||
|
<<mrw::Opt('v', "--verbose", "print more information"); |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
Args& operator<<(const mrw::Opt& opt) throw(mrw::invalid_argument) { |
||||||
|
// twice the same, but other sort order
|
||||||
|
Options::iterator it(_options.insert(_options.end(), opt)); |
||||||
|
if (!_shortopts.insert(ShortOpts::value_type(opt._shortname, it)).second) |
||||||
|
throw mrw::invalid_argument(std::string(1, opt._shortname)); |
||||||
|
if (!_longopts.insert(LongOpts::value_type(opt._longname, it)).second) |
||||||
|
throw mrw::invalid_argument(opt._longname); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief setup the number of arguments
|
||||||
|
|
||||||
|
Setup the number of arguments. |
||||||
|
This must be done before @c argv is shifted in. |
||||||
|
|
||||||
|
Example: |
||||||
|
|
||||||
|
@code |
||||||
|
int main(int argv, const char * const * const argv) { |
||||||
|
mrw::Args::instance()<<argc<<argv; |
||||||
|
... |
||||||
|
} |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
Args& operator<<(int argc) throw(mrw::bad_exception) { |
||||||
|
_argc = argc; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief setup the C array of command line arguments
|
||||||
|
|
||||||
|
Setup the C array of command line arguments. This must be the |
||||||
|
very last thing shifted in. |
||||||
|
|
||||||
|
Example: |
||||||
|
|
||||||
|
@code |
||||||
|
int main(int argv, const char * const * const argv) { |
||||||
|
mrw::Args::instance()<<argc<<argv; |
||||||
|
... |
||||||
|
} |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
Args& operator<<(const char *const*const argv) throw(mrw::exception) { |
||||||
|
if (_argc<0) |
||||||
|
throw mrw::invalid_argument("argc was not set when shifting argv"); |
||||||
|
return parse(_argc, argv); |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief add a description text
|
||||||
|
|
||||||
|
Add a description text. This description text is shown in the |
||||||
|
@c DESCRIPTION section of the help display. If the description |
||||||
|
text is shifted in more then once, the different sections are |
||||||
|
appended with new line and an empty line between. |
||||||
|
|
||||||
|
Example: |
||||||
|
|
||||||
|
@code |
||||||
|
mrw::Args::instance()<<"this is a description for --help"; |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
Args& operator<<(const std::string& description) throw(mrw::exception) { |
||||||
|
if (_description=="") |
||||||
|
_description = description; |
||||||
|
else |
||||||
|
_description += "\n\n"+description; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief set the help option
|
||||||
|
|
||||||
|
Define which option prints the help text. There is no code |
||||||
|
needed for printing the help text: if the help option has been |
||||||
|
shifted in, help is printed automatically at user request, |
||||||
|
then the program is terminated. Only specify the short option |
||||||
|
name, the long option name is known. |
||||||
|
|
||||||
|
Example: |
||||||
|
|
||||||
|
@code |
||||||
|
mrw::Args::instance()<<'h'; |
||||||
|
@endcode |
||||||
|
*/ |
||||||
|
Args& operator<<(char help) throw(mrw::exception) { |
||||||
|
_help = help; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief get an option, given the short option name
|
||||||
|
@throw mrw::out_of_range if the option does not exist |
||||||
|
*/ |
||||||
|
const Opt& find(char c) const throw(mrw::exception) { |
||||||
|
ShortOpts::const_iterator it(_shortopts.find(c)); |
||||||
|
if (it==_shortopts.end()) throw mrw::out_of_range(std::string(1, c)); |
||||||
|
return *it->second; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief get an option, given the long option name
|
||||||
|
@throw mrw::out_of_range if the option does not exist |
||||||
|
*/ |
||||||
|
const Opt& find(const std::string& s) const throw(mrw::exception) { |
||||||
|
LongOpts::const_iterator it(_longopts.find(s)); |
||||||
|
if (it==_longopts.end()) throw mrw::out_of_range(s); |
||||||
|
return *it->second; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief get all non interpreted options
|
||||||
|
|
||||||
|
All user options that don't fit the defined and interpreted |
||||||
|
options. The meaning for this is, that a user may append, |
||||||
|
e.g. a list of file names. |
||||||
|
*/ |
||||||
|
const OtherArgs& otherArgs() { |
||||||
|
return _otherargs; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief get the file name of the executable, that's @c argv[0] */ |
||||||
|
const std::string& filename() throw(mrw::bad_exception) { |
||||||
|
return _filename; |
||||||
|
} |
||||||
|
|
||||||
|
/** @brief print the help text, then exit */ |
||||||
|
void help() { |
||||||
|
std::cout<<"USAGE: "<<std::endl |
||||||
|
<<" "<<_filename<<" [ OPTIONS ]"<<std::endl |
||||||
|
<<"OPTIONS:"<<std::endl; |
||||||
|
for (Options::iterator it(_options.begin()); it!=_options.end(); ++it) { |
||||||
|
std::cout<<" -"<<it->_shortname<<" | "<<it->_longname; |
||||||
|
for (int i(0); i<it->_param.size(); ++i) |
||||||
|
std::cout<<" <"<<(*it)[i]->typestr()<<">"; |
||||||
|
if (it->_param.size()>0) std::cout<<" (default: "; |
||||||
|
for (int i(0); i<it->_param.size()-1; ++i) |
||||||
|
std::cout<<(*it)[i]->printable()<<" "; |
||||||
|
if (it->_param.size()>0) |
||||||
|
std::cout<<(*it)[it->_param.size()-1]->printable()<<")"; |
||||||
|
std::cout<<std::endl<<" "<<it->help()<<std::endl; |
||||||
|
} |
||||||
|
if (_description.size()>0) |
||||||
|
std::cout<<"DESCRIPTION:"<<std::endl |
||||||
|
<<_description<<std::endl; |
||||||
|
exit(0); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
Args& parse(int argc, const char*const*const argv) throw(mrw::exception) { |
||||||
|
if (argc>0) _filename = argv[0]; |
||||||
|
for (int i(1); i<argc; ++i) { |
||||||
|
std::string arg(argv[i]); |
||||||
|
if (arg.find("--")==0 && arg!="--") { // long arguments
|
||||||
|
LongOpts::iterator it(_longopts.find(arg)); |
||||||
|
if (it!=_longopts.end() || i+it->second->args().size()>=argc) |
||||||
|
throw mrw::invalid_argument(arg); |
||||||
|
it->second->set(); |
||||||
|
for (int j(0), l(it->second->args().size()); j<l; ++j) { |
||||||
|
*(it->second->args().setable(j)) = argv[++i]; |
||||||
|
} |
||||||
|
} else if (arg.find("-")==0) { // short arguments
|
||||||
|
// first check all, then set all
|
||||||
|
for (int j(1), l(arg.size()); j<l; ++j) { |
||||||
|
ShortOpts::iterator it(_shortopts.find(arg[j])); |
||||||
|
if (it==_shortopts.end() || it->second->args().size()>0 && |
||||||
|
(j+1!=l || i+it->second->args().size()>=argc)) |
||||||
|
throw mrw::invalid_argument(arg); |
||||||
|
} |
||||||
|
for (int j(1), l(arg.size()); j<l; ++j) { |
||||||
|
ShortOpts::iterator it(_shortopts.find(arg[j])); |
||||||
|
it->second->set(); |
||||||
|
if (j+1==l && it->second->args().size()>0) { |
||||||
|
for (int k(0); k < it->second->args().size(); ++k) { |
||||||
|
*(it->second->args().setable(k)) = argv[++i]; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} else { |
||||||
|
if (arg!="--") _otherargs.push_back(arg); |
||||||
|
while (++i<argc) _otherargs.push_back(argv[i]); |
||||||
|
} |
||||||
|
} |
||||||
|
if (_help && find(_help)) help(); |
||||||
|
return *this; |
||||||
|
} |
||||||
|
typedef std::list<Opt> Options; |
||||||
|
typedef std::map<char, Options::iterator> ShortOpts; |
||||||
|
typedef std::map<std::string, Options::iterator> LongOpts; |
||||||
|
Args(): _argc(-1), _help(0) {} // singleton
|
||||||
|
Args& operator=(const Args&); // singleton, not implemented
|
||||||
|
std::string _filename; |
||||||
|
Options _options; |
||||||
|
ShortOpts _shortopts; |
||||||
|
LongOpts _longopts; |
||||||
|
OtherArgs _otherargs; |
||||||
|
int _argc; |
||||||
|
char _help; |
||||||
|
std::string _description; |
||||||
|
}; |
||||||
|
|
||||||
|
//@}
|
||||||
|
} |
||||||
@ -0,0 +1,25 @@ |
|||||||
|
#include <mrw/smartpointer.hpp> |
||||||
|
|
||||||
|
class A { |
||||||
|
public: int a; |
||||||
|
protected: virtual void fn() {} // dynamic_cast requires a virtual function
|
||||||
|
}; |
||||||
|
|
||||||
|
class B: virtual public A { |
||||||
|
public: int b; |
||||||
|
}; |
||||||
|
|
||||||
|
int main(int, char**) { |
||||||
|
utl::SmartPointer<int> i1 = new int; |
||||||
|
*i1 = 13; |
||||||
|
utl::SmartPointer<int> i2 = i1; |
||||||
|
utl::SmartPointer<int> i3; |
||||||
|
if (!i3) i3 = i2; |
||||||
|
*i2 = 666; // *i1 is now 666 too
|
||||||
|
utl::SmartPointer<A> b1 = new B; |
||||||
|
utl::SmartPointer<B> b2 = b1; // b1 and b2 point to the same instance
|
||||||
|
b1->a = 0; // b1->b does not compile
|
||||||
|
b2->a = 1; |
||||||
|
b2->b = 2; |
||||||
|
return 0; |
||||||
|
} // memory is automatically freed
|
||||||
@ -0,0 +1,72 @@ |
|||||||
|
#ifndef __MRW_SIMPLETRACE_HPP__ |
||||||
|
#define __MRW_SIMPLETRACE_HPP__ |
||||||
|
#include <iostream> |
||||||
|
#include <iomanip> |
||||||
|
#include <string> |
||||||
|
|
||||||
|
// GENERIC TRACER FOR TESTS ---------------------------------------------------
|
||||||
|
// (without file/line)
|
||||||
|
#ifndef __GNUG__ |
||||||
|
#define METHOD(name) mrw::FnTrace fnTrace(this, name) |
||||||
|
#define FUNCTION(name) mrw::FnTrace fnTrace(0, name) |
||||||
|
#else |
||||||
|
#define METHOD mrw::FnTrace fnTrace(this, __FUNCTION__) |
||||||
|
#define FUNCTION mrw::FnTrace fnTrace(0, __FUNCTION__) |
||||||
|
#endif |
||||||
|
#define CALL(name) fnTrace.call(name) |
||||||
|
#define TRACE(name) fnTrace.trace(name) |
||||||
|
#define TRACE_OFF mrw::FnTrace::off() |
||||||
|
#define TRACE_ON mrw::FnTrace::on() |
||||||
|
#define NO_TRACE mrw::NoTrace noTrace; |
||||||
|
|
||||||
|
namespace mrw { |
||||||
|
class FnTrace { |
||||||
|
public: |
||||||
|
FnTrace(const void* addr, const std::string& name): |
||||||
|
_addr(addr), _name(name) { |
||||||
|
if (_off==0) |
||||||
|
std::cout<<std::hex<<std::setw(15)<<_addr<<": "<<std::dec |
||||||
|
<<std::setw(2+_level)<<std::setfill(' ')<<"\\ " |
||||||
|
<<_name<<std::endl; |
||||||
|
++_level; |
||||||
|
} |
||||||
|
~FnTrace() { |
||||||
|
--_level; |
||||||
|
if (_off==0) |
||||||
|
std::cout<<std::hex<<std::setw(15)<<_addr<<": "<<std::dec |
||||||
|
<<std::setw(2+_level)<<std::setfill(' ')<<"/ "<<_name |
||||||
|
<<std::endl; |
||||||
|
} |
||||||
|
void call(const std::string& name) { |
||||||
|
if (_off==0) |
||||||
|
std::cout<<std::hex<<std::setw(15)<<_addr<<": "<<std::dec |
||||||
|
<<std::setw(4+_level)<<std::setfill(' ')<<" -> "<<name |
||||||
|
<<std::endl; |
||||||
|
} |
||||||
|
void trace(const std::string& name) { |
||||||
|
if (_off==0) |
||||||
|
std::cout<<std::hex<<std::setw(15)<<_addr<<": "<<std::dec |
||||||
|
<<std::setw(4+_level)<<std::setfill(' ')<<" **** "<<name |
||||||
|
<<" **** "<<std::endl; |
||||||
|
} |
||||||
|
static void off() { |
||||||
|
++_off; |
||||||
|
} |
||||||
|
static void on() { |
||||||
|
if (_off>0) --_off; |
||||||
|
} |
||||||
|
private: |
||||||
|
const void* _addr; |
||||||
|
const std::string _name; |
||||||
|
static unsigned int _level; |
||||||
|
static unsigned int _off; |
||||||
|
}; |
||||||
|
unsigned int FnTrace::_level(0); |
||||||
|
unsigned int FnTrace::_off(0); |
||||||
|
class NoTrace { |
||||||
|
public: |
||||||
|
NoTrace() {TRACE_OFF;} |
||||||
|
~NoTrace() {TRACE_ON;} |
||||||
|
}; |
||||||
|
} |
||||||
|
#endif |
||||||
@ -0,0 +1,137 @@ |
|||||||
|
#ifndef __MRW__SMARTPOINTER_HPP__ |
||||||
|
#define __MRW__SMARTPOINTER_HPP__ |
||||||
|
|
||||||
|
namespace mrw { |
||||||
|
|
||||||
|
class PointerCounter { |
||||||
|
private: |
||||||
|
unsigned int _cnt; |
||||||
|
public: |
||||||
|
PointerCounter(): |
||||||
|
_cnt(1) { |
||||||
|
} |
||||||
|
PointerCounter* incr() { |
||||||
|
++_cnt; |
||||||
|
return this; |
||||||
|
} |
||||||
|
int decr() { |
||||||
|
return --_cnt; |
||||||
|
} |
||||||
|
int get() { |
||||||
|
return _cnt; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
class SmartPointerParent { |
||||||
|
protected: |
||||||
|
template<class TYPE> |
||||||
|
PointerCounter* getCounter(TYPE& sp) { |
||||||
|
return sp._cnt; |
||||||
|
} |
||||||
|
template<class TYPE> |
||||||
|
typename TYPE::Pointer getPointer(TYPE& sp) { |
||||||
|
return sp._ptr; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
/** @addtogroup AutoTools */ |
||||||
|
//@{
|
||||||
|
|
||||||
|
/** @brief Smart Pointer Implementation
|
||||||
|
@pre #include <mrw/smartpointer.hpp> |
||||||
|
|
||||||
|
This is a smart pointer that can be casted withing the |
||||||
|
inheritance of the pointer it is storing. |
||||||
|
|
||||||
|
A smart pointer is a pointer that is automatically cleaned up |
||||||
|
when it is no more referenced. Therefore you only allocate |
||||||
|
memory, but you never free it, just as in Java, cleaning up is |
||||||
|
done behind the scenes. If you assign a smart pointer to another |
||||||
|
smart pointer, both point to the same memory. A counter counts |
||||||
|
the number of references to the object and frees it as soon as |
||||||
|
the last smart pointer pointing to the same memory has been |
||||||
|
destroyed. |
||||||
|
|
||||||
|
A smart pointer is used just as a normal pointer, except that |
||||||
|
you can assign it only to other smart pointers, not to ordinary |
||||||
|
pointers, and you don't have to delete the memory allocated. Any |
||||||
|
memory assigned to a smart pointer is consumed and mustn't be |
||||||
|
used any more. Never allocate a smart pointer with |
||||||
|
<code>new</code>, but only the pointer that is stored in the |
||||||
|
smart pointer! |
||||||
|
|
||||||
|
@note memory assigned to a smart pointer is consumed |
||||||
|
*/
|
||||||
|
template<class TYPE> class SmartPointer: public SmartPointerParent { |
||||||
|
private: |
||||||
|
typedef TYPE* Pointer; |
||||||
|
PointerCounter* _cnt; |
||||||
|
TYPE* _ptr; |
||||||
|
private: |
||||||
|
void drop() { |
||||||
|
if (_cnt && !_cnt->decr()) { |
||||||
|
delete _cnt; _cnt=0; |
||||||
|
delete _ptr; _ptr=0; |
||||||
|
} |
||||||
|
} |
||||||
|
private: |
||||||
|
friend class SmartPointerParent; |
||||||
|
friend class SmartPointerTest; |
||||||
|
public: |
||||||
|
SmartPointer(): |
||||||
|
_cnt(0), _ptr(0) { |
||||||
|
} |
||||||
|
SmartPointer(const SmartPointer<TYPE>& o): |
||||||
|
_cnt(o._cnt?o._cnt->incr():0), _ptr(o._ptr) { |
||||||
|
} |
||||||
|
SmartPointer(TYPE* ptr): |
||||||
|
_cnt(ptr ? new PointerCounter : 0), _ptr(ptr) { |
||||||
|
} |
||||||
|
template<class OTHER> SmartPointer(const SmartPointer<OTHER>& o): |
||||||
|
_cnt(0), _ptr(dynamic_cast<TYPE*>(getPointer(o))) { |
||||||
|
if (_ptr) _cnt = getCounter(o)->incr(); |
||||||
|
} |
||||||
|
~SmartPointer() { |
||||||
|
drop(); |
||||||
|
} |
||||||
|
SmartPointer& operator=(const SmartPointer<TYPE>& o) { |
||||||
|
if (o._ptr==_ptr) return *this; |
||||||
|
drop(); |
||||||
|
_cnt = o._cnt ? o._cnt->incr() : 0; |
||||||
|
_ptr = o._ptr; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
SmartPointer& operator=(TYPE* ptr) { |
||||||
|
if (ptr==_ptr) return *this; |
||||||
|
drop(); |
||||||
|
_cnt = ptr ? new PointerCounter : 0; |
||||||
|
_ptr = ptr; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
template<class OTHER> |
||||||
|
SmartPointer& operator=(const SmartPointer<OTHER>& o) { |
||||||
|
if (getPointer(o)==_ptr) return *this; |
||||||
|
drop(); |
||||||
|
_ptr = dynamic_cast<TYPE*>(getPointer(o)); |
||||||
|
_cnt = _ptr ? getCounter(o)->incr() : 0; |
||||||
|
return *this; |
||||||
|
} |
||||||
|
TYPE& operator*() { |
||||||
|
return *_ptr; |
||||||
|
} |
||||||
|
const TYPE& operator*() const { |
||||||
|
return *_ptr; |
||||||
|
} |
||||||
|
TYPE* const operator->() { |
||||||
|
return _ptr; |
||||||
|
} |
||||||
|
const TYPE* const operator->() const { |
||||||
|
return _ptr; |
||||||
|
} |
||||||
|
operator bool() { |
||||||
|
return _ptr!=0; |
||||||
|
} |
||||||
|
}; |
||||||
|
//@}
|
||||||
|
} |
||||||
|
#endif |
||||||
Loading…
Reference in new issue