More std::jthread

diff --git a/projects/sgconf/action.h b/projects/sgconf/action.h
index 940ea7f6272673bad87ab08aa12819e8e86a602f..bd3555ed6125b3466be44943cd4375386d7bd813 100644 (file)
--- a/projects/sgconf/action.h
+++ b/projects/sgconf/action.h
@@ -18,8 +18,7 @@
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 

-#ifndef __STG_SGCONF_ACTION_H__
-#define __STG_SGCONF_ACTION_H__
+#pragma once

 
 #include <string>
 #include <map>
 
 #include <string>
 #include <map>


@@ -37,21 +36,17 @@ class ACTION
     public:
         virtual ~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;
         virtual PARSER_STATE Parse(int argc, char ** argv, void * data = NULL) = 0;
         virtual void ParseValue(const std::string &) {}
 
         virtual std::string ParamDescription() const = 0;
         virtual std::string DefaultDescription() const = 0;
         virtual OPTION_BLOCK & Suboptions() = 0;
         virtual PARSER_STATE Parse(int argc, char ** argv, void * data = NULL) = 0;
         virtual void ParseValue(const std::string &) {}
 

-        class ERROR : public std::runtime_error
+        struct ERROR : std::runtime_error

         {
         {

-            public:
-                ERROR(const std::string & message)
-                    : std::runtime_error(message.c_str()) {}
+            explicit ERROR(const std::string & message)
+                : std::runtime_error(message.c_str()) {}

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

-
-#endif

diff --git a/projects/sgconf/actions.h b/projects/sgconf/actions.h
index 3181a105a31ab2cc9adf0ca950e2ad8d37f75383..f23e566de1682c6ce7721646d34b300ea37761c6 100644 (file)
--- a/projects/sgconf/actions.h
+++ b/projects/sgconf/actions.h
@@ -40,17 +40,15 @@ template <typename F>
 class FUNC0_ACTION : public ACTION
 {
     public:
 class FUNC0_ACTION : public ACTION
 {
     public:

-        FUNC0_ACTION(const F & func) : m_func(func) {}
+        explicit 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, void * /*data*/)
+        std::string ParamDescription() const override { return ""; }
+        std::string DefaultDescription() const override { return ""; }
+        OPTION_BLOCK & Suboptions() override { return m_suboptions; }
+        PARSER_STATE Parse(int argc, char ** argv, void * /*data*/) override

         {
         {

-        m_func();
-        return PARSER_STATE(true, argc, argv);
+            m_func();
+            return PARSER_STATE(true, argc, argv);

         }
 
     private:
         }
 
     private:


@@ -60,9 +58,9 @@ class FUNC0_ACTION : public ACTION
 
 template <typename F>
 inline
 
 template <typename F>
 inline

-FUNC0_ACTION<F> * MakeFunc0Action(F func)
+std::unique_ptr<ACTION> MakeFunc0Action(F func)

 {
 {

-return new FUNC0_ACTION<F>(func);
+return std::make_unique<FUNC0_ACTION<F>>(func);

 }
 
 template <typename T>
 }
 
 template <typename T>


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

-        PARAM_ACTION(STG::Optional<T> & param)
+        explicit PARAM_ACTION(STG::Optional<T> & param)

             : m_param(param),
               m_hasDefault(false)
         {}
             : m_param(param),
               m_hasDefault(false)
         {}


@@ -88,13 +86,11 @@ class PARAM_ACTION : public ACTION
               m_hasDefault(false)
         {}
 
               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; }
-        virtual PARSER_STATE Parse(int argc, char ** argv, void * /*data*/);
-        virtual void ParseValue(const std::string & value);
+        std::string ParamDescription() const override { return m_description; }
+        std::string DefaultDescription() const override;
+        OPTION_BLOCK & Suboptions() override { return m_suboptions; }
+        PARSER_STATE Parse(int argc, char ** argv, void * /*data*/) override;
+        void ParseValue(const std::string & value) override;

 
     private:
         STG::Optional<T> & m_param;
 
     private:
         STG::Optional<T> & m_param;


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

-PARAM_ACTION<T> * MakeParamAction(STG::Optional<T> & param,
-                                  const T & defaultValue,
-                                  const std::string & paramDescription)
+std::unique_ptr<ACTION> MakeParamAction(STG::Optional<T> & param,
+                                        const T & defaultValue,
+                                        const std::string & paramDescription)

 {
 {

-return new PARAM_ACTION<T>(param, defaultValue, paramDescription);
+return std::make_unique<PARAM_ACTION<T>>(param, defaultValue, paramDescription);

 }
 
 template <typename T>
 inline
 }
 
 template <typename T>
 inline

-PARAM_ACTION<T> * MakeParamAction(STG::Optional<T> & param)
+std::unique_ptr<ACTION> MakeParamAction(STG::Optional<T> & param)

 {
 {

-return new PARAM_ACTION<T>(param);
+return std::make_unique<PARAM_ACTION<T>>(param);

 }
 
 template <typename T>
 inline
 }
 
 template <typename T>
 inline

-PARAM_ACTION<T> * MakeParamAction(STG::Optional<T> & param,
-                                  const std::string & paramDescription)
+std::unique_ptr<ACTION> MakeParamAction(STG::Optional<T> & param,
+                                        const std::string & paramDescription)

 {
 {

-return new PARAM_ACTION<T>(param, paramDescription);
+return std::make_unique<PARAM_ACTION<T>>(param, paramDescription);

 }
 
 class KV_ACTION : public ACTION
 }
 
 class KV_ACTION : public ACTION


@@ -207,12 +203,10 @@ class KV_ACTION : public ACTION
               m_description(paramDescription)
         {}
 
               m_description(paramDescription)
         {}
 

-        virtual ACTION * Clone() const { return new KV_ACTION(*this); }
-
-        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, void * data);
+        std::string ParamDescription() const override { return m_description; }
+        std::string DefaultDescription() const override { return ""; }
+        OPTION_BLOCK & Suboptions() override { return m_suboptions; }
+        PARSER_STATE Parse(int argc, char ** argv, void * data) override;

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


@@ -234,10 +228,10 @@ return PARSER_STATE(false, --argc, ++argv);
 }
 
 inline
 }
 
 inline

-KV_ACTION * MakeKVAction(const std::string & name,
-                         const std::string & paramDescription)
+std::unique_ptr<ACTION> MakeKVAction(const std::string & name,
+                                     const std::string & paramDescription)

 {
 {

-return new KV_ACTION(name, paramDescription);
+return std::make_unique<KV_ACTION>(name, paramDescription);

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

diff --git a/projects/sgconf/api_action.h b/projects/sgconf/api_action.h
index f27715ca5f58bf65b042f8591796a71f5bbc185f..7fc22bcad40c57b18b0ac05c68be953ce28fd1c4 100644 (file)
--- a/projects/sgconf/api_action.h
+++ b/projects/sgconf/api_action.h
@@ -90,12 +90,10 @@ class API_ACTION : public ACTION
               m_funPtr(funPtr)
         {}
 
               m_funPtr(funPtr)
         {}
 

-        virtual ACTION * Clone() const { return new API_ACTION(*this); }
-
-        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, void * /*data*/);
+        std::string ParamDescription() const override { return m_description; }
+        std::string DefaultDescription() const override { return ""; }
+        OPTION_BLOCK & Suboptions() override { return m_suboptions; }
+        PARSER_STATE Parse(int argc, char ** argv, void * /*data*/) override;

 
     private:
         COMMANDS & m_commands;
 
     private:
         COMMANDS & m_commands;


@@ -107,35 +105,35 @@ class API_ACTION : public ACTION
 };
 
 inline
 };
 
 inline

-ACTION * MakeAPIAction(COMMANDS & commands,
+std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,

                        const std::string & paramDescription,
                        const std::vector<API_ACTION::PARAM> & params,
                        API_FUNCTION funPtr)
 {
                        const std::string & paramDescription,
                        const std::vector<API_ACTION::PARAM> & params,
                        API_FUNCTION funPtr)
 {

-return new API_ACTION(commands, paramDescription, true, params, funPtr);
+return std::make_unique<API_ACTION>(commands, paramDescription, true, params, funPtr);

 }
 
 inline
 }
 
 inline

-ACTION * MakeAPIAction(COMMANDS & commands,
+std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,

                        const std::vector<API_ACTION::PARAM> & params,
                        API_FUNCTION funPtr)
 {
                        const std::vector<API_ACTION::PARAM> & params,
                        API_FUNCTION funPtr)
 {

-return new API_ACTION(commands, "", false, params, funPtr);
+return std::make_unique<API_ACTION>(commands, "", false, params, funPtr);

 }
 
 inline
 }
 
 inline

-ACTION * MakeAPIAction(COMMANDS & commands,
+std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,

                        const std::string & paramDescription,
                        API_FUNCTION funPtr)
 {
                        const std::string & paramDescription,
                        API_FUNCTION funPtr)
 {

-return new API_ACTION(commands, paramDescription, true, funPtr);
+return std::make_unique<API_ACTION>(commands, paramDescription, true, funPtr);

 }
 
 inline
 }
 
 inline

-ACTION * MakeAPIAction(COMMANDS & commands,
+std::unique_ptr<ACTION> MakeAPIAction(COMMANDS & commands,

                        API_FUNCTION funPtr)
 {
                        API_FUNCTION funPtr)
 {

-return new API_ACTION(commands, "", false, funPtr);
+return std::make_unique<API_ACTION>(commands, "", false, funPtr);

 }
 
 }
 }
 
 }

diff --git a/projects/sgconf/main.cpp b/projects/sgconf/main.cpp
index 979081953464c40316b60c8b9708bef2098499a5..3413dbd9177cb74e71ff6275605a1e0cb7c5b806 100644 (file)
--- a/projects/sgconf/main.cpp
+++ b/projects/sgconf/main.cpp
@@ -73,7 +73,7 @@ template <typename A, typename R>
 class FUNC1_ADAPTER : public std::unary_function<A, R>
 {
     public:
 class FUNC1_ADAPTER : public std::unary_function<A, R>
 {
     public:

-        FUNC1_ADAPTER(R (*func)(A)) : m_func(func) {}
+        explicit FUNC1_ADAPTER(R (*func)(A)) : m_func(func) {}

         const R operator()(A arg) const { return (m_func)(arg); }
     private:
         R (*m_func)(A);
         const R operator()(A arg) const { return (m_func)(arg); }
     private:
         R (*m_func)(A);


@@ -160,12 +160,10 @@ class CONFIG_ACTION : public ACTION
               m_description(paramDescription)
         {}
 
               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; }
-        virtual PARSER_STATE Parse(int argc, char ** argv, void * /*data*/);
+        std::string ParamDescription() const override { return m_description; }
+        std::string DefaultDescription() const override { return ""; }
+        OPTION_BLOCK & Suboptions() override { return m_suboptions; }
+        PARSER_STATE Parse(int argc, char ** argv, void * /*data*/) override;

 
     private:
         SGCONF::CONFIG & m_config;
 
     private:
         SGCONF::CONFIG & m_config;


@@ -227,11 +225,10 @@ else
     }
 }
 
     }
 }
 

-inline
-CONFIG_ACTION * MakeParamAction(SGCONF::CONFIG & config,
-                                const std::string & paramDescription)
+std::unique_ptr<SGCONF::ACTION> MakeParamAction(SGCONF::CONFIG & config,
+                                                const std::string & paramDescription)

 {
 {

-return new CONFIG_ACTION(config, paramDescription);
+return std::make_unique<CONFIG_ACTION>(config, paramDescription);

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

diff --git a/projects/sgconf/options.cpp b/projects/sgconf/options.cpp
index e431bcb05a651d5739010d432fe44210eeca0a20..06378d1c0a60376afda4b2ec6de28f17fbd1a45e 100644 (file)
--- a/projects/sgconf/options.cpp
+++ b/projects/sgconf/options.cpp
@@ -39,26 +39,26 @@ namespace
 template <class C>
 void ReadConfigFile(const std::string & filePath, void (C::* callback)(const std::string&, const std::string&), C * obj)
 {
 template <class C>
 void ReadConfigFile(const std::string & filePath, void (C::* callback)(const std::string&, const std::string&), C * obj)
 {

-std::ifstream stream(filePath.c_str());
-std::string line;
-size_t num = 0;
-while (std::getline(stream, line))
+    std::ifstream stream(filePath.c_str());
+    std::string line;
+    size_t num = 0;
+    while (std::getline(stream, line))

     {
     {

-    ++num;
-    line = Trim(line);
-    std::string::size_type pos = line.find_first_of('#');
-    if (pos != std::string::npos)
-        line = line.substr(0, pos);
-    if (line.empty())
-        continue;
-    pos = line.find_first_of('=');
-    if (pos == std::string::npos)
+        ++num;
+        line = Trim(line);
+        std::string::size_type pos = line.find_first_of('#');
+        if (pos != std::string::npos)
+            line = line.substr(0, pos);
+        if (line.empty())
+            continue;
+        pos = line.find_first_of('=');
+        if (pos == std::string::npos)

         {
         {

-        std::ostringstream error;
-        error << "Bad file format, missing '=' in '" << filePath << ":" << num << "'.";
-        throw std::runtime_error(error.str().c_str());
+            std::ostringstream error;
+            error << "Bad file format, missing '=' in '" << filePath << ":" << num << "'.";
+            throw std::runtime_error(error.str().c_str());

         }
         }

-    (obj->*callback)(Trim(line.substr(0, pos)), Trim(line.substr(pos + 1, line.length() - pos - 1)));
+        (obj->*callback)(Trim(line.substr(0, pos)), Trim(line.substr(pos + 1, line.length() - pos - 1)));

     }
 }
 
     }
 }
 


@@ -72,184 +72,157 @@ using SGCONF::PARSER_STATE;
 
 OPTION::OPTION(const std::string & shortName,
                const std::string & longName,
 
 OPTION::OPTION(const std::string & shortName,
                const std::string & longName,

-               ACTION * action,
+               std::unique_ptr<ACTION> action,

                const std::string & description)
     : m_shortName(shortName),
       m_longName(longName),
                const std::string & description)
     : m_shortName(shortName),
       m_longName(longName),

-      m_action(action),
+      m_action(std::move(action)),

       m_description(description)
 {
 }
 
 OPTION::OPTION(const std::string & longName,
       m_description(description)
 {
 }
 
 OPTION::OPTION(const std::string & longName,

-               ACTION * action,
+               std::unique_ptr<ACTION> action,

                const std::string & description)
     : m_longName(longName),
                const std::string & description)
     : m_longName(longName),

-      m_action(action),
+      m_action(std::move(action)),

       m_description(description)
 {
 }
 
       m_description(description)
 {
 }
 

-OPTION::OPTION(const OPTION & rhs)
-    : m_shortName(rhs.m_shortName),
-      m_longName(rhs.m_longName),
-      m_action(rhs.m_action->Clone()),
-      m_description(rhs.m_description)
-{
-}
-
-OPTION::~OPTION()
-{
-delete m_action;
-}
-
-OPTION & OPTION::operator=(const OPTION & rhs)
-{
-m_shortName = rhs.m_shortName;
-m_longName = rhs.m_longName;
-m_action = rhs.m_action->Clone();
-m_description = rhs.m_description;
-return *this;
-}
-

 void OPTION::Help(size_t level) const
 {
 void OPTION::Help(size_t level) const
 {

-if (!m_action)
-    throw ERROR("Option is not defined.");
-std::string indent(level, '\t');
-std::cout << indent;
-if (!m_shortName.empty())
-    std::cout << "-" << m_shortName << ", ";
-std::cout << "--" << m_longName << " " << m_action->ParamDescription()
-          << "\t" << m_description << m_action->DefaultDescription() << "\n";
-m_action->Suboptions().Help(level);
+    if (!m_action)
+        throw ERROR("Option is not defined.");
+    std::string indent(level, '\t');
+    std::cout << indent;
+    if (!m_shortName.empty())
+        std::cout << "-" << m_shortName << ", ";
+    std::cout << "--" << m_longName << " " << m_action->ParamDescription()
+              << "\t" << m_description << m_action->DefaultDescription() << "\n";
+    m_action->Suboptions().Help(level);

 }
 
 bool OPTION::Check(const char * arg) const
 {
 }
 
 bool OPTION::Check(const char * arg) const
 {

-if (arg == NULL)
-    return false;
+    if (arg == NULL)
+        return false;

 
 

-if (*arg++ != '-')
-    return false;
+    if (*arg++ != '-')
+        return false;

 
 

-if (*arg == '-')
-{
-    return m_longName == arg + 1;
-}
+    if (*arg == '-')
+        return m_longName == arg + 1;

 
 

-return m_shortName == arg;
+    return m_shortName == arg;

 }
 
 PARSER_STATE OPTION::Parse(int argc, char ** argv, void * data)
 {
 }
 
 PARSER_STATE OPTION::Parse(int argc, char ** argv, void * data)
 {

-if (!m_action)
-    throw ERROR("Option is not defined.");
-try
+    if (!m_action)
+        throw ERROR("Option is not defined.");
+    try

     {
     {

-    return m_action->Parse(argc, argv, data);
+        return m_action->Parse(argc, argv, data);

     }
     }

-catch (const ACTION::ERROR & ex)
+    catch (const ACTION::ERROR & ex)

     {
     {

-    if (m_longName.empty())
-        throw ERROR("-" + m_shortName + ": " + ex.what());
-    else
-        throw m_shortName.empty() ? ERROR("--" + m_longName + ": " + ex.what())
-                                  : ERROR("--" + m_longName + ", -" + m_shortName + ": " + ex.what());
+        if (m_longName.empty())
+            throw ERROR("-" + m_shortName + ": " + ex.what());
+        else
+            throw m_shortName.empty() ? ERROR("--" + m_longName + ": " + ex.what())
+                                      : ERROR("--" + m_longName + ", -" + m_shortName + ": " + ex.what());

     }
 }
 
 void OPTION::ParseValue(const std::string & value)
 {
     }
 }
 
 void OPTION::ParseValue(const std::string & value)
 {

-if (!m_action)
-    throw ERROR("Option is not defined.");
-try
+    if (!m_action)
+        throw ERROR("Option is not defined.");
+    try

     {
     {

-    return m_action->ParseValue(value);
+        return m_action->ParseValue(value);

     }
     }

-catch (const ACTION::ERROR & ex)
+    catch (const ACTION::ERROR & ex)

     {
     {

-    throw ERROR(m_longName + ": " + ex.what());
+        throw ERROR(m_longName + ": " + ex.what());

     }
 }
 
 OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & shortName,
                                  const std::string & longName,
     }
 }
 
 OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & shortName,
                                  const std::string & longName,

-                                 ACTION * action,
+                                 std::unique_ptr<ACTION> action,

                                  const std::string & description)
 {
                                  const std::string & description)
 {

-m_options.push_back(OPTION(shortName, longName, action, description));
-return *this;
+    m_options.emplace_back(shortName, longName, std::move(action), description);
+    return *this;

 }
 
 OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & longName,
 }
 
 OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & longName,

-                                 ACTION * action,
+                                 std::unique_ptr<ACTION> action,

                                  const std::string & description)
 {
                                  const std::string & description)
 {

-m_options.push_back(OPTION(longName, action, description));
-return *this;
+    m_options.emplace_back(longName, std::move(action), description);
+    return *this;

 }
 
 void OPTION_BLOCK::Help(size_t level) const
 {
 }
 
 void OPTION_BLOCK::Help(size_t level) const
 {

-if (m_options.empty())
-    return;
-if (!m_description.empty())
-    std::cout << m_description << ":\n";
-std::for_each(m_options.begin(),
-              m_options.end(),
-              [&level](const auto& opt){ opt.Help(level + 1); });
+    if (m_options.empty())
+        return;
+    if (!m_description.empty())
+        std::cout << m_description << ":\n";
+    for (const auto& option : m_options)
+        option.Help(level + 1);

 }
 
 PARSER_STATE OPTION_BLOCK::Parse(int argc, char ** argv, void * data)
 {
 }
 
 PARSER_STATE OPTION_BLOCK::Parse(int argc, char ** argv, void * data)
 {

-PARSER_STATE state(false, argc, argv);
-if (state.argc == 0)
-    return state;
-while (state.argc > 0 && !state.stop)
+    PARSER_STATE state(false, argc, argv);
+    if (state.argc == 0)
+        return state;
+    while (state.argc > 0 && !state.stop)

     {
     {

-    const auto it = std::find_if(m_options.begin(), m_options.end(), [&state](const auto& opt){ return opt.Check(*state.argv); });
-    if (it != m_options.end())
-        state = it->Parse(--state.argc, ++state.argv, data);
-    else
-        break;
+        const auto it = std::find_if(m_options.begin(), m_options.end(), [&state](const auto& opt){ return opt.Check(*state.argv); });
+        if (it != m_options.end())
+            state = it->Parse(--state.argc, ++state.argv, data);
+        else
+            break;

     }
     }

-return state;
+    return state;

 }
 
 void OPTION_BLOCK::ParseFile(const std::string & filePath)
 {
 }
 
 void OPTION_BLOCK::ParseFile(const std::string & filePath)
 {

-if (access(filePath.c_str(), R_OK))
-    throw ERROR("File '" + filePath + "' does not exists.");
-ReadConfigFile(filePath, &OPTION_BLOCK::OptionCallback, this);
+    if (access(filePath.c_str(), R_OK))
+        throw ERROR("File '" + filePath + "' does not exists.");
+    ReadConfigFile(filePath, &OPTION_BLOCK::OptionCallback, this);

 }
 
 void OPTION_BLOCK::OptionCallback(const std::string & key, const std::string & value)
 {
 }
 
 void OPTION_BLOCK::OptionCallback(const std::string & key, const std::string & value)
 {

-for (std::vector<OPTION>::iterator it = m_options.begin(); it != m_options.end(); ++it)
-    if (it->Name() == key)
-        it->ParseValue(value);
+    for (auto& option : m_options)
+        if (option.Name() == key)
+            option.ParseValue(value);

 }
 
 void OPTION_BLOCKS::Help(size_t level) const
 {
 }
 
 void OPTION_BLOCKS::Help(size_t level) const
 {

-std::list<OPTION_BLOCK>::const_iterator it(m_blocks.begin());
-while (it != m_blocks.end())
+    for (const auto& block : m_blocks)

     {
     {

-    it->Help(level);
-    std::cout << "\n";
-    ++it;
+        block.Help(level);
+        std::cout << "\n";

     }
 }
 
 PARSER_STATE OPTION_BLOCKS::Parse(int argc, char ** argv)
 {
     }
 }
 
 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.argc > 0 && !state.stop && it != m_blocks.end())
+    PARSER_STATE state(false, argc, argv);
+    auto it = m_blocks.begin();
+    while (state.argc > 0 && !state.stop && it != m_blocks.end())

     {
     {

-    state = it->Parse(state.argc, state.argv);
-    ++it;
+        state = it->Parse(state.argc, state.argv);
+        ++it;

     }
     }

-return state;
+    return state;

 }
 }

diff --git a/projects/sgconf/options.h b/projects/sgconf/options.h
index c00707bf2d0887d0e7a279f0125eaeecf47e1071..012b5167146fd0259742bfd5b276d83d1cd9f4e7 100644 (file)
--- a/projects/sgconf/options.h
+++ b/projects/sgconf/options.h
@@ -18,14 +18,13 @@
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 
  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  */
 

-#ifndef __STG_SGCONF_OPTIONS_H__
-#define __STG_SGCONF_OPTIONS_H__
+#pragma once

 
 #include <string>
 #include <vector>
 
 #include <string>
 #include <vector>

-#include <list>

 #include <utility>
 #include <stdexcept>
 #include <utility>
 #include <stdexcept>

+#include <memory>

 #include <cstddef> // size_t
 
 namespace SGCONF
 #include <cstddef> // size_t
 
 namespace SGCONF


@@ -39,15 +38,14 @@ class OPTION
     public:
         OPTION(const std::string & shortName,
                const std::string & longName,
     public:
         OPTION(const std::string & shortName,
                const std::string & longName,

-               ACTION * action,
+               std::unique_ptr<ACTION> action,

                const std::string & description);
         OPTION(const std::string & longName,
                const std::string & description);
         OPTION(const std::string & longName,

-               ACTION * action,
+               std::unique_ptr<ACTION> action,

                const std::string & description);
                const std::string & description);

-        OPTION(const OPTION & rhs);
-        ~OPTION();

 
 

-        OPTION & operator=(const OPTION & rhs);
+        OPTION(OPTION&& rhs) = default;
+        OPTION& operator=(OPTION& rhs) = default;

 
         void Help(size_t level = 0) const;
         PARSER_STATE Parse(int argc, char ** argv, void * data);
 
         void Help(size_t level = 0) const;
         PARSER_STATE Parse(int argc, char ** argv, void * data);


@@ -55,17 +53,16 @@ class OPTION
         bool Check(const char * arg) const;
         const std::string & Name() const { return m_longName; }
 
         bool Check(const char * arg) const;
         const std::string & Name() const { return m_longName; }
 

-        class ERROR : public std::runtime_error
+        struct ERROR : std::runtime_error

         {
         {

-            public:
-                ERROR(const std::string & message)
-                    : std::runtime_error(message.c_str()) {}
+            explicit ERROR(const std::string & message)
+                : std::runtime_error(message.c_str()) {}

         };
 
     private:
         std::string m_shortName;
         std::string m_longName;
         };
 
     private:
         std::string m_shortName;
         std::string m_longName;

-        ACTION * m_action;
+        std::unique_ptr<ACTION> m_action;

         std::string m_description;
 };
 
         std::string m_description;
 };
 


@@ -73,14 +70,18 @@ class OPTION_BLOCK
 {
     public:
         OPTION_BLOCK() {}
 {
     public:
         OPTION_BLOCK() {}

-        OPTION_BLOCK(const std::string & description)
+        explicit OPTION_BLOCK(const std::string & description)

             : m_description(description) {}
             : m_description(description) {}

+
+        OPTION_BLOCK(OPTION_BLOCK&&) = default;
+        OPTION_BLOCK& operator=(OPTION_BLOCK&&) = default;
+

         OPTION_BLOCK & Add(const std::string & shortName,
                            const std::string & longName,
         OPTION_BLOCK & Add(const std::string & shortName,
                            const std::string & longName,

-                           ACTION * action,
+                           std::unique_ptr<ACTION> action,

                            const std::string & description);
         OPTION_BLOCK & Add(const std::string & longName,
                            const std::string & description);
         OPTION_BLOCK & Add(const std::string & longName,

-                           ACTION * action,
+                           std::unique_ptr<ACTION> action,

                            const std::string & description);
 
         void Help(size_t level) const;
                            const std::string & description);
 
         void Help(size_t level) const;


@@ -88,11 +89,10 @@ class OPTION_BLOCK
         PARSER_STATE Parse(int argc, char ** argv, void * data = NULL);
         void ParseFile(const std::string & filePath);
 
         PARSER_STATE Parse(int argc, char ** argv, void * data = NULL);
         void ParseFile(const std::string & filePath);
 

-        class ERROR : public std::runtime_error
+        struct ERROR : std::runtime_error

         {
         {

-            public:
-                ERROR(const std::string & message)
-                    : std::runtime_error(message.c_str()) {}
+            explicit ERROR(const std::string & message)
+                : std::runtime_error(message.c_str()) {}

         };
 
     private:
         };
 
     private:


@@ -107,14 +107,12 @@ class OPTION_BLOCKS
     public:
         OPTION_BLOCK & Add(const std::string & description)
         { m_blocks.push_back(OPTION_BLOCK(description)); return m_blocks.back(); }
     public:
         OPTION_BLOCK & Add(const std::string & description)
         { m_blocks.push_back(OPTION_BLOCK(description)); return m_blocks.back(); }

-        void Add(const OPTION_BLOCK & block) { m_blocks.push_back(block); }
+        void Add(OPTION_BLOCK&& block) { m_blocks.push_back(std::move(block)); }

         void Help(size_t level) const;
         PARSER_STATE Parse(int argc, char ** argv);
 
     private:
         void Help(size_t level) const;
         PARSER_STATE Parse(int argc, char ** argv);
 
     private:

-        std::list<OPTION_BLOCK> m_blocks;
+        std::vector<OPTION_BLOCK> m_blocks;

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

-
-#endif

diff --git a/projects/stargazer/actions.h b/projects/stargazer/actions.h
index 33c9a8fdb4b57e282ddb832f4d075cbddf727e1c..360a56e1903c504476c85531ba61417ad068bf20 100644 (file)
--- a/projects/stargazer/actions.h
+++ b/projects/stargazer/actions.h
@@ -1,5 +1,4 @@
-#ifndef __ACTIONS_H__
-#define __ACTIONS_H__
+#pragma once

 
 // Usage:
 //
 
 // Usage:
 //


@@ -21,7 +20,7 @@
 template <class ACTIVE_CLASS, typename DATA_TYPE>
 struct ACTOR
 {
 template <class ACTIVE_CLASS, typename DATA_TYPE>
 struct ACTOR
 {

-typedef void (ACTIVE_CLASS::*TYPE)(DATA_TYPE);
+    using TYPE = void (ACTIVE_CLASS::*)(DATA_TYPE);

 };
 
 // Abstract base action class for polymorphic action invocation
 };
 
 // Abstract base action class for polymorphic action invocation


@@ -34,15 +33,17 @@ public:
 
 // Concrete generalized action type - an actor with it's data and owner
 template <class ACTIVE_CLASS, typename DATA_TYPE>
 
 // Concrete generalized action type - an actor with it's data and owner
 template <class ACTIVE_CLASS, typename DATA_TYPE>

-class ACTION : public BASE_ACTION,
-               public std::unary_function<ACTIVE_CLASS &, void>
+class ACTION : public BASE_ACTION

 {
 public:
     ACTION(ACTIVE_CLASS & ac,
            typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
            DATA_TYPE d)
         : activeClass(ac), actor(a), data(d) {}
 {
 public:
     ACTION(ACTIVE_CLASS & ac,
            typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
            DATA_TYPE d)
         : activeClass(ac), actor(a), data(d) {}

-    void Invoke() override;
+    void Invoke() override
+    {
+        (activeClass.*actor)(data);
+    }

 private:
     ACTION(const ACTION<ACTIVE_CLASS, DATA_TYPE> & rvalue);
     ACTION<ACTIVE_CLASS, DATA_TYPE> & operator=(const ACTION<ACTIVE_CLASS, DATA_TYPE> & rvalue);
 private:
     ACTION(const ACTION<ACTIVE_CLASS, DATA_TYPE> & rvalue);
     ACTION<ACTIVE_CLASS, DATA_TYPE> & operator=(const ACTION<ACTIVE_CLASS, DATA_TYPE> & rvalue);


@@ -54,37 +55,42 @@ private:
 
 // A list of an actions
 // All methods are thread-safe
 
 // A list of an actions
 // All methods are thread-safe

-class ACTIONS_LIST : private std::vector<BASE_ACTION *>
+class ACTIONS_LIST

 {
 public:
 {
 public:

-    // Just a typedef for parent class
-    typedef std::vector<BASE_ACTION *> parent;
+    ~ACTIONS_LIST()
+    {
+        std::lock_guard lock(m_mutex);
+        for (auto action : m_list)
+            delete action;
+    }

 
 

-    // Initialize mutex
-    ACTIONS_LIST();
-    // Delete actions and destroy mutex
-    virtual ~ACTIONS_LIST();
+    auto begin() { std::lock_guard lock(m_mutex); return m_list.begin(); }
+    auto end() { std::lock_guard lock(m_mutex); return m_list.end(); }
+    auto begin() const { std::lock_guard lock(m_mutex); return m_list.begin(); }
+    auto end() const { std::lock_guard lock(m_mutex); return m_list.end(); }

 
 

-    parent::iterator begin();
-    parent::iterator end();
-    parent::const_iterator begin() const;
-    parent::const_iterator end() const;
-
-    bool empty() const;
-    size_t size() const;
-    void swap(ACTIONS_LIST & list);
+    bool empty() const { std::lock_guard lock(m_mutex); return m_list.empty(); }
+    size_t size() const { std::lock_guard lock(m_mutex); return m_list.size(); }
+    void swap(ACTIONS_LIST & rhs) { std::lock_guard lock(m_mutex); m_list.swap(rhs.m_list); }

 
     // Add an action to list
     template <class ACTIVE_CLASS, typename DATA_TYPE>
     void Enqueue(ACTIVE_CLASS & ac,
                  typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
 
     // Add an action to list
     template <class ACTIVE_CLASS, typename DATA_TYPE>
     void Enqueue(ACTIVE_CLASS & ac,
                  typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,

-                 DATA_TYPE d);
+                 DATA_TYPE d)
+    {
+        std::lock_guard lock(m_mutex);
+        m_list.push_back(new ACTION<ACTIVE_CLASS, DATA_TYPE>(ac, a, d));
+    }

     // Invoke all actions in the list
     // Invoke all actions in the list

-    void InvokeAll();
+    void InvokeAll()
+    {
+        std::lock_guard lock(m_mutex);
+        for (auto action : m_list)
+            action->Invoke();
+    }

 private:
     mutable std::mutex m_mutex;
 private:
     mutable std::mutex m_mutex;

+    std::vector<BASE_ACTION*> m_list;

 };
 };

-
-#include "actions.inl.h"
-
-#endif

diff --git a/projects/stargazer/actions.inl.h b/projects/stargazer/actions.inl.h
deleted file mode 100644 (file)
index 7a0bac3..0000000
--- a/projects/stargazer/actions.inl.h
+++ /dev/null
@@ -1,101 +0,0 @@
-#ifndef __ACTIONS_INL_H__
-#define __ACTIONS_INL_H__
-
-#include <algorithm>
-
-#include "stg/locker.h"
-
-// Polymorphick action invocation
-template <class ACTIVE_CLASS, typename DATA_TYPE>
-inline
-void ACTION<ACTIVE_CLASS, DATA_TYPE>::Invoke()
-{
-(activeClass.*actor)(data);
-}
-
-inline
-ACTIONS_LIST::ACTIONS_LIST()
-{
-}
-
-// Delete all actions before deleting list
-inline
-ACTIONS_LIST::~ACTIONS_LIST()
-{
-std::lock_guard lock(m_mutex);
-
-parent::iterator it(parent::begin());
-while (it != parent::end())
-    delete *it++;
-}
-
-inline
-ACTIONS_LIST::parent::iterator ACTIONS_LIST::begin()
-{
-std::lock_guard lock(m_mutex);
-return parent::begin();
-}
-
-inline
-ACTIONS_LIST::parent::iterator ACTIONS_LIST::end()
-{
-std::lock_guard lock(m_mutex);
-return parent::end();
-}
-
-inline
-ACTIONS_LIST::parent::const_iterator ACTIONS_LIST::begin() const
-{
-std::lock_guard lock(m_mutex);
-return parent::begin();
-}
-
-inline
-ACTIONS_LIST::parent::const_iterator ACTIONS_LIST::end() const
-{
-std::lock_guard lock(m_mutex);
-return parent::end();
-}
-
-inline
-bool ACTIONS_LIST::empty() const
-{
-std::lock_guard lock(m_mutex);
-return parent::empty();
-}
-
-inline
-size_t ACTIONS_LIST::size() const
-{
-std::lock_guard lock(m_mutex);
-return parent::size();
-}
-
-inline
-void ACTIONS_LIST::swap(ACTIONS_LIST & list)
-{
-std::lock_guard lock(m_mutex);
-parent::swap(list);
-}
-
-template <class ACTIVE_CLASS, typename DATA_TYPE>
-inline
-void ACTIONS_LIST::Enqueue(ACTIVE_CLASS & ac,
-                           typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
-                           DATA_TYPE d)
-{
-std::lock_guard lock(m_mutex);
-push_back(new ACTION<ACTIVE_CLASS, DATA_TYPE>(ac, a, d));
-}
-
-inline
-void ACTIONS_LIST::InvokeAll()
-{
-std::lock_guard lock(m_mutex);
-std::for_each(
-        parent::begin(),
-        parent::end(),
-        [](auto action){ action->Invoke(); });
-}
-
-#endif

diff --git a/projects/stargazer/eventloop.cpp b/projects/stargazer/eventloop.cpp
index 36a77e9e21929c26e19e3ad9ecea86559eed0a1e..ea175c414985fda732a5353622b9e40de257a76a 100644 (file)
--- a/projects/stargazer/eventloop.cpp
+++ b/projects/stargazer/eventloop.cpp
@@ -1,119 +1,59 @@
-#include <csignal>
-#include <cerrno>
-#include <cstring>
-
-#include "stg/locker.h"

 #include "stg/common.h"
 #include "eventloop.h"
 
 #include "stg/common.h"
 #include "eventloop.h"
 

-EVENT_LOOP::EVENT_LOOP()
-    : ACTIONS_LIST(),
-      _running(false),
-      _stopped(true),
-      _tid(),
-      _mutex(),
-      _condition()
-{
-pthread_mutex_init(&_mutex, NULL);
-pthread_cond_init(&_condition, NULL);
-}
+#include <csignal>
+#include <cerrno>
+#include <cstring>

 
 

-EVENT_LOOP::~EVENT_LOOP()
+EVENT_LOOP& EVENT_LOOP::instance()

 {
 {

-pthread_cond_destroy(&_condition);
-pthread_mutex_destroy(&_mutex);
+    static EVENT_LOOP el;
+    return el;

 }
 
 bool EVENT_LOOP::Start()
 {
 }
 
 bool EVENT_LOOP::Start()
 {

-_running = true;
-if (pthread_create(&_tid, NULL, Run, this))
-    {
-    printfd(__FILE__, "EVENT_LOOP::Start - Failed to create thread: '%s'\n", strerror(errno));
-    return true;
-    }
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });

 return false;
 }
 
 bool EVENT_LOOP::Stop()
 {
 return false;
 }
 
 bool EVENT_LOOP::Stop()
 {

-_running = false;
+m_thread.request_stop();

 // Wake up thread
 // Wake up thread

-pthread_cond_signal(&_condition);
-// Wait until thread exit
-pthread_join(_tid, NULL);
+m_cond.notify_all();
+m_thread.join();

 return false;
 }
 
 return false;
 }
 

-void * EVENT_LOOP::Run(void * self)
-{
-EVENT_LOOP * ev = static_cast<EVENT_LOOP *>(self);
-ev->Runner();
-return NULL;
-}
-
-void EVENT_LOOP::Runner()
+void EVENT_LOOP::Run(std::stop_token token)

 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 

-_stopped = false;

 printfd(__FILE__, "EVENT_LOOP::Runner - Before start\n");
 printfd(__FILE__, "EVENT_LOOP::Runner - Before start\n");

-while (_running)
+while (!token.stop_requested())

     {
     {

+    // Create new empty actions list
+    ACTIONS_LIST local;

         {
         {

-        STG_LOCKER lock(&_mutex);
+        std::unique_lock lock(m_mutex);

         // Check for any actions...
         // Check for any actions...

-        if (empty())
-            {
-            // ... and sleep until new actions added
-            printfd(__FILE__, "EVENT_LOOP::Runner - Sleeping until new actions arrived\n");
-            pthread_cond_wait(&_condition, &_mutex);
-            }
+        // ... and sleep until new actions added
+        printfd(__FILE__, "EVENT_LOOP::Runner - Sleeping until new actions arrived\n");
+        m_cond.wait(lock);

         // Check for running after wake up
         // Check for running after wake up

-        if (!_running)
-            {
-            // Don't process any actions if stopping
-            break;
-            }
+        if (token.stop_requested())
+            break; // Don't process any actions if stopping
+        if (!m_list.empty())
+            local.swap(m_list);

         }
         }

-    // Create new empty actions list
-    ACTIONS_LIST local;

     // Fast swap with current
     // Fast swap with current

-    swap(local);
+    m_list.swap(local);

     // Invoke all current actions
     printfd(__FILE__, "EVENT_LOOP::Runner - Invoke %d actions\n", local.size());
     local.InvokeAll();
     }
 printfd(__FILE__, "EVENT_LOOP::Runner - Before stop\n");
     // Invoke all current actions
     printfd(__FILE__, "EVENT_LOOP::Runner - Invoke %d actions\n", local.size());
     local.InvokeAll();
     }
 printfd(__FILE__, "EVENT_LOOP::Runner - Before stop\n");

-_stopped = true;
-}
-
-namespace {
-
-pthread_mutex_t singletonMutex;
-
-}
-
-EVENT_LOOP & EVENT_LOOP_SINGLETON::GetInstance()
-{
-// Double-checking technique
-if (!_instance)
-    {
-    STG_LOCKER lock(&singletonMutex);
-    if (!_instance)
-        {
-        CreateInstance();
-        }
-    }
-return *_instance;

 }
 }

-
-void EVENT_LOOP_SINGLETON::CreateInstance()
-{
-static EVENT_LOOP loop;
-_instance = &loop;
-}
-
-EVENT_LOOP * EVENT_LOOP_SINGLETON::_instance = NULL;

diff --git a/projects/stargazer/eventloop.h b/projects/stargazer/eventloop.h
index 0e7981421ea289858b31beda001e859d707e7358..0b2b83979fe5522e00ac554aca5c0e4fcfec252c 100644 (file)
--- a/projects/stargazer/eventloop.h
+++ b/projects/stargazer/eventloop.h
@@ -1,63 +1,45 @@
 #ifndef __EVENT_LOOP_H__
 #define __EVENT_LOOP_H__
 
 #ifndef __EVENT_LOOP_H__
 #define __EVENT_LOOP_H__
 

-#include <pthread.h>
-
-#include "stg/noncopyable.h"

 #include "actions.h"
 
 #include "actions.h"
 

-class EVENT_LOOP : private NONCOPYABLE,
-                   private ACTIONS_LIST
+#include <mutex>
+#include <condition_variable>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop
+
+class EVENT_LOOP

 {
     public:
 {
     public:

+        static EVENT_LOOP& instance();
+

         bool Start();
         bool Stop();
         bool Start();
         bool Stop();

-        bool IsRunning() const { return _running; }

 
         template <class ACTIVE_CLASS, typename DATA_TYPE>
         void Enqueue(ACTIVE_CLASS & ac,
                      typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
 
         template <class ACTIVE_CLASS, typename DATA_TYPE>
         void Enqueue(ACTIVE_CLASS & ac,
                      typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,

-                     DATA_TYPE d);
+                     DATA_TYPE d)
+        {
+            std::lock_guard lock(m_mutex);
+            // Add new action
+            m_list.Enqueue(ac, a, d);
+            // Signal about new action
+            m_cond.notify_all();
+        }

 
     private:
 
     private:

-        bool _running;
-        bool _stopped;
-        pthread_t _tid;
-        pthread_mutex_t _mutex;
-        pthread_cond_t _condition;
-
-        EVENT_LOOP();
-        virtual ~EVENT_LOOP();
-
-        static void * Run(void *);
-        void Runner();
-
-        friend class EVENT_LOOP_SINGLETON;
-};
+        std::jthread m_thread;
+        std::mutex m_mutex;
+        std::condition_variable m_cond;

 
 

-class EVENT_LOOP_SINGLETON : private NONCOPYABLE
-{
-    public:
-        static EVENT_LOOP & GetInstance();
+        ACTIONS_LIST m_list;

 
 

-    private:
-        static EVENT_LOOP * _instance;
-        static void CreateInstance();
+        EVENT_LOOP() = default;

 
 

-        EVENT_LOOP_SINGLETON() {}
-        ~EVENT_LOOP_SINGLETON() {}
+        void Run(std::stop_token token);

 };
 
 };
 

-template <class ACTIVE_CLASS, typename DATA_TYPE>
-void EVENT_LOOP::Enqueue(ACTIVE_CLASS & ac,
-                         typename ACTOR<ACTIVE_CLASS, DATA_TYPE>::TYPE a,
-                         DATA_TYPE d)
-{
-STG_LOCKER lock(&_mutex);
-// Add new action
-ACTIONS_LIST::Enqueue(ac, a, d);
-// Signal about new action
-pthread_cond_signal(&_condition);
-}
-

 #endif
 #endif

diff --git a/projects/stargazer/main.cpp b/projects/stargazer/main.cpp
index d70f50a3d0af0a4515c0e5056238a47ae76098d0..bcf7af777f2bec80e9b8c89a11a54bcf63a05159 100644 (file)
--- a/projects/stargazer/main.cpp
+++ b/projects/stargazer/main.cpp
@@ -282,7 +282,7 @@ int main(int argc, char* argv[])
         return -1;
     }
 
         return -1;
     }
 

-    auto& loop = EVENT_LOOP_SINGLETON::GetInstance();
+    auto& loop = EVENT_LOOP::instance();

 
     StoreLoader storeLoader(settings);
     if (storeLoader.load())
 
     StoreLoader storeLoader(settings);
     if (storeLoader.load())

diff --git a/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.cpp b/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.cpp
index f063da9f2f4364f5ae77538bd73ee9cf730f2bea..aa10327cf41ff09db42abfb0f3d7168002d1003f 100644 (file)
--- a/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.cpp
+++ b/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.cpp
@@ -108,8 +108,7 @@ return "cap_bpf v.1.0";
 }
 //-----------------------------------------------------------------------------
 BPF_CAP::BPF_CAP()
 }
 //-----------------------------------------------------------------------------
 BPF_CAP::BPF_CAP()

-    : nonstop(false),
-      isRunning(false),
+    : isRunning(false),

       capSock(-1),
       traffCnt(NULL),
       logger(STG::PluginLogger::get("cap_bpf"))
       capSock(-1),
       traffCnt(NULL),
       logger(STG::PluginLogger::get("cap_bpf"))


@@ -138,15 +137,7 @@ if (BPFCapOpen() < 0)
     return -1;
     }
 
     return -1;
     }
 

-nonstop = true;
-
-if (pthread_create(&thread, NULL, Run, this))
-    {
-    errorStr = "Cannot create thread.";
-    logger("Cannot create thread.");
-    printfd(__FILE__, "Cannot create thread\n");
-    return -1;
-    }
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });

 
 return 0;
 }
 
 return 0;
 }


@@ -158,7 +149,7 @@ if (!isRunning)
 
 BPFCapClose();
 
 
 BPFCapClose();
 

-nonstop = false;
+m_thread.request_stop();

 
 //5 seconds to thread stops itself
 int i;
 
 //5 seconds to thread stops itself
 int i;


@@ -173,28 +164,20 @@ for (i = 0; i < 25; i++)
 
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)
 
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)

-    {
-    //TODO pthread_cancel()
-    if (pthread_kill(thread, SIGINT))
-        {
-        errorStr = "Cannot kill thread.";
-        logger("Cannot send signal to thread.");
-        printfd(__FILE__, "Cannot kill thread\n");
-        return -1;
-        }
-    }
+    m_thread.detach();
+else
+    m_thread.join();

 
 return 0;
 }
 //-----------------------------------------------------------------------------
 
 return 0;
 }
 //-----------------------------------------------------------------------------

-void * BPF_CAP::Run(void * d)
+void BPF_CAP::Run(std::stop_token token)

 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 

-BPF_CAP * dc = static_cast<BPF_CAP *>(d);
-dc->isRunning = true;
+isRunning = true;

 
 uint8_t hdr[96]; //68 + 14 + 4(size) + 9(SYS_IFACE) + 1(align to 4) = 96
 
 
 uint8_t hdr[96]; //68 + 14 + 4(size) + 9(SYS_IFACE) + 1(align to 4) = 96
 


@@ -204,19 +187,18 @@ memset(hdr, 0, sizeof(hdr));
 rpp->dataLen = -1;
 char * iface;
 
 rpp->dataLen = -1;
 char * iface;
 

-while (dc->nonstop)
+while (!token.stop_requested())

     {
     {

-    if (dc->BPFCapRead((char*)&hdr, 68 + 14, &iface))
+    if (BPFCapRead((char*)&hdr, 68 + 14, &iface))

         continue;
 
     if (!(hdr[12] == 0x8 && hdr[13] == 0x0))
         continue;
 
         continue;
 
     if (!(hdr[12] == 0x8 && hdr[13] == 0x0))
         continue;
 

-    dc->traffCnt->process(*rpp);
+    traffCnt->process(*rpp);

     }
 
     }
 

-dc->isRunning = false;
-return NULL;
+isRunning = false;

 }
 //-----------------------------------------------------------------------------
 int BPF_CAP::BPFCapOpen()
 }
 //-----------------------------------------------------------------------------
 int BPF_CAP::BPFCapOpen()

diff --git a/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.h b/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.h
index 07380bda4fe1cefbb6cfa922cdafda81f05d2025..a416727401f0ba8517bdd5fa360cf654ccf4fe78 100644 (file)
--- a/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.h
+++ b/projects/stargazer/plugins/capture/ether_freebsd/ether_cap.h
@@ -32,9 +32,12 @@
 
 #include <string>
 #include <vector>
 
 #include <string>
 #include <vector>

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop

 #include <cstdint>
 
 #include <cstdint>
 

-#include <pthread.h>

 #include <sys/poll.h>
 
 #define BUFF_LEN (128)
 #include <sys/poll.h>
 
 #define BUFF_LEN (128)


@@ -114,7 +117,7 @@ private:
     BPF_CAP(const BPF_CAP & rvalue);
     BPF_CAP & operator=(const BPF_CAP & rvalue);
 
     BPF_CAP(const BPF_CAP & rvalue);
     BPF_CAP & operator=(const BPF_CAP & rvalue);
 

-    static void *       Run(void *);
+    void                Run(std::stop_token token);

     int                 BPFCapOpen();
     int                 BPFCapOpen(BPF_DATA * bd);
     int                 BPFCapClose();
     int                 BPFCapOpen();
     int                 BPFCapOpen(BPF_DATA * bd);
     int                 BPFCapClose();


@@ -128,8 +131,7 @@ private:
     std::vector<BPF_DATA> bpfData;
     std::vector<pollfd>   polld;
 
     std::vector<BPF_DATA> bpfData;
     std::vector<pollfd>   polld;
 

-    pthread_t             thread;
-    bool                  nonstop;
+    std::jthread          m_thread;

     bool                  isRunning;
     int                   capSock;
     STG::ModuleSettings       settings;
     bool                  isRunning;
     int                   capSock;
     STG::ModuleSettings       settings;

diff --git a/projects/stargazer/plugins/capture/ether_linux/ether_cap.cpp b/projects/stargazer/plugins/capture/ether_linux/ether_cap.cpp
index 7ca6c01f254327c947b5579080c7f65c3537c3bb..3ac60d1ff3f2326fb3047d5497a3603f9305be45 100644 (file)
--- a/projects/stargazer/plugins/capture/ether_linux/ether_cap.cpp
+++ b/projects/stargazer/plugins/capture/ether_linux/ether_cap.cpp
@@ -65,8 +65,7 @@ return "cap_ether v.1.2";
 }
 //-----------------------------------------------------------------------------
 ETHER_CAP::ETHER_CAP()
 }
 //-----------------------------------------------------------------------------
 ETHER_CAP::ETHER_CAP()

-    : nonstop(false),
-      isRunning(false),
+    : isRunning(false),

       capSock(-1),
       traffCnt(NULL),
       logger(STG::PluginLogger::get("cap_ether"))
       capSock(-1),
       traffCnt(NULL),
       logger(STG::PluginLogger::get("cap_ether"))


@@ -85,15 +84,7 @@ if (EthCapOpen() < 0)
     return -1;
     }
 
     return -1;
     }
 

-nonstop = true;
-
-if (pthread_create(&thread, NULL, Run, this))
-    {
-    errorStr = "Cannot create thread.";
-    logger("Cannot create thread.");
-    printfd(__FILE__, "Cannot create thread\n");
-    return -1;
-    }
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });

 
 return 0;
 }
 
 return 0;
 }


@@ -103,7 +94,7 @@ int ETHER_CAP::Stop()
 if (!isRunning)
     return 0;
 
 if (!isRunning)
     return 0;
 

-nonstop = false;
+m_thread.request_stop();

 
 //5 seconds to thread stops itself
 for (int i = 0; i < 25 && isRunning; i++)
 
 //5 seconds to thread stops itself
 for (int i = 0; i < 25 && isRunning; i++)


@@ -113,43 +104,21 @@ for (int i = 0; i < 25 && isRunning; i++)
     }
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)
     }
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)

-    {
-    if (pthread_kill(thread, SIGUSR1))
-        {
-        errorStr = "Cannot kill thread.";
-        logger("Cannot send signal to thread.");
-        return -1;
-        }
-    for (int i = 0; i < 25 && isRunning; ++i)
-        {
-        struct timespec ts = {0, 200000000};
-        nanosleep(&ts, NULL);
-        }
-    if (isRunning)
-        {
-        errorStr = "ETHER_CAP not stopped.";
-        logger("Cannot stop thread.");
-        printfd(__FILE__, "Cannot stop thread\n");
-        return -1;
-        }
-    else
-        {
-        pthread_join(thread, NULL);
-        }
-    }
+    m_thread.detach();
+else
+    m_thread.join();

 
 EthCapClose();
 return 0;
 }
 //-----------------------------------------------------------------------------
 
 EthCapClose();
 return 0;
 }
 //-----------------------------------------------------------------------------

-void * ETHER_CAP::Run(void * d)
+void ETHER_CAP::Run(std::stop_token token)

 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 

-ETHER_CAP * dc = static_cast<ETHER_CAP *>(d);
-dc->isRunning = true;
+isRunning = true;

 
 struct ETH_IP
 {
 
 struct ETH_IP
 {


@@ -168,9 +137,9 @@ ethIP->rp.dataLen = -1;
 
 char * iface = NULL;
 
 
 char * iface = NULL;
 

-while (dc->nonstop)
+while (!token.stop_requested())

     {
     {

-    if (dc->EthCapRead(&ethip, 68 + 14, &iface))
+    if (EthCapRead(&ethip, 68 + 14, &iface))

         {
         continue;
         }
         {
         continue;
         }


@@ -178,11 +147,10 @@ while (dc->nonstop)
     if (ethIP->ethHdr[7] != 0x8)
         continue;
 
     if (ethIP->ethHdr[7] != 0x8)
         continue;
 

-    dc->traffCnt->process(ethIP->rp);
+    traffCnt->process(ethIP->rp);

     }
 
     }
 

-dc->isRunning = false;
-return NULL;
+isRunning = false;

 }
 //-----------------------------------------------------------------------------
 int ETHER_CAP::EthCapOpen()
 }
 //-----------------------------------------------------------------------------
 int ETHER_CAP::EthCapOpen()


@@ -202,7 +170,7 @@ return 0;
 int ETHER_CAP::EthCapRead(void * buffer, int blen, char **)
 {
 struct sockaddr_ll  addr;
 int ETHER_CAP::EthCapRead(void * buffer, int blen, char **)
 {
 struct sockaddr_ll  addr;

-int addrLen;
+socklen_t addrLen;

 
 if (!WaitPackets(capSock))
     {
 
 if (!WaitPackets(capSock))
     {


@@ -211,7 +179,7 @@ if (!WaitPackets(capSock))
 
 addrLen = sizeof(addr);
 
 
 addrLen = sizeof(addr);
 

-if (recvfrom(capSock, ((char*)buffer) + 2, blen, 0, (struct sockaddr *)&addr, (socklen_t*)&addrLen) < 0)
+if (recvfrom(capSock, static_cast<char*>(buffer) + 2, blen, 0, reinterpret_cast<sockaddr *>(&addr), &addrLen) < 0)

     {
     logger("recvfrom error: %s", strerror(errno));
     return ENODATA;
     {
     logger("recvfrom error: %s", strerror(errno));
     return ENODATA;

diff --git a/projects/stargazer/plugins/capture/ether_linux/ether_cap.h b/projects/stargazer/plugins/capture/ether_linux/ether_cap.h
index cf776a4526bd1ec63d255491372f18cec7e46569..d50923d6572be158c1c713c076338cef04b11f64 100644 (file)
--- a/projects/stargazer/plugins/capture/ether_linux/ether_cap.h
+++ b/projects/stargazer/plugins/capture/ether_linux/ether_cap.h
@@ -25,14 +25,16 @@
 
 #pragma once
 
 
 #pragma once
 

-#include <pthread.h>
-
-#include <string>
-

 #include "stg/plugin.h"
 #include "stg/module_settings.h"
 #include "stg/logger.h"
 
 #include "stg/plugin.h"
 #include "stg/module_settings.h"
 #include "stg/logger.h"
 

+#include <string>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop
+

 namespace STG
 {
 
 namespace STG
 {
 


@@ -66,15 +68,14 @@ private:
     ETHER_CAP(const ETHER_CAP & rvalue);
     ETHER_CAP & operator=(const ETHER_CAP & rvalue);
 
     ETHER_CAP(const ETHER_CAP & rvalue);
     ETHER_CAP & operator=(const ETHER_CAP & rvalue);
 

-    static void *       Run(void *);
+    void                Run(std::stop_token token);

     int                 EthCapOpen();
     int                 EthCapClose();
     int                 EthCapRead(void * buffer, int blen, char ** iface);
 
     mutable std::string errorStr;
 
     int                 EthCapOpen();
     int                 EthCapClose();
     int                 EthCapRead(void * buffer, int blen, char ** iface);
 
     mutable std::string errorStr;
 

-    pthread_t           thread;
-    bool                nonstop;
+    std::jthread        m_thread;

     bool                isRunning;
     int                 capSock;
 
     bool                isRunning;
     int                 capSock;
 

diff --git a/projects/stargazer/plugins/capture/nfqueue/nfqueue.cpp b/projects/stargazer/plugins/capture/nfqueue/nfqueue.cpp
index 3c79c1b1c2f0376f5c771ff3278cbf7d1e069a0d..0a5d87122816e9e3134f20bf902c9deb4859075e 100644 (file)
--- a/projects/stargazer/plugins/capture/nfqueue/nfqueue.cpp
+++ b/projects/stargazer/plugins/capture/nfqueue/nfqueue.cpp
@@ -87,8 +87,7 @@ return "cap_nfqueue v.1.0";
 }
 //-----------------------------------------------------------------------------
 NFQ_CAP::NFQ_CAP()
 }
 //-----------------------------------------------------------------------------
 NFQ_CAP::NFQ_CAP()

-    : nonstop(false),
-      isRunning(false),
+    : isRunning(false),

       queueNumber(0),
       nfqHandle(NULL),
       queueHandle(NULL),
       queueNumber(0),
       nfqHandle(NULL),
       queueHandle(NULL),


@@ -152,15 +151,7 @@ if (nfq_set_mode(queueHandle, NFQNL_COPY_PACKET, 0xffFF) < 0)
     return -1;
     }
 
     return -1;
     }
 

-nonstop = true;
-
-if (pthread_create(&thread, NULL, Run, this))
-    {
-    errorStr = "Cannot create thread.";
-    logger("Cannot create thread.");
-    printfd(__FILE__, "Cannot create thread\n");
-    return -1;
-    }
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });

 
 return 0;
 }
 
 return 0;
 }


@@ -170,7 +161,7 @@ int NFQ_CAP::Stop()
 if (!isRunning)
     return 0;
 
 if (!isRunning)
     return 0;
 

-nonstop = false;
+m_thread.request_stop();

 
 //5 seconds to thread stops itself
 for (int i = 0; i < 25 && isRunning; i++)
 
 //5 seconds to thread stops itself
 for (int i = 0; i < 25 && isRunning; i++)


@@ -180,28 +171,9 @@ for (int i = 0; i < 25 && isRunning; i++)
     }
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)
     }
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)

-    {
-    if (pthread_kill(thread, SIGUSR1))
-        {
-        errorStr = "Cannot kill thread.";
-        logger("Cannot send signal to thread.");
-        return -1;
-        }
-    for (int i = 0; i < 25 && isRunning; ++i)
-        {
-        struct timespec ts = {0, 200000000};
-        nanosleep(&ts, NULL);
-        }
-    if (isRunning)
-        {
-        errorStr = "NFQ_CAP not stopped.";
-        logger("Cannot stop thread.");
-        printfd(__FILE__, "Cannot stop thread\n");
-        return -1;
-        }
-    }
-
-pthread_join(thread, NULL);
+    m_thread.detach();
+else
+    m_thread.join();

 
 nfq_destroy_queue(queueHandle);
 nfq_close(nfqHandle);
 
 nfq_destroy_queue(queueHandle);
 nfq_close(nfqHandle);


@@ -209,19 +181,18 @@ nfq_close(nfqHandle);
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-void * NFQ_CAP::Run(void * d)
+void NFQ_CAP::Run(std::stop_token token)

 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 

-NFQ_CAP * dc = static_cast<NFQ_CAP *>(d);
-dc->isRunning = true;
+isRunning = true;

 
 

-int fd = nfq_fd(dc->nfqHandle);
+int fd = nfq_fd(nfqHandle);

 char buf[4096];
 
 char buf[4096];
 

-while (dc->nonstop)
+while (!token.stop_requested())

     {
         if (!WaitPackets(fd))
             continue;
     {
         if (!WaitPackets(fd))
             continue;


@@ -229,15 +200,14 @@ while (dc->nonstop)
         int rv = read(fd, buf, sizeof(buf));
         if (rv < 0)
             {
         int rv = read(fd, buf, sizeof(buf));
         if (rv < 0)
             {

-            dc->errorStr = std::string("Read error: ") + strerror(errno);
-            dc->logger(dc->errorStr);
+            errorStr = std::string("Read error: ") + strerror(errno);
+            logger(errorStr);

             break;
             }
             break;
             }

-        nfq_handle_packet(dc->nfqHandle, buf, rv);
+        nfq_handle_packet(nfqHandle, buf, rv);

     }
 
     }
 

-dc->isRunning = false;
-return NULL;
+isRunning = false;

 }
 //-----------------------------------------------------------------------------
 void NFQ_CAP::Process(const STG::RawPacket & packet)
 }
 //-----------------------------------------------------------------------------
 void NFQ_CAP::Process(const STG::RawPacket & packet)

diff --git a/projects/stargazer/plugins/capture/nfqueue/nfqueue.h b/projects/stargazer/plugins/capture/nfqueue/nfqueue.h
index 7d71bcd23e38885547b093c10bd7e84cbc3caed1..402e36bf4a6a1e37465fbf24089e899bbeacef50 100644 (file)
--- a/projects/stargazer/plugins/capture/nfqueue/nfqueue.h
+++ b/projects/stargazer/plugins/capture/nfqueue/nfqueue.h
@@ -26,8 +26,10 @@
 
 #include <string>
 #include <vector>
 
 #include <string>
 #include <vector>

-
-#include <pthread.h>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop

 
 namespace STG
 {
 
 namespace STG
 {


@@ -69,12 +71,11 @@ private:
     NFQ_CAP(const NFQ_CAP & rvalue);
     NFQ_CAP & operator=(const NFQ_CAP & rvalue);
 
     NFQ_CAP(const NFQ_CAP & rvalue);
     NFQ_CAP & operator=(const NFQ_CAP & rvalue);
 

-    static void *       Run(void *);
+    void                Run(std::stop_token token);

 
     mutable std::string errorStr;
 
 
     mutable std::string errorStr;
 

-    pthread_t           thread;
-    bool                nonstop;
+    std::jthread        m_thread;

     bool                isRunning;
     STG::ModuleSettings     settings;
 
     bool                isRunning;
     STG::ModuleSettings     settings;
 

diff --git a/projects/stargazer/plugins/capture/pcap/pcap_cap.cpp b/projects/stargazer/plugins/capture/pcap/pcap_cap.cpp
index 394487f37ab3b45946e41ad93f25e65108e756c1..323bd7bf85f6200d372ab631061452676af50ebf 100644 (file)
--- a/projects/stargazer/plugins/capture/pcap/pcap_cap.cpp
+++ b/projects/stargazer/plugins/capture/pcap/pcap_cap.cpp
@@ -61,8 +61,7 @@ return "pcap_cap v.1.0";
 }
 //-----------------------------------------------------------------------------
 PCAP_CAP::PCAP_CAP()
 }
 //-----------------------------------------------------------------------------
 PCAP_CAP::PCAP_CAP()

-    : nonstop(false),
-      isRunning(false),
+    : isRunning(false),

       traffCnt(NULL),
       logger(STG::PluginLogger::get("pcap_cap"))
 {
       traffCnt(NULL),
       logger(STG::PluginLogger::get("pcap_cap"))
 {


@@ -178,15 +177,7 @@ while (it != devices.end())
     ++it;
     }
 
     ++it;
     }
 

-nonstop = true;
-
-if (pthread_create(&thread, NULL, Run, this))
-    {
-    errorStr = "Cannot create thread.";
-    logger("Cannot create thread.");
-    printfd(__FILE__, "Cannot create thread\n");
-    return -1;
-    }
+m_thread = std::jthread([this](auto token){ Run(std::move(token)); });

 
 return 0;
 }
 
 return 0;
 }


@@ -196,7 +187,7 @@ int PCAP_CAP::Stop()
 if (!isRunning)
     return 0;
 
 if (!isRunning)
     return 0;
 

-nonstop = false;
+m_thread.request_stop();

 
 //5 seconds to thread stops itself
 for (int i = 0; i < 25 && isRunning; i++)
 
 //5 seconds to thread stops itself
 for (int i = 0; i < 25 && isRunning; i++)


@@ -206,28 +197,9 @@ for (int i = 0; i < 25 && isRunning; i++)
     }
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)
     }
 //after 5 seconds waiting thread still running. now killing it
 if (isRunning)

-    {
-    if (pthread_kill(thread, SIGUSR1))
-        {
-        errorStr = "Cannot kill thread.";
-        logger("Cannot send signal to thread.");
-        return -1;
-        }
-    for (int i = 0; i < 25 && isRunning; ++i)
-        {
-        struct timespec ts = {0, 200000000};
-        nanosleep(&ts, NULL);
-        }
-    if (isRunning)
-        {
-        errorStr = "PCAP_CAP not stopped.";
-        logger("Cannot stop thread.");
-        printfd(__FILE__, "Cannot stop thread\n");
-        return -1;
-        }
-    }
-
-pthread_join(thread, NULL);
+    m_thread.detach();
+else
+    m_thread.join();

 
 for (DEV_MAP::iterator it(devices.begin()); it != devices.end(); ++it)
     {
 
 for (DEV_MAP::iterator it(devices.begin()); it != devices.end(); ++it)
     {


@@ -238,35 +210,33 @@ for (DEV_MAP::iterator it(devices.begin()); it != devices.end(); ++it)
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-void * PCAP_CAP::Run(void * d)
+void PCAP_CAP::Run(std::stop_token token)

 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 
 {
 sigset_t signalSet;
 sigfillset(&signalSet);
 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 

-PCAP_CAP * dc = static_cast<PCAP_CAP *>(d);
-dc->isRunning = true;
+isRunning = true;

 
 fd_set fds;
 FD_ZERO(&fds);
 int maxFd = 0;
 
 fd_set fds;
 FD_ZERO(&fds);
 int maxFd = 0;

-for (DEV_MAP::const_iterator it(dc->devices.begin()); it != dc->devices.end(); ++it)
+for (DEV_MAP::const_iterator it(devices.begin()); it != devices.end(); ++it)

     {
     FD_SET(it->fd, &fds);
     maxFd = std::max(maxFd, it->fd);
     }
 
     {
     FD_SET(it->fd, &fds);
     maxFd = std::max(maxFd, it->fd);
     }
 

-while (dc->nonstop)
+while (!token.stop_requested())

     {
     fd_set rfds = fds;
     struct timeval tv = {0, 500000};
 
     if (select(maxFd + 1, &rfds, NULL, NULL, &tv) > 0)
     {
     fd_set rfds = fds;
     struct timeval tv = {0, 500000};
 
     if (select(maxFd + 1, &rfds, NULL, NULL, &tv) > 0)

-        dc->TryRead(rfds);
+        TryRead(rfds);

     }
 
     }
 

-dc->isRunning = false;
-return NULL;
+isRunning = false;

 }
 
 void PCAP_CAP::TryRead(const fd_set & set)
 }
 
 void PCAP_CAP::TryRead(const fd_set & set)

diff --git a/projects/stargazer/plugins/capture/pcap/pcap_cap.h b/projects/stargazer/plugins/capture/pcap/pcap_cap.h
index f47c6b8dae3b293642cddeacc9888eaf921f8580..e72c3e749e2eec3f11a11890556251a5afae64b4 100644 (file)
--- a/projects/stargazer/plugins/capture/pcap/pcap_cap.h
+++ b/projects/stargazer/plugins/capture/pcap/pcap_cap.h
@@ -26,9 +26,12 @@
 
 #include <string>
 #include <vector>
 
 #include <string>
 #include <vector>

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop

 
 #include <pcap.h>
 
 #include <pcap.h>

-#include <pthread.h>

 #include <sys/select.h>
 
 namespace STG
 #include <sys/select.h>
 
 namespace STG


@@ -45,7 +48,7 @@ struct Settings;
 struct DEV
 {
     DEV() : device("any"), filterExpression("ip"), handle(NULL), fd(-1) {}
 struct DEV
 {
     DEV() : device("any"), filterExpression("ip"), handle(NULL), fd(-1) {}

-    DEV(const std::string & d) : device(d), filterExpression("ip"), handle(NULL), fd(-1) {}
+    explicit DEV(const std::string & d) : device(d), filterExpression("ip"), handle(NULL), fd(-1) {}

     DEV(const std::string & d, const std::string & f)
         : device(d), filterExpression(f), handle(NULL), fd(-1) {}
 
     DEV(const std::string & d, const std::string & f)
         : device(d), filterExpression(f), handle(NULL), fd(-1) {}
 


@@ -84,12 +87,11 @@ private:
     void TryRead(const fd_set & set);
     void TryReadDev(const DEV & dev);
 
     void TryRead(const fd_set & set);
     void TryReadDev(const DEV & dev);
 

-    static void *       Run(void *);
+    void                Run(std::stop_token token);

 
     mutable std::string errorStr;
 
 
     mutable std::string errorStr;
 

-    pthread_t           thread;
-    bool                nonstop;
+    std::jthread        m_thread;

     bool                isRunning;
     STG::ModuleSettings     settings;
     DEV_MAP             devices;
     bool                isRunning;
     STG::ModuleSettings     settings;
     DEV_MAP             devices;

diff --git a/projects/stargazer/plugins/configuration/sgconfig/stgconfig.cpp b/projects/stargazer/plugins/configuration/sgconfig/stgconfig.cpp
index a63478bd714435ba3aa185cebc88baf61b674e0e..0896bb85f434cacb392166e4e55c12db19099ae8 100644 (file)
--- a/projects/stargazer/plugins/configuration/sgconfig/stgconfig.cpp
+++ b/projects/stargazer/plugins/configuration/sgconfig/stgconfig.cpp
@@ -127,6 +127,8 @@ int STG_CONFIG::Stop()
 
     if (isRunning)
         m_thread.detach();
 
     if (isRunning)
         m_thread.detach();

+    else
+        m_thread.join();

 
     return 0;
 }
 
     return 0;
 }

diff --git a/projects/stargazer/plugins/other/ping/ping.cpp b/projects/stargazer/plugins/other/ping/ping.cpp
index a8dda2a680ee510474c9e7169d86a9659119feb5..53f7b2f02b8bdf929d540f98358347ac69ffa6e2 100644 (file)
--- a/projects/stargazer/plugins/other/ping/ping.cpp
+++ b/projects/stargazer/plugins/other/ping/ping.cpp
@@ -128,6 +128,8 @@ while (users_iter != usersList.end())
 
 if (isRunning)
     m_thread.detach();
 
 if (isRunning)
     m_thread.detach();

+else
+    m_thread.join();

 
 return 0;
 }
 
 return 0;
 }

diff --git a/projects/stargazer/plugins/other/rscript/rscript.cpp b/projects/stargazer/plugins/other/rscript/rscript.cpp
index 8b0e2054a984154961eeb1e31dffbd54ff6fe96e..95699e1068cefd48f79669d1ecbb04a8b0f30cd7 100644 (file)
--- a/projects/stargazer/plugins/other/rscript/rscript.cpp
+++ b/projects/stargazer/plugins/other/rscript/rscript.cpp
@@ -265,6 +265,8 @@ if (isRunning)
     logger("Cannot stop thread.");
     m_thread.detach();
     }
     logger("Cannot stop thread.");
     m_thread.detach();
     }

+else
+    m_thread.join();

 
 return 0;
 }
 
 return 0;
 }

diff --git a/projects/stargazer/plugins/other/smux/smux.cpp b/projects/stargazer/plugins/other/smux/smux.cpp
index 77df934800f77bc93a8b53cff6ca280bcb9f938a..e0ddfffcb56e251fc84b0454fda065b6a9797930 100644 (file)
--- a/projects/stargazer/plugins/other/smux/smux.cpp
+++ b/projects/stargazer/plugins/other/smux/smux.cpp
@@ -214,6 +214,8 @@ if (!stopped)
 
 if (!stopped)
     m_thread.detach();
 
 if (!stopped)
     m_thread.detach();

+else
+    m_thread.join();

 
 ResetNotifiers();
 
 
 ResetNotifiers();
 

diff --git a/projects/stargazer/plugins/store/firebird/firebird_store.h b/projects/stargazer/plugins/store/firebird/firebird_store.h
index 14f0b26997fffe1d105199d1871c68fe9d6ce25f..736451ec31e675943aeb1f1bd3f82098772b1d8b 100644 (file)
--- a/projects/stargazer/plugins/store/firebird/firebird_store.h
+++ b/projects/stargazer/plugins/store/firebird/firebird_store.h
@@ -30,10 +30,6 @@
 #include <string>
 #include <vector>
 
 #include <string>
 #include <vector>
 

-struct ToLower {
-    char operator() (char c) const  { return static_cast<char>(std::tolower(c)); }
-};
-

 class FIREBIRD_STORE : public STG::Store {
 public:
     FIREBIRD_STORE();
 class FIREBIRD_STORE : public STG::Store {
 public:
     FIREBIRD_STORE();

diff --git a/projects/stargazer/plugins/store/postgresql/postgresql_store.cpp b/projects/stargazer/plugins/store/postgresql/postgresql_store.cpp
index 2146d66483f32dc9179122828cbe0b146584694d..ba47896694ec5f61c9a7d7930614a117661524ad 100644 (file)
--- a/projects/stargazer/plugins/store/postgresql/postgresql_store.cpp
+++ b/projects/stargazer/plugins/store/postgresql/postgresql_store.cpp
@@ -40,9 +40,6 @@
 
 #include "postgresql_store.h"
 
 
 #include "postgresql_store.h"
 

-#include "postgresql_store_utils.h"
-#include "postgresql_store.h"
-

 #include "stg/common.h" // str2x, printfd
 
 #include <string>
 #include "stg/common.h" // str2x, printfd
 
 #include <string>

diff --git a/projects/stargazer/plugins/store/postgresql/postgresql_store_utils.h b/projects/stargazer/plugins/store/postgresql/postgresql_store_utils.h
deleted file mode 100644 (file)
index 4ffa6ec..0000000
--- a/projects/stargazer/plugins/store/postgresql/postgresql_store_utils.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef POSTGRESQL_UTILS_STORE_H
-#define POSTGRESQL_UTILS_STORE_H
-
-#include <functional>
-
-struct ToLower : public std::unary_function<char, char>
-{
-char operator() (char c) const  { return static_cast<char>(std::tolower(c)); }
-};
-
-#endif

diff --git a/projects/stargazer/traffcounter_impl.cpp b/projects/stargazer/traffcounter_impl.cpp
index e61be9665b626fefbb5703543a24b749da388324..9b0fd966d9a2732e456b60f176c8200e5bed6ccb 100644 (file)
--- a/projects/stargazer/traffcounter_impl.cpp
+++ b/projects/stargazer/traffcounter_impl.cpp
@@ -128,9 +128,7 @@ users->CloseSearch(h);
 //5 seconds to thread stops itself
 struct timespec ts = {0, 200000000};
 for (int i = 0; i < 25 && !stopped; i++)
 //5 seconds to thread stops itself
 struct timespec ts = {0, 200000000};
 for (int i = 0; i < 25 && !stopped; i++)

-    {

     nanosleep(&ts, NULL);
     nanosleep(&ts, NULL);

-    }

 
 if (!stopped)
 {
 
 if (!stopped)
 {


@@ -138,6 +136,8 @@ if (!stopped)
     return -1;
 }
 
     return -1;
 }
 

+m_thread.join();
+

 printfd(__FILE__, "TraffCounter::Stop()\n");
 
 return 0;
 printfd(__FILE__, "TraffCounter::Stop()\n");
 
 return 0;

diff --git a/projects/stargazer/traffcounter_impl.h b/projects/stargazer/traffcounter_impl.h
index 42774bf9f2be1b92d7ea9b5881032bef1228fc97..ed639f5c3ddcffb2fc1db1d669678a41a673add6 100644 (file)
--- a/projects/stargazer/traffcounter_impl.h
+++ b/projects/stargazer/traffcounter_impl.h
@@ -244,7 +244,7 @@ void TRF_IP_BEFORE::Notify(const uint32_t & oldValue, const uint32_t &)
 if (!oldValue)
     return;
 
 if (!oldValue)
     return;
 

-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, oldValue);
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, oldValue);

 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 inline


@@ -254,20 +254,20 @@ void TRF_IP_AFTER::Notify(const uint32_t &, const uint32_t & newValue)
 if (!newValue)
     return;
 
 if (!newValue)
     return;
 

-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::AddUser, user);
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::AddUser, user);

 }
 //-----------------------------------------------------------------------------
 inline
 void ADD_USER_NONIFIER::Notify(const UserImplPtr & user)
 {
 }
 //-----------------------------------------------------------------------------
 inline
 void ADD_USER_NONIFIER::Notify(const UserImplPtr & user)
 {

-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::SetUserNotifiers, user);
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::SetUserNotifiers, user);

 }
 //-----------------------------------------------------------------------------
 inline
 void DEL_USER_NONIFIER::Notify(const UserImplPtr & user)
 {
 }
 //-----------------------------------------------------------------------------
 inline
 void DEL_USER_NONIFIER::Notify(const UserImplPtr & user)
 {

-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::UnSetUserNotifiers, user);
-EVENT_LOOP_SINGLETON::GetInstance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, user->GetCurrIP());
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::UnSetUserNotifiers, user);
+EVENT_LOOP::instance().Enqueue(traffCnt, &TraffCounterImpl::DelUser, user->GetCurrIP());

 }
 //-----------------------------------------------------------------------------
 }
 }
 //-----------------------------------------------------------------------------
 }

diff --git a/projects/stargazer/users_impl.cpp b/projects/stargazer/users_impl.cpp
index 2e40f03e90f2bd3d5f2efffdb14d7048d7855ff9..ee25fb2cf90516159b348c7efd7f4fd92d3fd98b 100644 (file)
--- a/projects/stargazer/users_impl.cpp
+++ b/projects/stargazer/users_impl.cpp
@@ -534,6 +534,8 @@ if (isRunning)
     //TODO pthread_cancel()
     m_thread.detach();
     }
     //TODO pthread_cancel()
     m_thread.detach();
     }

+else
+    m_thread.join();

 
 printfd(__FILE__, "Before USERS::Run()\n");
 for_each(users.begin(), users.end(), [](auto& user){ user.Run(); });
 
 printfd(__FILE__, "Before USERS::Run()\n");
 for_each(users.begin(), users.end(), [](auto& user){ user.Run(); });