Implemented command line options parsing.

diff --git a/projects/sgconf/action.h b/projects/sgconf/action.h
index 469d746030b953860f51ac9119910bf1c90779c6..64d7c1e83e01ed6aceb653bde460c4157d182422 100644 (file)
--- a/projects/sgconf/action.h
+++ b/projects/sgconf/action.h
@@ -35,6 +35,7 @@ class ACTION
     public:
         virtual ~ACTION() {}
 
+        virtual ACTION * Clone() const = 0;
         virtual std::string ParamDescription() const = 0;
         virtual std::string DefaultDescription() const = 0;
         virtual OPTION_BLOCK & Suboptions() = 0;
@@ -48,6 +49,13 @@ class ACTION
         };
 };
 
+template <typename T>
+class ACTION_CLONE_MIXIN : public ACTION
+{
+    public:
+        virtual ACTION * Clone() const { return new T(*this); }
+};
+
 } // namespace SGCONF
 
 #endif

diff --git a/projects/sgconf/actions.cpp b/projects/sgconf/actions.cpp
index 742ff042e31fe8c8341bd4aa8384e1b4520aea00..afa51621cb2aa127f4679c830246ac06a328f5f0 100644 (file)
--- a/projects/sgconf/actions.cpp
+++ b/projects/sgconf/actions.cpp
@@ -17,14 +17,3 @@
 /*
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
-
-#include "actions.h"
-
-using SGCONF::FUNC0_ACTION;
-using SGCONF::PARSER_STATE;
-
-PARSER_STATE FUNC0_ACTION::Parse(int argc, char ** argv)
-{
-m_func();
-return PARSER_STATE(true, argc, argv);
-}

diff --git a/projects/sgconf/actions.h b/projects/sgconf/actions.h
index 739fbf14af85a886e753c1ddf96f1a46a055cd2e..886e17e2568619da73bcdaf31873c0698c93853a 100644 (file)
--- a/projects/sgconf/actions.h
+++ b/projects/sgconf/actions.h
@@ -35,29 +35,37 @@ namespace SGCONF
 
 typedef void (* FUNC0)();
 
+template <typename F>
 class FUNC0_ACTION : public ACTION
 {
     public:
-        FUNC0_ACTION(FUNC0 func) : m_func(func) {}
+        FUNC0_ACTION(const F & func) : m_func(func) {}
+
+        virtual ACTION * Clone() const { return new FUNC0_ACTION<F>(*this); }
 
         virtual std::string ParamDescription() const { return ""; }
         virtual std::string DefaultDescription() const { return ""; }
         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
-        virtual PARSER_STATE Parse(int argc, char ** argv);
+        virtual PARSER_STATE Parse(int argc, char ** argv)
+        {
+        m_func();
+        return PARSER_STATE(true, argc, argv);
+        }
 
     private:
-        FUNC0 m_func;
+        F m_func;
         OPTION_BLOCK m_suboptions;
 };
 
+template <typename F>
 inline
-FUNC0_ACTION * MakeFunc0Action(FUNC0 func)
+FUNC0_ACTION<F> * MakeFunc0Action(F func)
 {
-return new FUNC0_ACTION(func);
+return new FUNC0_ACTION<F>(func);
 }
 
 template <typename T>
-class PARAM_ACTION: public ACTION
+class PARAM_ACTION : public ACTION
 {
     public:
         PARAM_ACTION(RESETABLE<T> & param,
@@ -75,6 +83,8 @@ class PARAM_ACTION: public ACTION
               m_hasDefault(false)
         {}
 
+        virtual ACTION * Clone() const { return new PARAM_ACTION<T>(*this); }
+
         virtual std::string ParamDescription() const { return m_description; }
         virtual std::string DefaultDescription() const;
         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }

diff --git a/projects/sgconf/main.cpp b/projects/sgconf/main.cpp
index 8644e690ddd5dcd693c92730c7c4f225b6793e9d..a1c8df8f0fb8f85ab3dc26d7a0851db7ee416e00 100644 (file)
--- a/projects/sgconf/main.cpp
+++ b/projects/sgconf/main.cpp
@@ -65,6 +65,65 @@ struct ARRAY_TYPE<T[N]>
 typedef T type;
 };
 
+template <typename T>
+struct nullary_function
+{
+typedef T result_type;
+};
+
+template <typename F>
+class binder0 : public nullary_function<typename F::result_type>
+{
+    public:
+        binder0(const F & func, const typename F::argument_type & arg)
+            : m_func(func), m_arg(arg) {}
+        typename F::result_type operator()() const { return m_func(m_arg); }
+    private:
+        F m_func;
+        typename F::argument_type m_arg;
+};
+
+template <typename F>
+inline
+binder0<F> bind0(const F & func, const typename F::argument_type & arg)
+{
+return binder0<F>(func, arg);
+}
+
+template <typename C, typename A, typename R>
+class METHOD1_ADAPTER : public std::unary_function<A, R>
+{
+    public:
+        METHOD1_ADAPTER(R (C::* func)(A), C & obj) : m_func(func), m_obj(obj) {}
+        R operator()(A arg) { return (m_obj.*m_func)(arg); }
+    private:
+        R (C::* m_func)(A);
+        C & m_obj;
+};
+
+template <typename C, typename A, typename R>
+class CONST_METHOD1_ADAPTER : public std::unary_function<A, R>
+{
+    public:
+        CONST_METHOD1_ADAPTER(R (C::* func)(A) const, C & obj) : m_func(func), m_obj(obj) {}
+        R operator()(A arg) const { return (m_obj.*m_func)(arg); }
+    private:
+        R (C::* m_func)(A) const;
+        C & m_obj;
+};
+
+template <typename C, typename A, typename R>
+METHOD1_ADAPTER<C, A, R> Method1Adapt(R (C::* func)(A), C & obj)
+{
+return METHOD1_ADAPTER<C, A, R>(func, obj);
+}
+
+template <typename C, typename A, typename R>
+CONST_METHOD1_ADAPTER<C, A, R> Method1Adapt(R (C::* func)(A) const, C & obj)
+{
+return CONST_METHOD1_ADAPTER<C, A, R>(func, obj);
+}
+
 template <typename T>
 bool SetArrayItem(T & array, const char * index, const typename ARRAY_TYPE<T>::type & value)
 {
@@ -92,7 +151,7 @@ void Version();
 namespace SGCONF
 {
 
-class CONFIG_ACTION: public ACTION
+class CONFIG_ACTION : public ACTION
 {
     public:
         CONFIG_ACTION(CONFIG & config,
@@ -101,6 +160,8 @@ class CONFIG_ACTION: public ACTION
               m_description(paramDescription)
         {}
 
+        virtual ACTION * Clone() const { return new CONFIG_ACTION(*this); }
+
         virtual std::string ParamDescription() const { return m_description; }
         virtual std::string DefaultDescription() const { return ""; }
         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
@@ -1138,23 +1199,33 @@ return ProcessSetUser(req.server.data(), req.port.data(), req.admLogin.data(), r
 //-----------------------------------------------------------------------------
 int main(int argc, char **argv)
 {
-UsageAll();
-exit(0);
-
 SGCONF::CONFIG config;
 
-SGCONF::OPTION_BLOCK generalOptions;
-generalOptions.Add("c", "config", SGCONF::MakeParamAction(config.configFile, std::string("~/.config/stg/sgconf.conf"), "<config file>"), "override default config file");
-generalOptions.Add("h", "help", SGCONF::MakeFunc0Action(Usage), "show this help and exit");
-generalOptions.Add("help-all", SGCONF::MakeFunc0Action(UsageAll), "show full help and exit");
-generalOptions.Add("v", "version", SGCONF::MakeFunc0Action(Version), "show version information and exit");
-
-SGCONF::OPTION_BLOCK connOptions;
-connOptions.Add("s", "server", SGCONF::MakeParamAction(config.server, std::string("localhost"), "<address>"), "host to connect");
-connOptions.Add("p", "port", SGCONF::MakeParamAction(config.port, uint16_t(5555), "<port>"), "port to connect");
-connOptions.Add("u", "username", SGCONF::MakeParamAction(config.userName, std::string("admin"), "<username>"), "administrative login");
-connOptions.Add("w", "userpass", SGCONF::MakeParamAction(config.userPass, "<password>"), "password for the administrative login");
-connOptions.Add("a", "address", SGCONF::MakeParamAction(config, "<connection string>"), "connection params as a single string in format: <login>:<password>@<host>:<port>");
+SGCONF::OPTION_BLOCKS blocks;
+blocks.Add("General options")
+      .Add("c", "config", SGCONF::MakeParamAction(config.configFile, std::string("~/.config/stg/sgconf.conf"), "<config file>"), "override default config file")
+      .Add("h", "help", SGCONF::MakeFunc0Action(bind0(Method1Adapt(&SGCONF::OPTION_BLOCKS::Help, blocks), 0)), "\t\tshow this help and exit")
+      .Add("help-all", SGCONF::MakeFunc0Action(UsageAll), "\t\tshow full help and exit")
+      .Add("v", "version", SGCONF::MakeFunc0Action(Version), "\t\tshow version information and exit");
+blocks.Add("Connection options")
+      .Add("s", "server", SGCONF::MakeParamAction(config.server, std::string("localhost"), "<address>"), "\t\thost to connect")
+      .Add("p", "port", SGCONF::MakeParamAction(config.port, uint16_t(5555), "<port>"), "\t\tport to connect")
+      .Add("u", "username", SGCONF::MakeParamAction(config.userName, std::string("admin"), "<username>"), "\tadministrative login")
+      .Add("w", "userpass", SGCONF::MakeParamAction(config.userPass, "<password>"), "\tpassword for the administrative login")
+      .Add("a", "address", SGCONF::MakeParamAction(config, "<connection string>"), "connection params as a single string in format: <login>:<password>@<host>:<port>");
+
+SGCONF::PARSER_STATE state(blocks.Parse(--argc, ++argv)); // Skipping self name
+
+if (state.stop)
+    return 0;
+
+if (state.argc > 0)
+    {
+    std::cerr << "Unknown option: '" << *state.argv << "'\n";
+    return -1;
+    }
+
+return 0;
 
 if (argc < 2)
     {

diff --git a/projects/sgconf/options.cpp b/projects/sgconf/options.cpp
index 71f9687ce73ff9117e1f8463ae5f93997eaef509..06889174b0b2d7eb5aedb57f9c402ad0ce08fde1 100644 (file)
--- a/projects/sgconf/options.cpp
+++ b/projects/sgconf/options.cpp
@@ -29,6 +29,7 @@
 
 using SGCONF::OPTION;
 using SGCONF::OPTION_BLOCK;
+using SGCONF::OPTION_BLOCKS;
 using SGCONF::ACTION;
 using SGCONF::PARSER_STATE;
 
@@ -55,7 +56,7 @@ OPTION::OPTION(const std::string & longName,
 OPTION::OPTION(const OPTION & rhs)
     : m_shortName(rhs.m_shortName),
       m_longName(rhs.m_longName),
-      m_action(rhs.m_action),
+      m_action(rhs.m_action->Clone()),
       m_description(rhs.m_description)
 {
 }
@@ -106,26 +107,31 @@ catch (const ACTION::ERROR & ex)
     }
 }
 
-void OPTION_BLOCK::Add(const std::string & shortName,
-                       const std::string & longName,
-                       ACTION * action,
-                       const std::string & description)
+OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & shortName,
+                                 const std::string & longName,
+                                 ACTION * action,
+                                 const std::string & description)
 {
 m_options.push_back(OPTION(shortName, longName, action, description));
+return *this;
 }
 
-void OPTION_BLOCK::Add(const std::string & longName,
-                       ACTION * action,
-                       const std::string & description)
+OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & longName,
+                                 ACTION * action,
+                                 const std::string & description)
 {
 m_options.push_back(OPTION(longName, action, description));
+return *this;
 }
 
 void OPTION_BLOCK::Help(size_t level) const
 {
+if (m_options.empty())
+    return;
+std::cout << m_description << ":\n";
 std::for_each(m_options.begin(),
               m_options.end(),
-              std::bind2nd(std::mem_fun_ref(&OPTION::Help), level));
+              std::bind2nd(std::mem_fun_ref(&OPTION::Help), level + 1));
 }
 
 PARSER_STATE OPTION_BLOCK::Parse(int argc, char ** argv)
@@ -138,6 +144,30 @@ while (state.argc > 0 && !state.stop)
         state = it->Parse(--state.argc, ++state.argv);
     else
         break;
+    ++it;
+    }
+return state;
+}
+
+void OPTION_BLOCKS::Help(size_t level) const
+{
+std::list<OPTION_BLOCK>::const_iterator it(m_blocks.begin());
+while (it != m_blocks.end())
+    {
+    it->Help(level);
+    std::cout << "\n";
+    ++it;
+    }
+}
+
+PARSER_STATE OPTION_BLOCKS::Parse(int argc, char ** argv)
+{
+PARSER_STATE state(false, argc, argv);
+std::list<OPTION_BLOCK>::iterator it(m_blocks.begin());
+while (!state.stop && it != m_blocks.end())
+    {
+    state = it->Parse(state.argc, state.argv);
+    ++it;
     }
 return state;
 }

diff --git a/projects/sgconf/options.h b/projects/sgconf/options.h
index 696255ff6c58b28c8699e118398759fc8c16b40e..3d4bdd64263355211dcaf41ef5539506c777f40d 100644 (file)
--- a/projects/sgconf/options.h
+++ b/projects/sgconf/options.h
@@ -23,6 +23,7 @@
 
 #include <string>
 #include <vector>
+#include <list>
 #include <stdexcept>
 #include <cstddef> // size_t
 
@@ -68,13 +69,16 @@ class OPTION
 class OPTION_BLOCK
 {
     public:
-        void Add(const std::string & shortName,
-                 const std::string & longName,
-                 ACTION * action,
-                 const std::string & description);
-        void Add(const std::string & longName,
-                 ACTION * action,
-                 const std::string & description);
+        OPTION_BLOCK() {}
+        OPTION_BLOCK(const std::string & description)
+            : m_description(description) {}
+        OPTION_BLOCK & Add(const std::string & shortName,
+                           const std::string & longName,
+                           ACTION * action,
+                           const std::string & description);
+        OPTION_BLOCK & Add(const std::string & longName,
+                           ACTION * action,
+                           const std::string & description);
 
         void Help(size_t level) const;
 
@@ -82,6 +86,19 @@ class OPTION_BLOCK
 
     private:
         std::vector<OPTION> m_options;
+        std::string m_description;
+};
+
+class OPTION_BLOCKS
+{
+    public:
+        OPTION_BLOCK & Add(const std::string & description)
+        { m_blocks.push_back(OPTION_BLOCK(description)); return m_blocks.back(); }
+        void Help(size_t level) const;
+        PARSER_STATE Parse(int argc, char ** argv);
+
+    private:
+        std::list<OPTION_BLOCK> m_blocks;
 };
 
 } // namespace SGCONF