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 #pragma once
  22
  23 #include "action.h"
  24 #include "options.h"
  25 #include "parser_state.h"
  26
  27 #include "stg/common.h"
  28
  29 #include <string>
  30 #include <optional>
  31
  32 #include <cassert>
  33
  34 namespace SGCONF
  35 {
  36
  37 typedef void (* FUNC0)();
  38
  39 template <typename F>
  40 class FUNC0_ACTION : public ACTION
  41 {
  42     public:
  43         explicit FUNC0_ACTION(const F & func) : m_func(func) {}
  44
  45         std::string ParamDescription() const override { return ""; }
  46         std::string DefaultDescription() const override { return ""; }
  47         OPTION_BLOCK & Suboptions() override { return m_suboptions; }
  48         PARSER_STATE Parse(int argc, char ** argv, void * /*data*/) override
  49         {
  50             m_func();
  51             return PARSER_STATE(true, argc, argv);
  52         }
  53
  54     private:
  55         F m_func;
  56         OPTION_BLOCK m_suboptions;
  57 };
  58
  59 template <typename F>
  60 inline
  61 std::unique_ptr<ACTION> MakeFunc0Action(F func)
  62 {
  63 return std::make_unique<FUNC0_ACTION<F>>(func);
  64 }
  65
  66 template <typename T>
  67 class PARAM_ACTION : public ACTION
  68 {
  69     public:
  70         PARAM_ACTION(std::optional<T> & param,
  71                      const T & defaultValue,
  72                      const std::string & paramDescription)
  73             : m_param(param),
  74               m_defaltValue(defaultValue),
  75               m_description(paramDescription),
  76               m_hasDefault(true)
  77         {}
  78         explicit PARAM_ACTION(std::optional<T> & param)
  79             : m_param(param),
  80               m_hasDefault(false)
  81         {}
  82         PARAM_ACTION(std::optional<T> & param,
  83                      const std::string & paramDescription)
  84             : m_param(param),
  85               m_description(paramDescription),
  86               m_hasDefault(false)
  87         {}
  88
  89         std::string ParamDescription() const override { return m_description; }
  90         std::string DefaultDescription() const override;
  91         OPTION_BLOCK & Suboptions() override { return m_suboptions; }
  92         PARSER_STATE Parse(int argc, char ** argv, void * /*data*/) override;
  93         void ParseValue(const std::string & value) override;
  94
  95     private:
  96         std::optional<T> & m_param;
  97         T m_defaltValue;
  98         std::string m_description;
  99         bool m_hasDefault;
 100         OPTION_BLOCK m_suboptions;
 101 };
 102
 103 template <typename T>
 104 inline
 105 std::string PARAM_ACTION<T>::DefaultDescription() const
 106 {
 107 return m_hasDefault ? " (default: '" + std::to_string(m_defaltValue) + "')"
 108                     : "";
 109 }
 110
 111 template <>
 112 inline
 113 std::string PARAM_ACTION<std::string>::DefaultDescription() const
 114 {
 115 return m_hasDefault ? " (default: '" + m_defaltValue + "')"
 116                     : "";
 117 }
 118
 119 template <typename T>
 120 inline
 121 PARSER_STATE PARAM_ACTION<T>::Parse(int argc, char ** argv, void * /*data*/)
 122 {
 123 if (argc == 0 ||
 124     argv == NULL ||
 125     *argv == NULL)
 126     throw ERROR("Missing argument.");
 127 T value;
 128 if (str2x(*argv, value))
 129     throw ERROR(std::string("Bad argument: '") + *argv + "'");
 130 m_param = value;
 131 return PARSER_STATE(false, --argc, ++argv);
 132 }
 133
 134 template <>
 135 inline
 136 PARSER_STATE PARAM_ACTION<bool>::Parse(int argc, char ** argv, void * /*data*/)
 137 {
 138 m_param = true;
 139 return PARSER_STATE(false, argc, argv);
 140 }
 141
 142 template <typename T>
 143 inline
 144 void PARAM_ACTION<T>::ParseValue(const std::string & stringValue)
 145 {
 146 if (stringValue.empty())
 147     throw ERROR("Missing value.");
 148 T value;
 149 if (str2x(stringValue, value))
 150     throw ERROR(std::string("Bad value: '") + stringValue + "'");
 151 m_param = value;
 152 }
 153
 154 template <>
 155 inline
 156 void PARAM_ACTION<std::string>::ParseValue(const std::string & stringValue)
 157 {
 158 m_param = stringValue;
 159 }
 160
 161 template <>
 162 inline
 163 PARSER_STATE PARAM_ACTION<std::string>::Parse(int argc, char ** argv, void * /*data*/)
 164 {
 165 if (argc == 0 ||
 166     argv == NULL ||
 167     *argv == NULL)
 168     throw ERROR("Missing argument.");
 169 m_param = *argv;
 170 return PARSER_STATE(false, --argc, ++argv);
 171 }
 172
 173 template <typename T>
 174 inline
 175 std::unique_ptr<ACTION> MakeParamAction(std::optional<T> & param,
 176                                         const T & defaultValue,
 177                                         const std::string & paramDescription)
 178 {
 179 return std::make_unique<PARAM_ACTION<T>>(param, defaultValue, paramDescription);
 180 }
 181
 182 template <typename T>
 183 inline
 184 std::unique_ptr<ACTION> MakeParamAction(std::optional<T> & param)
 185 {
 186 return std::make_unique<PARAM_ACTION<T>>(param);
 187 }
 188
 189 template <typename T>
 190 inline
 191 std::unique_ptr<ACTION> MakeParamAction(std::optional<T> & param,
 192                                         const std::string & paramDescription)
 193 {
 194 return std::make_unique<PARAM_ACTION<T>>(param, paramDescription);
 195 }
 196
 197 class KV_ACTION : public ACTION
 198 {
 199     public:
 200         KV_ACTION(const std::string & name,
 201                   const std::string & paramDescription)
 202             : m_name(name),
 203               m_description(paramDescription)
 204         {}
 205
 206         std::string ParamDescription() const override { return m_description; }
 207         std::string DefaultDescription() const override { return ""; }
 208         OPTION_BLOCK & Suboptions() override { return m_suboptions; }
 209         PARSER_STATE Parse(int argc, char ** argv, void * data) override;
 210
 211     private:
 212         std::string m_name;
 213         std::string m_description;
 214         OPTION_BLOCK m_suboptions;
 215 };
 216
 217 inline
 218 PARSER_STATE KV_ACTION::Parse(int argc, char ** argv, void * data)
 219 {
 220 if (argc == 0 ||
 221     argv == NULL ||
 222     *argv == NULL)
 223     throw ERROR("Missing argument.");
 224 assert(data != NULL && "Expecting container pointer.");
 225 std::map<std::string, std::string> & kvs = *static_cast<std::map<std::string, std::string>*>(data);
 226 kvs[m_name] = *argv;
 227 return PARSER_STATE(false, --argc, ++argv);
 228 }
 229
 230 inline
 231 std::unique_ptr<ACTION> MakeKVAction(const std::string & name,
 232                                      const std::string & paramDescription)
 233 {
 234 return std::make_unique<KV_ACTION>(name, paramDescription);
 235 }
 236
 237 } // namespace SGCONF