bug fixes and code updates

updated Loggins and Thread

Author: htartisan

Src/Logging/Logging.h

@@ -26,11 +26,17 @@
 #endif
 
 #include <string>
-
 #include <cstdarg>
 
-#include <format>
+//#include <format>
+
+#ifndef USE_SPDLOG
+
+#include <variant>>
+
+typedef std::vector<std::variant<int, unsigned int, float, double, std::string>>  MultiVarArray_def;
 
+#endif
 
 enum eLogLevel
 {
@@ -43,6 +49,7 @@ enum eLogLevel
     LogLevel_trace = 6
 };
 
+
 class CLogger
 {
     std::string         m_sLogName;
@@ -89,7 +96,7 @@ class CLogger
 
         auto spdlogLevel = ((int)spdlog::level::off - (int)m_nLogLevel);
 
-        spdlog::set_level((spdlog::level::level_enum)spdlogLevel);
+        spdlog::set_level((spdlog::level::level_enum) spdlogLevel);
 
 #else
 
@@ -100,51 +107,86 @@ class CLogger
 
 #ifndef USE_SPDLOG
 
-    std::string formatString(const std::string& fmt, ...)
+    std::string formatString(const std::string& fmt, MultiVarArray_def params)
     {
         std::string sOut = "";
 
-        bool bOpenBracketDetected = false;
+        try
+        {
+            unsigned int argIdx = 0;
 
-        unsigned int nParamIdx = 0;
+            bool bFound = false;
 
-        va_list args;
-        va_start(args, fmt);
+            std::string insertMarker = "{}";
 
-        for (auto x = fmt.begin(); x != fmt.end(); x++)
-        {
-            if ((*x) == '{')    // check for start-param-insiertion
+            std::string sParam;
+
+            unsigned int lastPos = 0;
+
+            unsigned int nextPos = fmt.find(insertMarker);
+
+            auto prm = params.begin();
+
+            while (nextPos != std::string::npos)
             {
-                bOpenBracketDetected = true;
-                continue;
-            }
-            else
-            { 
-                if ((*x) == '}')
-                { 
-                    if (bOpenBracketDetected == true)
-                    {
-                        // process next param
+                auto len = (nextPos - 1) - lastPos;
+                if (len > 0)
+                {
+                    sOut.append(fmt.substr(lastPos, len));
+                }
 
+                if (prm != params.end())
+                {
+                    if (std::holds_alternative<int>(*prm)) 
+                    {
+                        sParam = std::to_string(std::get<int>(*prm));
+                    } 
+                    else if (std::holds_alternative<unsigned int>(*prm)) 
+                    {
+                        sParam = std::to_string(std::get<unsigned int>(*prm));
+                    }
+                    else if (std::holds_alternative<float>(*prm)) 
+                    {
+                        sParam = std::to_string(std::get<float>(*prm));
+                    }
+                    else if (std::holds_alternative<double>(*prm)) 
+                    {
+                        sParam = std::to_string(std::get<double>(*prm));
+                    }
+                    else if (std::holds_alternative<std::string>(*prm)) 
+                    {
+                        sParam = std::get<std::string>(*prm);
                     }
+                    else
+                    {
+                        sParam.clear();   
+                    }
+
+                    prm++;
                 }
-                bOpenBracketDetected = false;
+                else
+                {
+                    sParam.clear();   
+                }
+
+                sOut.append(sParam);
             }
 
-            sOut.push_back((*x));
+            if (bFound == false)
+            {
+                sOut = fmt;
+            }
         }
+        catch(...)
+        {
 
+        }
 
-        va_end(args);
-
+        return sOut;
     }
 
-    void ErrorMsg(unsigned int logLevel, const std::string& msg, ...)
+    void ErrorMsg(unsigned int logLevel, const std::string& fmt, MultiVarArray_def params)
     {
-
-        va_list args;
-        va_start(args, msg);
-
         std::string sOut = "";
 
         switch (logLevel)
@@ -154,12 +196,35 @@ class CLogger
                 break;;
 
             case LogLevel_fatal:
-                sOut = formatString(msg.c_str(), args);
-                PLOG_FATAL << msg;
+                sOut = formatString(fmt, params);
+                PLOG_CRITICAL << sOut;
+                break;
+
+            case LogLevel_error:
+                sOut = formatString(fmt, params);
+                PLOG_ERROR << sOut;
                 break;
-        }
 
-        va_end(args);
+            case LogLevel_warning:
+                sOut = formatString(fmt, params);
+                PLOG_WARNING << sOut;
+                break;
+
+            case LogLevel_info:
+                sOut = formatString(fmt, params);
+                PLOG_INFO << sOut;
+                break;
+
+            case LogLevel_debug:
+                sOut = formatString(fmt, params);
+                PLOG_DEBUG << sOut;
+                break;
+
+            case LogLevel_trace:
+                sOut = formatString(fmt, params);
+                PLOG_VERBOSE << sOut;
+                break;
+        }
     }
 
 #endif
@@ -182,12 +247,12 @@ class CLogger
 
 #define LogInit                 plog::Logger::init
 
-#define LogCritical(m, ...)     spdlog::critical(m, )
-#define LogError(m, ...)        PLOG_ERROR << m
-#define LogWarning(m, ...)      PLOG_WARNING << m
-#define LogInfo(m, ...)         PLOG_INFO << m
-#define LogDebug(m, ...)        PLOG_ERROR << m
-#define LogTrace(m, ...)        PLOG_VERBOSE << m
+#define LogCritical(m, ...)     {MultiVarArray_def params = {__VA_ARGS__};  PLOG_CRITICAL << formatString(m, params);}
+#define LogError(m, ...)        {MultiVarArray_def params = {__VA_ARGS__};  PLOG_ERROR << formatString(m, params);}
+#define LogWarning(m, ...)      {MultiVarArray_def params = {__VA_ARGS__};  PLOG_WARNING << formatString(m, params);}
+#define LogInfo(m, ...)         {MultiVarArray_def params = {__VA_ARGS__};  PLOG_INFO << formatString(m, params);}
+#define LogDebug(m, ...)        {MultiVarArray_def params = {__VA_ARGS__};  PLOG_DEBUG << formatString(m, params);}
+#define LogTrace(m, ...)        {MultiVarArray_def params = {__VA_ARGS__};  PLOG_VERBOSE << formatString(m, params);}
 
 #endif
 

Src/Thread/ThreadBase.h

@@ -38,6 +38,8 @@ typedef std::unique_ptr<std::thread>    ThreadHandle_def;
 
 class CThreadBase
 {
+  protected:
+
     std::string                   m_sName;
 
     int                           m_priority;
@@ -50,9 +52,11 @@ class CThreadBase
 
     volatile bool                 m_running;
 
+    std::mutex                    m_startupMutex;
+
     volatile bool                 m_bThreadExitFlag;
 
-  protected:
+    std::mutex                    m_exitMutex;
 
     void newThread()
     //void newThread(CThreadBase * pThisClass)
@@ -148,8 +152,10 @@ class CThreadBase
         stopThread(true);
     }
 
-    bool createThread()
+    bool createThread()     // This function = start thread
     {
+        std::scoped_lock lock(m_startupMutex);
+
         if (m_running)
         {
             //LogDebug("already active");
@@ -169,6 +175,8 @@ class CThreadBase
 
     void stopThread(bool bSetExitFlag)
     {
+        std::scoped_lock lock(m_exitMutex);
+
         if (bSetExitFlag == true)
         {
             m_bThreadExitFlag = true;
@@ -180,15 +188,22 @@ class CThreadBase
         }
     }
 
+    bool isActive()
+    {
+        return m_running;
+    }
+
     void waitForSignal()
     {
         std::unique_lock<std::mutex> lock(m_signalMutex);
+
         m_signalVar.wait(lock); 
     }
 
     void triggerSignal(bool bWaitAll = false)
     {
         std::unique_lock<std::mutex> lock(m_signalMutex);
+
         if (bWaitAll == false)
             m_signalVar.notify_one();
         else