source/core/getopt.h

   1 /* $Id$
   2
   3 This file is part of libmspcore
   4 Copyright © 2006-2007 Mikko Rasa, Mikkosoft Productions
   5 Distributed under the LGPL
   6 */
   7 #ifndef MSP_CORE_GETOPT_H_
   8 #define MSP_CORE_GETOPT_H_
   9
  10 #include <sstream>
  11 #include <string>
  12 #include <vector>
  13 #include "except.h"
  14
  15 namespace Msp {
  16
  17 class GetOpt
  18 {
  19 public:
  20         enum ArgType
  21         {
  22                 NO_ARG,
  23                 OPTIONAL_ARG,
  24                 REQUIRED_ARG
  25         };
  26
  27         class OptBase
  28         {
  29         public:
  30                 OptBase           &set_help(const std::string &);
  31                 OptBase           &set_help(const std::string &, const std::string &);
  32                 char              get_short() const               { return shrt; }
  33                 const std::string &get_long() const               { return lng; }
  34                 ArgType           get_arg_type() const            { return arg_type; }
  35                 const std::string &get_help() const               { return help; }
  36                 const std::string &get_metavar() const            { return metavar; }
  37                 unsigned          get_seen_count() const          { return seen_count; }
  38                 void              process();
  39                 void              process(const std::string &);
  40                 virtual ~OptBase() { }
  41         protected:
  42                 char        shrt;
  43                 std::string lng;
  44                 ArgType     arg_type;
  45                 unsigned    seen_count;
  46                 std::string help;
  47                 std::string metavar;
  48
  49                 OptBase(char, const std::string &, ArgType);
  50                 virtual void store()=0;
  51                 virtual void store(const std::string &)=0;
  52         };
  53
  54 private:
  55         template<typename T>
  56         class Option: public OptBase
  57         {
  58         public:
  59                 Option(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d) { }
  60
  61                 virtual void store() { }
  62
  63                 virtual void store(const std::string &a)
  64                 {
  65                         T tmp;
  66                         std::istringstream ss(a);
  67                         ss>>tmp;
  68                         if(ss.fail())
  69                                 throw UsageError("Invalid argument for --"+lng);
  70
  71                         data=tmp;
  72                 }
  73         private:
  74                 T &data;
  75         };
  76
  77         template<typename T>
  78         class ListOption: public OptBase
  79         {
  80         public:
  81                 ListOption(char s, const std::string &l, T &d, ArgType a): OptBase(s, l, a), data(d)
  82                 { if(arg_type!=REQUIRED_ARG) throw Exception("ListOption with arg_type!=REQUIRED makes no sense"); }
  83
  84                 virtual void store() { }
  85
  86                 virtual void store(const std::string &a)
  87                 {
  88                         typename T::value_type tmp;
  89                         std::istringstream ss(a);
  90                         ss>>tmp;
  91                         if(ss.fail())
  92                                 throw UsageError("Invalid argument for --"+lng);
  93
  94                         data.push_back(tmp);
  95                 }
  96         private:
  97                 T &data;
  98         };
  99
 100         std::list<OptBase *> opts;
 101         std::vector<std::string> args;
 102
 103 public:
 104         ~GetOpt();
 105
 106         const std::vector<std::string> &get_args() const { return args; }
 107
 108         template<typename T>
 109         OptBase &add_option(char s, const std::string &l, T &d, ArgType a=NO_ARG)
 110         { opts.push_back(new Option<T>(s, l, d, a)); return *opts.back(); }
 111
 112         template<typename T>
 113         OptBase &add_option(char s, const std::string &l, std::list<T> &d, ArgType a=REQUIRED_ARG)
 114         { opts.push_back(new ListOption<std::list<T> >(s, l, d, a)); return *opts.back(); }
 115
 116         template<typename T>
 117         OptBase &add_option(const std::string &l, T &d, ArgType a)
 118         { return add_option(0, l, d, a); }
 119
 120         std::string generate_usage(const std::string &) const;
 121         std::string generate_help() const;
 122         void operator()(unsigned, const char *const *);
 123 private:
 124
 125         OptBase &get_option(char);
 126         OptBase &get_option(const std::string &);
 127         unsigned process_long(const char *const *);
 128         unsigned process_short(const char *const *);
 129 };
 130
 131 template<> inline void GetOpt::Option<bool>::store()     { data=true; }
 132 template<> inline void GetOpt::Option<unsigned>::store() { ++data; }
 133
 134 template<> inline void GetOpt::Option<std::string>::store(const std::string &a)
 135 { data=a; }
 136
 137 template<> inline void GetOpt::ListOption<std::list<std::string> >::store(const std::string &a)
 138 { data.push_back(a); }
 139
 140 } // namespace Msp
 141
 142 #endif