#include <string>
#include <vector>
#include <msp/strings/lexicalcast.h>
+#include "mspcore_api.h"
#include "noncopyable.h"
namespace Msp {
-class usage_error: public std::runtime_error
+class MSPCORE_API usage_error: public std::runtime_error
{
private:
- std::string help_;
+ std::string m_help;
public:
- usage_error(const std::string &w, const std::string &h = std::string()): std::runtime_error(w), help_(h) { }
- ~usage_error() throw() { }
+ usage_error(const std::string &w, const std::string &h = std::string()): std::runtime_error(w), m_help(h) { }
- const char *help() const throw() { return help_.c_str(); }
+ const char *help() const noexcept { return m_help.c_str(); }
};
arguments and their associated help texts. An application may override this by
providing its own option with the same name.
*/
-class GetOpt: private NonCopyable
+class MSPCORE_API GetOpt: private NonCopyable
{
public:
enum ArgType
REQUIRED_ARG
};
- class Option
+ class MSPCORE_API Option
{
protected:
- Option() { }
+ Option() = default;
public:
- virtual ~Option() { }
+ virtual ~Option() = default;
/// Sets help text for the option.
virtual Option &set_help(const std::string &) = 0;
virtual unsigned get_seen_count() const = 0;
};
- class Argument
+ class MSPCORE_API Argument
{
protected:
- Argument() { }
+ Argument() = default;
public:
- virtual ~Argument() { }
+ virtual ~Argument() = default;
virtual Argument &set_help(const std::string &) = 0;
};
class Store
{
protected:
- Store() { }
+ Store() = default;
public:
- virtual ~Store() { }
+ virtual ~Store() = default;
virtual Store *clone() const = 0;
class OptionImpl: public Option
{
protected:
- char shrt;
+ char shrt = 0;
std::string lng;
- ArgType arg_type;
- unsigned seen_count;
- unsigned *ext_seen_count;
+ ArgType arg_type = NO_ARG;
+ unsigned seen_count = 0;
+ unsigned *ext_seen_count = nullptr;
std::string help;
- std::string metavar;
- Store *store;
+ std::string metavar = "ARG";
+ Store *store = nullptr;
public:
OptionImpl(char, const std::string &, const Store &, ArgType);
- virtual ~OptionImpl();
+ ~OptionImpl() override;
- virtual OptionImpl &set_help(const std::string &);
- virtual OptionImpl &set_help(const std::string &, const std::string &);
- virtual OptionImpl &bind_seen_count(unsigned &);
+ OptionImpl &set_help(const std::string &) override;
+ OptionImpl &set_help(const std::string &, const std::string &) override;
+ OptionImpl &bind_seen_count(unsigned &) override;
char get_short() const { return shrt; }
const std::string &get_long() const { return lng; }
ArgType get_arg_type() const { return arg_type; }
const std::string &get_help() const { return help; }
const std::string &get_metavar() const { return metavar; }
- virtual unsigned get_seen_count() const { return seen_count; }
+ unsigned get_seen_count() const override { return seen_count; }
void process();
void process(const std::string &);
};
{
private:
std::string name;
- ArgType type;
+ ArgType type = REQUIRED_ARG;
std::string help;
- Store *store;
+ Store *store = nullptr;
public:
ArgumentImpl(const std::string &, const Store &, ArgType);
- virtual ~ArgumentImpl();
+ ~ArgumentImpl() override;
- virtual ArgumentImpl &set_help(const std::string &);
+ ArgumentImpl &set_help(const std::string &) override;
const std::string &get_name() const { return name; }
ArgType get_type() const { return type; }
const std::string &get_help() const { return help; }
public:
SimpleStore(T &d): data(d) { }
- virtual SimpleStore *clone() const
+ SimpleStore *clone() const override
{ return new SimpleStore(data); }
- virtual bool is_list() const { return false; }
+ bool is_list() const override { return false; }
- virtual void store() { }
+ void store() override { }
- virtual void store(const std::string &a)
+ void store(const std::string &a) override
{ data = lexical_cast<T>(a); }
};
public:
ListStore(T &d): data(d) { }
- virtual ListStore *clone() const
+ ListStore *clone() const override
{ return new ListStore(data); }
- virtual bool is_list() const { return true; }
+ bool is_list() const override { return true; }
- virtual void store() { }
+ void store() override { }
- virtual void store(const std::string &a)
+ void store(const std::string &a) override
{ data.push_back(lexical_cast<typename T::value_type>(a)); }
};
- typedef std::list<OptionImpl *> OptionList;
- typedef std::list<ArgumentImpl *> ArgumentList;
-
- bool help;
- OptionList opts;
- ArgumentList args;
+ bool help = false;
+ std::vector<OptionImpl *> opts;
+ std::vector<ArgumentImpl *> args;
std::vector<std::string> args_raw;
public:
GetOpt();
~GetOpt();
- /** Returns any non-option arguments encountered during processing.
- Deprecated. */
- const std::vector<std::string> &get_args() const { return args_raw; }
-
/** Adds an option with both short and long forms. Processing depends on
the type of the destination variable and whether an argument is taken or
not. With an argument, the value is lexical_cast to the appropriate type
Option &add_option(char s, const std::string &l, T &d, ArgType a = NO_ARG)
{ return add_option(s, l, SimpleStore<T>(d), a); }
+ /** Adds an option with both short and long forms. The option may be
+ specified multiple times, and the argument from each occurrence is stored in
+ the list. The argument type must be REQUIRED_ARG. */
+ template<typename T>
+ Option &add_option(char s, const std::string &l, std::vector<T> &d, ArgType a = REQUIRED_ARG)
+ { return add_option(s, l, ListStore<std::vector<T> >(d), a); }
+
/** Adds an option with both short and long forms. The option may be
specified multiple times, and the argument from each occurrence is stored in
the list. The argument type must be REQUIRED_ARG. */
Argument &add_argument(const std::string &n, T &d, ArgType a = REQUIRED_ARG)
{ return add_argument(n, SimpleStore<T>(d), a); }
+ /** Adds a positional argument list. If the list is declared as required,
+ at least one element must be given; an optional list may be empty. Only one
+ list may be added, and optional fixed arguments can't be used with it. */
+ template<typename T>
+ Argument &add_argument(const std::string &n, std::vector<T> &d, ArgType a = REQUIRED_ARG)
+ { return add_argument(n, ListStore<std::vector<T> >(d), a); }
+
/** Adds a positional argument list. If the list is declared as required,
at least one element must be given; an optional list may be empty. Only one
list may be added, and optional fixed arguments can't be used with it. */
template<> inline void GetOpt::SimpleStore<std::string>::store(const std::string &a)
{ data = a; }
+template<> inline void GetOpt::ListStore<std::vector<std::string> >::store(const std::string &a)
+{ data.push_back(a); }
+
template<> inline void GetOpt::ListStore<std::list<std::string> >::store(const std::string &a)
{ data.push_back(a); }
projects / libs / core.git / blobdiff