projects/sgconf/actions.h

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  19  */
  20
  21 #ifndef __STG_SGCONF_ACTIONS_H__
  22 #define __STG_SGCONF_ACTIONS_H__
  23
  24 #include "action.h"
  25 #include "options.h"
  26 #include "parser_state.h"
  27
  28 #include "stg/common.h"
  29 #include "stg/resetable.h"
  30
  31 #include <string>
  32
  33 namespace SGCONF
  34 {
  35
  36 typedef void (* FUNC0)();
  37
  38 template <typename F>
  39 class FUNC0_ACTION : public ACTION
  40 {
  41     public:
  42         FUNC0_ACTION(const F & func) : m_func(func) {}
  43
  44         virtual ACTION * Clone() const { return new FUNC0_ACTION<F>(*this); }
  45
  46         virtual std::string ParamDescription() const { return ""; }
  47         virtual std::string DefaultDescription() const { return ""; }
  48         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
  49         virtual PARSER_STATE Parse(int argc, char ** argv)
  50         {
  51         m_func();
  52         return PARSER_STATE(true, argc, argv);
  53         }
  54
  55     private:
  56         F m_func;
  57         OPTION_BLOCK m_suboptions;
  58 };
  59
  60 template <typename F>
  61 inline
  62 FUNC0_ACTION<F> * MakeFunc0Action(F func)
  63 {
  64 return new FUNC0_ACTION<F>(func);
  65 }
  66
  67 template <typename T>
  68 class PARAM_ACTION : public ACTION
  69 {
  70     public:
  71         PARAM_ACTION(RESETABLE<T> & param,
  72                      const T & defaultValue,
  73                      const std::string & paramDescription)
  74             : m_param(param),
  75               m_defaltValue(defaultValue),
  76               m_description(paramDescription),
  77               m_hasDefault(true)
  78         {}
  79         PARAM_ACTION(RESETABLE<T> & param,
  80                      const std::string & paramDescription)
  81             : m_param(param),
  82               m_description(paramDescription),
  83               m_hasDefault(false)
  84         {}
  85
  86         virtual ACTION * Clone() const { return new PARAM_ACTION<T>(*this); }
  87
  88         virtual std::string ParamDescription() const { return m_description; }
  89         virtual std::string DefaultDescription() const;
  90         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
  91         virtual PARSER_STATE Parse(int argc, char ** argv);
  92
  93     private:
  94         RESETABLE<T> & m_param;
  95         T m_defaltValue;
  96         std::string m_description;
  97         bool m_hasDefault;
  98         OPTION_BLOCK m_suboptions;
  99 };
 100
 101 template <typename T>
 102 inline
 103 std::string PARAM_ACTION<T>::DefaultDescription() const
 104 {
 105 return m_hasDefault ? " (default: '" + x2str(m_defaltValue) + "')"
 106                     : "";
 107 }
 108
 109 template <>
 110 inline
 111 std::string PARAM_ACTION<std::string>::DefaultDescription() const
 112 {
 113 return m_hasDefault ? " (default: '" + m_defaltValue + "')"
 114                     : "";
 115 }
 116
 117 template <typename T>
 118 inline
 119 PARSER_STATE PARAM_ACTION<T>::Parse(int argc, char ** argv)
 120 {
 121 if (argc == 0 ||
 122     argv == NULL ||
 123     *argv == NULL)
 124     throw ERROR("Missing argument.");
 125 T value;
 126 if (str2x(*argv, value))
 127     throw ERROR(std::string("Bad argument: '") + *argv + "'");
 128 m_param = value;
 129 return PARSER_STATE(false, --argc, ++argv);
 130 }
 131
 132 template <>
 133 inline
 134 PARSER_STATE PARAM_ACTION<std::string>::Parse(int argc, char ** argv)
 135 {
 136 if (argc == 0 ||
 137     argv == NULL ||
 138     *argv == NULL)
 139     throw ERROR("Missing argument.");
 140 m_param = *argv;
 141 return PARSER_STATE(false, --argc, ++argv);
 142 }
 143
 144 template <typename T>
 145 inline
 146 PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
 147                                   const T & defaultValue,
 148                                   const std::string & paramDescription)
 149 {
 150 return new PARAM_ACTION<T>(param, defaultValue, paramDescription);
 151 }
 152
 153 template <typename T>
 154 inline
 155 PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
 156                                   const std::string & paramDescription)
 157 {
 158 return new PARAM_ACTION<T>(param, paramDescription);
 159 }
 160
 161 } // namespace SGCONF
 162
 163 #endif