projects/sgconf/api_action.h

   1 #ifndef __STG_SGCONF_API_ACTION_H__
   2 #define __STG_SGCONF_API_ACTION_H__
   3
   4 #include "action.h"
   5
   6 #include "options.h"
   7
   8 #include <string>
   9 #include <map>
  10 #include <vector>
  11
  12 namespace SGCONF
  13 {
  14
  15 typedef bool (* API_FUNCTION) (const CONFIG &,
  16                                const std::string &,
  17                                const std::map<std::string, std::string> &);
  18
  19 class COMMAND
  20 {
  21     public:
  22         COMMAND(API_FUNCTION funPtr,
  23                 const std::string & arg,
  24                 const std::map<std::string, std::string> & options)
  25             : m_funPtr(funPtr),
  26               m_arg(arg),
  27               m_options(options)
  28         {}
  29         bool Execute(const SGCONF::CONFIG & config) const
  30         {
  31             return m_funPtr(config, m_arg, m_options);
  32         }
  33
  34     private:
  35         API_FUNCTION m_funPtr;
  36         std::string m_arg;
  37         std::map<std::string, std::string> m_options;
  38 };
  39
  40 class COMMANDS
  41 {
  42     public:
  43         void Add(API_FUNCTION funPtr,
  44                  const std::string & arg,
  45                  const std::map<std::string, std::string> & options) { m_commands.push_back(COMMAND(funPtr, arg, options)); }
  46         bool Execute(const SGCONF::CONFIG & config) const
  47         {
  48             std::vector<COMMAND>::const_iterator it(m_commands.begin());
  49             bool res = true;
  50             while (it != m_commands.end() && res)
  51             {
  52                 res = res && it->Execute(config);
  53                 ++it;
  54             }
  55             return res;
  56         }
  57     private:
  58         std::vector<COMMAND> m_commands;
  59 };
  60
  61 class API_ACTION : public ACTION
  62 {
  63     public:
  64         struct PARAM
  65         {
  66             PARAM(const std::string & n,
  67                   const std::string & s,
  68                   const std::string & l)
  69                 : name(n),
  70                   shortDescr(s),
  71                   longDescr(l)
  72             {}
  73             std::string name;
  74             std::string shortDescr;
  75             std::string longDescr;
  76         };
  77
  78         API_ACTION(COMMANDS & commands,
  79                    const std::string & paramDescription,
  80                    bool needArgument,
  81                    const std::vector<PARAM> & params,
  82                    API_FUNCTION funPtr);
  83         API_ACTION(COMMANDS & commands,
  84                    const std::string & paramDescription,
  85                    bool needArgument,
  86                    API_FUNCTION funPtr)
  87             : m_commands(commands),
  88               m_description(paramDescription),
  89               m_argument(needArgument ? "1" : ""), // Hack
  90               m_funPtr(funPtr)
  91         {}
  92
  93         std::string ParamDescription() const override { return m_description; }
  94         std::string DefaultDescription() const override { return ""; }
  95         OPTION_BLOCK & Suboptions() override { return m_suboptions; }
  96         PARSER_STATE Parse(int argc, char ** argv, void * /*data*/) override;
  97
  98     private:
  99         COMMANDS & m_commands;
 100         std::string m_description;
 101         std::string m_argument;
 102         OPTION_BLOCK m_suboptions;
 103         std::map<std::string, std::string> m_params;
 104         API_FUNCTION m_funPtr;
 105 };
 106
 107 inline
 108 std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,
 109                        const std::string & paramDescription,
 110                        const std::vector<API_ACTION::PARAM> & params,
 111                        API_FUNCTION funPtr)
 112 {
 113 return std::make_unique<API_ACTION>(commands, paramDescription, true, params, funPtr);
 114 }
 115
 116 inline
 117 std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,
 118                        const std::vector<API_ACTION::PARAM> & params,
 119                        API_FUNCTION funPtr)
 120 {
 121 return std::make_unique<API_ACTION>(commands, "", false, params, funPtr);
 122 }
 123
 124 inline
 125 std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,
 126                        const std::string & paramDescription,
 127                        API_FUNCTION funPtr)
 128 {
 129 return std::make_unique<API_ACTION>(commands, paramDescription, true, funPtr);
 130 }
 131
 132 inline
 133 std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,
 134                        API_FUNCTION funPtr)
 135 {
 136 return std::make_unique<API_ACTION>(commands, "", false, funPtr);
 137 }
 138
 139 }
 140
 141 #endif