More stgTime cleanup.

[stg.git] / projects / sgconf / actions.h

diff --git a/projects/sgconf/actions.h b/projects/sgconf/actions.h
index c47f9776090b7adde79252cbb931bb26cde65cc7..3181a105a31ab2cc9adf0ca950e2ad8d37f75383 100644 (file)
--- a/projects/sgconf/actions.h
+++ b/projects/sgconf/actions.h
@@ -18,18 +18,19 @@
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 

-#ifndef __STG_SGCONF_ACTIONS_H__
-#define __STG_SGCONF_ACTIONS_H__
+#pragma once

 
 #include "action.h"
 #include "options.h"
 #include "parser_state.h"
 
 #include "stg/common.h"
 
 #include "action.h"
 #include "options.h"
 #include "parser_state.h"
 
 #include "stg/common.h"

-#include "stg/resetable.h"
+#include "stg/optional.h"

 
 #include <string>
 
 
 #include <string>
 

+#include <cassert>
+

 namespace SGCONF
 {
 
 namespace SGCONF
 {
 


@@ -46,7 +47,7 @@ class FUNC0_ACTION : public ACTION
         virtual std::string ParamDescription() const { return ""; }
         virtual std::string DefaultDescription() const { return ""; }
         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
         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, void * /*data*/)

         {
         m_func();
         return PARSER_STATE(true, argc, argv);
         {
         m_func();
         return PARSER_STATE(true, argc, argv);


@@ -68,7 +69,7 @@ template <typename T>
 class PARAM_ACTION : public ACTION
 {
     public:
 class PARAM_ACTION : public ACTION
 {
     public:

-        PARAM_ACTION(RESETABLE<T> & param,
+        PARAM_ACTION(STG::Optional<T> & param,

                      const T & defaultValue,
                      const std::string & paramDescription)
             : m_param(param),
                      const T & defaultValue,
                      const std::string & paramDescription)
             : m_param(param),


@@ -76,7 +77,11 @@ class PARAM_ACTION : public ACTION
               m_description(paramDescription),
               m_hasDefault(true)
         {}
               m_description(paramDescription),
               m_hasDefault(true)
         {}

-        PARAM_ACTION(RESETABLE<T> & param,
+        PARAM_ACTION(STG::Optional<T> & param)
+            : m_param(param),
+              m_hasDefault(false)
+        {}
+        PARAM_ACTION(STG::Optional<T> & param,

                      const std::string & paramDescription)
             : m_param(param),
               m_description(paramDescription),
                      const std::string & paramDescription)
             : m_param(param),
               m_description(paramDescription),


@@ -88,11 +93,11 @@ class PARAM_ACTION : public ACTION
         virtual std::string ParamDescription() const { return m_description; }
         virtual std::string DefaultDescription() const;
         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
         virtual std::string ParamDescription() const { return m_description; }
         virtual std::string DefaultDescription() const;
         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }

-        virtual PARSER_STATE Parse(int argc, char ** argv);
+        virtual PARSER_STATE Parse(int argc, char ** argv, void * /*data*/);

         virtual void ParseValue(const std::string & value);
 
     private:
         virtual void ParseValue(const std::string & value);
 
     private:

-        RESETABLE<T> & m_param;
+        STG::Optional<T> & m_param;

         T m_defaltValue;
         std::string m_description;
         bool m_hasDefault;
         T m_defaltValue;
         std::string m_description;
         bool m_hasDefault;


@@ -103,7 +108,7 @@ template <typename T>
 inline
 std::string PARAM_ACTION<T>::DefaultDescription() const
 {
 inline
 std::string PARAM_ACTION<T>::DefaultDescription() const
 {

-return m_hasDefault ? " (default: '" + x2str(m_defaltValue) + "')"
+return m_hasDefault ? " (default: '" + std::to_string(m_defaltValue) + "')"

                     : "";
 }
 
                     : "";
 }
 


@@ -117,7 +122,7 @@ return m_hasDefault ? " (default: '" + m_defaltValue + "')"
 
 template <typename T>
 inline
 
 template <typename T>
 inline

-PARSER_STATE PARAM_ACTION<T>::Parse(int argc, char ** argv)
+PARSER_STATE PARAM_ACTION<T>::Parse(int argc, char ** argv, void * /*data*/)

 {
 if (argc == 0 ||
     argv == NULL ||
 {
 if (argc == 0 ||
     argv == NULL ||


@@ -130,6 +135,14 @@ m_param = value;
 return PARSER_STATE(false, --argc, ++argv);
 }
 
 return PARSER_STATE(false, --argc, ++argv);
 }
 

+template <>
+inline
+PARSER_STATE PARAM_ACTION<bool>::Parse(int argc, char ** argv, void * /*data*/)
+{
+m_param = true;
+return PARSER_STATE(false, argc, argv);
+}
+

 template <typename T>
 inline
 void PARAM_ACTION<T>::ParseValue(const std::string & stringValue)
 template <typename T>
 inline
 void PARAM_ACTION<T>::ParseValue(const std::string & stringValue)


@@ -151,7 +164,7 @@ m_param = stringValue;
 
 template <>
 inline
 
 template <>
 inline

-PARSER_STATE PARAM_ACTION<std::string>::Parse(int argc, char ** argv)
+PARSER_STATE PARAM_ACTION<std::string>::Parse(int argc, char ** argv, void * /*data*/)

 {
 if (argc == 0 ||
     argv == NULL ||
 {
 if (argc == 0 ||
     argv == NULL ||


@@ -163,7 +176,7 @@ return PARSER_STATE(false, --argc, ++argv);
 
 template <typename T>
 inline
 
 template <typename T>
 inline

-PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
+PARAM_ACTION<T> * MakeParamAction(STG::Optional<T> & param,

                                   const T & defaultValue,
                                   const std::string & paramDescription)
 {
                                   const T & defaultValue,
                                   const std::string & paramDescription)
 {


@@ -172,7 +185,14 @@ return new PARAM_ACTION<T>(param, defaultValue, paramDescription);
 
 template <typename T>
 inline
 
 template <typename T>
 inline

-PARAM_ACTION<T> * MakeParamAction(RESETABLE<T> & param,
+PARAM_ACTION<T> * MakeParamAction(STG::Optional<T> & param)
+{
+return new PARAM_ACTION<T>(param);
+}
+
+template <typename T>
+inline
+PARAM_ACTION<T> * MakeParamAction(STG::Optional<T> & param,

                                   const std::string & paramDescription)
 {
 return new PARAM_ACTION<T>(param, paramDescription);
                                   const std::string & paramDescription)
 {
 return new PARAM_ACTION<T>(param, paramDescription);


@@ -182,10 +202,8 @@ class KV_ACTION : public ACTION
 {
     public:
         KV_ACTION(const std::string & name,
 {
     public:
         KV_ACTION(const std::string & name,

-                  std::map<std::string, std::string> & kvs,

                   const std::string & paramDescription)
             : m_name(name),
                   const std::string & paramDescription)
             : m_name(name),

-              m_kvs(kvs),

               m_description(paramDescription)
         {}
 
               m_description(paramDescription)
         {}
 


@@ -194,34 +212,32 @@ class KV_ACTION : public ACTION
         virtual std::string ParamDescription() const { return m_description; }
         virtual std::string DefaultDescription() const { return ""; }
         virtual OPTION_BLOCK & Suboptions() { return m_suboptions; }
         virtual std::string ParamDescription() const { return m_description; }
         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, void * data);

 
     private:
         std::string m_name;
 
     private:
         std::string m_name;

-        std::map<std::string, std::string> & m_kvs;

         std::string m_description;
         OPTION_BLOCK m_suboptions;
 };
 
 inline
         std::string m_description;
         OPTION_BLOCK m_suboptions;
 };
 
 inline

-PARSER_STATE KV_ACTION::Parse(int argc, char ** argv)
+PARSER_STATE KV_ACTION::Parse(int argc, char ** argv, void * data)

 {
 if (argc == 0 ||
     argv == NULL ||
     *argv == NULL)
     throw ERROR("Missing argument.");
 {
 if (argc == 0 ||
     argv == NULL ||
     *argv == NULL)
     throw ERROR("Missing argument.");

-m_kvs[m_name] = *argv;
+assert(data != NULL && "Expecting container pointer.");
+std::map<std::string, std::string> & kvs = *static_cast<std::map<std::string, std::string>*>(data);
+kvs[m_name] = *argv;

 return PARSER_STATE(false, --argc, ++argv);
 }
 
 inline
 KV_ACTION * MakeKVAction(const std::string & name,
 return PARSER_STATE(false, --argc, ++argv);
 }
 
 inline
 KV_ACTION * MakeKVAction(const std::string & name,

-                         std::map<std::string, std::string> & kvs,

                          const std::string & paramDescription)
 {
                          const std::string & paramDescription)
 {

-return new KV_ACTION(name, kvs, paramDescription);
+return new KV_ACTION(name, paramDescription);

 }
 
 } // namespace SGCONF
 }
 
 } // namespace SGCONF

-
-#endif