src/LightApp/MBDebug.h

   1 #ifndef MBDebug_HeaderFile\r
   2 #define MBDebug_HeaderFile\r
   3 \r
   4 //---------------------------------------------------------------\r
   5 // Usage of the logging facilities:\r
   6 //\r
   7 //  (1) At the beginning of each class file to be debugged, there\r
   8 //      should be a static string variable defined with the name\r
   9 //      of the class. Then, include the "MBDebug.h" header file.\r
  10 //\r
  11 //      //---------------------------------------------------------\r
  12 //      #define USE_DEBUG\r
  13 //      //#define MB_IGNORE_QT\r
  14 //      //#define MB_FULL_DUMP\r
  15 //      #define MBCLASSNAME "ClassName"\r
  16 //      #include "MBDebug.h"\r
  17 //      // <-- insert includes for addtional debug headers here!\r
  18 //      //---------------------------------------------------------\r
  19 //\r
  20 //  (2) At the beginning of each class method, call the DBG_FUN\r
  21 //      macro.\r
  22 //\r
  23 //      int ClassName::MyMethod(int x)\r
  24 //      {\r
  25 //        DBG_FUN();\r
  26 //        ...\r
  27 //      }\r
  28 //\r
  29 //      NOTE: For static methods, call the DBG_FUNC() macro!!\r
  30 //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\r
  31 //  This debugging/logging class is a "header-only" solution and\r
  32 //  does NOT require any additional implementation (.cpp) file!\r
  33 //---------------------------------------------------------------\r
  34 \r
  35 #include <iostream>\r
  36 #include <string>\r
  37 #include <locale>\r
  38 #include <codecvt>\r
  39 #include <list>\r
  40 #include <map>\r
  41 #include <set>\r
  42 #include <vector>\r
  43 #include <mutex>\r
  44 #include <thread>\r
  45 #ifndef MB_IGNORE_QT\r
  46 # include <QString>\r
  47 # include <QStringList>\r
  48 #endif\r
  49 \r
  50 static std::mutex mtx;\r
  51 \r
  52 //---------------------------------------------------------------\r
  53 //      Set the debug flags dependent on the preprocessor definitions\r
  54 //---------------------------------------------------------------\r
  55 #ifdef USE_DEBUG\r
  56 #       define MBS_DEBUG_FLAG           MBDebug::DF_DEBUG\r
  57 #else\r
  58 #       define MBS_DEBUG_FLAG           0\r
  59 #endif  /*DEBUG*/ \r
  60 \r
  61 #define MBS_DBG_FLAGS                   (MBS_DEBUG_FLAG)\r
  62 \r
  63 \r
  64 //---------------------------------------------------------------\r
  65 //      Define the global debug macros\r
  66 //---------------------------------------------------------------\r
  67 #define DLOG                                                    MBDebug::LogPrint()\r
  68 #define RETURN(var)                             { RET(var); return (var); }\r
  69 \r
  70 #ifdef  USE_DEBUG\r
  71 \r
  72 # define DBG_FUN()                              MBDebug _dbg(MBCLASSNAME, __FUNCTION__, MBS_DBG_FLAGS, (void*)this)\r
  73 # define DBG_FUNC()                             MBDebug _dbg(MBCLASSNAME, __FUNCTION__, MBS_DBG_FLAGS)\r
  74 # define DBG_FUNB(blk)          MBDebug _dbg(MBCLASSNAME, blk, MBS_DBG_FLAGS)\r
  75 #       define MSGEL(txt)                               MBDebug::LogPrint() <<  ":" << txt << std::endl\r
  76 #       define PRINT(txt)                               MBDebug::LogPrint() << txt\r
  77 #       define SHOW2(var,typ)           do { PRINT(std::this_thread::get_id()); DumpVar(#var,(typ)(var)); } while (0)\r
  78 #       define SHOW(var)                                do { PRINT(std::this_thread::get_id()); DumpVar(#var,var); } while (0)\r
  79 #       define ARG(var)                                 do { PRINT(std::this_thread::get_id() << ":in:"); DumpVar(#var,var); } while (0)\r
  80 #       define ARG2(var,typ)            do { PRINT(std::this_thread::get_id() << ":in:"); DumpVar(#var,(typ)(var)); } while (0)\r
  81 #       define RET(var)                                 do { PRINT(std::this_thread::get_id() << ":out:"); DumpVar(#var,var); } while (0)\r
  82 #       define MSG(txt)                                 MBDebug::LogPrint() << std::this_thread::get_id() << ":" << txt\r
  83 \r
  84 #else   /*!USE_DEBUG*/ \r
  85 \r
  86 #       define DBG_FUN()\r
  87 #       define DBG_FUNC()\r
  88 #       define DBG_FUNB(blk)\r
  89 #       define MSGEL(txt)\r
  90 #       define PRINT(txt)\r
  91 #       define SHOW2(var,typ)\r
  92 #       define SHOW(var)\r
  93 #       define ARG(var)\r
  94 #       define ARG2(var,typ)\r
  95 #       define RET(var)\r
  96 #       define MSG(txt)\r
  97 \r
  98 #endif  /*USE_DEBUG*/ \r
  99 \r
 100 \r
 101 //---------------------------------------------------------------\r
 102 //      Declare the debugging and profiling class\r
 103 //---------------------------------------------------------------\r
 104 class MBDebug\r
 105 {\r
 106 public:\r
 107         enum {\r
 108                 DF_NONE                 = 0x00,         // no debug\r
 109                 DF_DEBUG                = 0x01          // debug a function\r
 110         };\r
 111 \r
 112         MBDebug(const char* aClassName, const char* aFuncName, const short aFlag, void* aThis=NULL)\r
 113         :mClassName(aClassName),mFuncName(aFuncName),mThis(aThis),mFlags((unsigned char)aFlag)\r
 114   {\r
 115         if (mFlags & (DF_DEBUG))\r
 116         {\r
 117       std::lock_guard<std::mutex> lck(mtx);\r
 118                 std::cout << std::this_thread::get_id() << ":{ENTER: " << mClassName + "::" + mFuncName;\r
 119                 if (mThis) std::cout << "(this=" << mThis << ")";\r
 120                 std::cout << std::endl;\r
 121         }\r
 122   }\r
 123         virtual ~MBDebug()\r
 124   {\r
 125         if (mFlags & (DF_DEBUG))\r
 126     {\r
 127       std::lock_guard<std::mutex> lck(mtx);\r
 128                 std::cout << std::this_thread::get_id() << ":}LEAVE: " << mClassName << "::" << mFuncName << std::endl;\r
 129     }\r
 130   }\r
 131 \r
 132         // Log file output management\r
 133         static std::ostream&    LogPrint()      { return std::cout; }\r
 134 \r
 135 private:\r
 136         std::string                     mClassName;     // Name of class to be debugged\r
 137         std::string                     mFuncName;      // Name of function to be debugged\r
 138         void*                           mThis;            // The "this" pointer to the class being debugged\r
 139         unsigned char           mFlags;                 // Debug mode flags\r
 140 };\r
 141 \r
 142 \r
 143 \r
 144 #define YesNo(b)        (b ? "Yes" : "No")\r
 145 \r
 146 \r
 147 \r
 148 inline std::string w2s(std::wstring ws)\r
 149 {\r
 150         using convert_typeX = std::codecvt_utf8<wchar_t>;\r
 151         std::wstring_convert<convert_typeX, wchar_t> converterX;\r
 152         return(converterX.to_bytes(ws));\r
 153 }\r
 154 \r
 155 // Primitive types\r
 156 inline void DumpVar(const char *szName, char value)\r
 157 {\r
 158   std::lock_guard<std::mutex> lck(mtx);\r
 159         DLOG << "[chr]: " << szName << "='" << value << "'" << std::endl;\r
 160 }\r
 161 \r
 162 inline void DumpVar(const char *szName, bool value)\r
 163 {\r
 164   std::lock_guard<std::mutex> lck(mtx);\r
 165         DLOG << "[bool]: " << szName << "=" << (value ? "true" : "false") << std::endl;\r
 166 }\r
 167 \r
 168 inline void DumpVar(const char *szName, short value)\r
 169 {\r
 170   std::lock_guard<std::mutex> lck(mtx);\r
 171         DLOG  << "[shrt]: " << szName << "=" << value << std::endl;\r
 172 }\r
 173 \r
 174 inline void DumpVar(const char *szName, int value)\r
 175 {\r
 176   std::lock_guard<std::mutex> lck(mtx);\r
 177         DLOG << "[int]: " << szName << "=" << value << std::endl;\r
 178 }\r
 179 \r
 180 inline void DumpVar(const char *szName, long value)\r
 181 {\r
 182   std::lock_guard<std::mutex> lck(mtx);\r
 183         DLOG << "[long]: " << szName << "=" << value << std::endl;\r
 184 }\r
 185 \r
 186 inline void DumpVar(const char *szName, double value)\r
 187 {\r
 188   std::lock_guard<std::mutex> lck(mtx);\r
 189         DLOG << "[dbl]: " << szName << "=" << value << std::endl;\r
 190 }\r
 191 \r
 192 inline void DumpVar(const char *szName, unsigned char value)\r
 193 {\r
 194   std::lock_guard<std::mutex> lck(mtx);\r
 195         DLOG << "[byte]: " << szName << "=0x" << std::hex << value << std::dec << std::endl;\r
 196 }\r
 197 \r
 198 inline void DumpVar(const char *szName, unsigned short value)\r
 199 {\r
 200   std::lock_guard<std::mutex> lck(mtx);\r
 201         DLOG << "[word]: " << szName << "=0x" << std::hex << value << std::dec << std::endl;\r
 202 }\r
 203 \r
 204 inline void DumpVar(const char *szName, unsigned int value)\r
 205 {\r
 206   std::lock_guard<std::mutex> lck(mtx);\r
 207         DLOG << "[uint]: " << szName << "=0x" << std::hex << value << std::dec << std::endl;\r
 208 }\r
 209 \r
 210 inline void DumpVar(const char *szName, unsigned long value)\r
 211 {\r
 212   std::lock_guard<std::mutex> lck(mtx);\r
 213         DLOG << "[dword]: " << szName << "=0x" << std::hex << value << std::dec << std::endl;\r
 214 }\r
 215 \r
 216 inline void DumpVar(const char *szName, const char* value)\r
 217 {\r
 218   std::lock_guard<std::mutex> lck(mtx);\r
 219         DLOG << "[str]: " << szName << "=\"" << (value ? value : "") << "\"" << std::endl;\r
 220 }\r
 221 \r
 222 inline void DumpVar(const char *szName, const std::string &value)\r
 223 {\r
 224   std::lock_guard<std::mutex> lck(mtx);\r
 225         DLOG << "[Str]: " << szName << "=\"" << value << "\"" << std::endl;\r
 226 }\r
 227 \r
 228 inline void DumpVar(const char *szName, const std::wstring &value)\r
 229 {\r
 230   std::lock_guard<std::mutex> lck(mtx);\r
 231         DLOG << "[WStr]: " << szName << "=\"" << w2s(value) << "\"" << std::endl;\r
 232 }\r
 233 \r
 234 #ifndef MB_IGNORE_QT\r
 235 inline void DumpVar(const char *szName, const QString &value)\r
 236 {\r
 237   std::lock_guard<std::mutex> lck(mtx);\r
 238         DLOG << "[QStr]: " << szName << "=\"" << value.toStdString() << "\"" << std::endl;\r
 239 }\r
 240 \r
 241 inline void DumpVar(const char *szName, const QStringList &value)\r
 242 {\r
 243   std::lock_guard<std::mutex> lck(mtx);\r
 244         DLOG << "[QStrLst]: " << szName << "=[len=" << value.length() << "] {";\r
 245   bool first = true;\r
 246   QStringList::const_iterator it = value.constBegin();\r
 247   for ( ; it != value.constEnd(); ++it)\r
 248   {\r
 249     DLOG << (first ? "" : ",") << "\"" << (*it).toStdString() << "\"";\r
 250     first = false;\r
 251   }\r
 252   DLOG << "}" << std::endl;\r
 253 }\r
 254 #endif\r
 255 \r
 256 inline void DumpVar(const char *szName, const void* value)\r
 257 {\r
 258   std::lock_guard<std::mutex> lck(mtx);\r
 259         DLOG << "[ptr]: " << szName << "=" << value << std::endl;\r
 260 }\r
 261 \r
 262 \r
 263 // Collection of primitive types\r
 264 inline void DumpVar(const char *szName, const std::set<int> &values)\r
 265 {\r
 266   std::lock_guard<std::mutex> lck(mtx);\r
 267         DLOG << "[intSet]: " << szName << "={" << values.size() << "}[";\r
 268         bool bFirst = true;\r
 269         for (auto it=values.cbegin(); it!=values.cend(); ++it) {\r
 270                 DLOG << (bFirst ? "" : ",") << *it;\r
 271     bFirst = false;\r
 272   }\r
 273         DLOG << "]" << std::endl;\r
 274 }\r
 275 \r
 276 inline void DumpVar(const char *szName, const std::vector<int> &values)\r
 277 {\r
 278   std::lock_guard<std::mutex> lck(mtx);\r
 279         DLOG << "[intVect]: " << szName << "={" << values.size() << "}[";\r
 280         bool bFirst = true;\r
 281         for (auto it=values.cbegin(); it!=values.cend(); ++it) {\r
 282                 DLOG << (bFirst ? "" : ",") << *it;\r
 283     bFirst = false;\r
 284   }\r
 285         DLOG << "]" << std::endl;\r
 286 }\r
 287 \r
 288 inline void DumpVar(const char *szName, const std::list<bool>& values)\r
 289 {\r
 290   std::lock_guard<std::mutex> lck(mtx);\r
 291         DLOG << "[boolList]: " << szName << "={" << values.size() << "}[";\r
 292         bool bFirst = true;\r
 293         for (auto it=values.cbegin(); it!=values.cend(); ++it) {\r
 294                 DLOG << (bFirst ? "" : ",") << (*it ? "Y" : "N");\r
 295     bFirst = false;\r
 296   }\r
 297         DLOG << "]" << std::endl;\r
 298 }\r
 299 \r
 300 inline void DumpVar(const char *szName, const std::list<std::string> &values)\r
 301 {\r
 302   std::lock_guard<std::mutex> lck(mtx);\r
 303         DLOG << "[strLst]: " << szName << "={" << values.size() << "}[";\r
 304         bool bFirst = true;\r
 305         for (auto it=values.cbegin(); it!=values.cend(); ++it) {\r
 306                 DLOG << (bFirst ? "\"" : ", \"") << *it << "\"";\r
 307     bFirst = false;\r
 308   }\r
 309         DLOG << "]" << std::endl;\r
 310 }\r
 311 \r
 312 #endif // MBDebug_HeaderFile\r
 313 \r