dbgutils.h

Go to the documentation of this file.

 
#pragma once
#include <cstring>
#include <iomanip>
#include <misc/global.h>
#include <utility>
 
#if IS_QT
  #include <QDebug>
  #include <QString>
  #include <QtGlobal>
#endif
 
// This define should be defined externally in the project or make file.
#ifndef SF_DEBUG_LEVEL
  #define SF_DEBUG_LEVEL 1
#endif
 
// Coverts the passed type into a name.
#define SF_RTTI_NAME(self) sf::demangleTypeName(typeid(self).name())
// Full current class member function name.
#define SF_RTTI_FUNCTION SF_RTTI_TYPENAME.append("::").append(__FUNCTION__)
// Define that converts a 'this' pointer to the class type name.
#define SF_RTTI_TYPENAME SF_RTTI_NAME(*this)
// Only the filename part of __FILE__.
#define SF_FILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 
#if IS_QT
 
  // Converts the passed type into a name.
  #define SF_Q_RTTI_NAME(self) QString::fromStdString(SF_RTTI_NAME(self))
  // Define that converts a 'this' pointer to the class type name.
  #define SF_Q_RTTI_TYPENAME SF_Q_RTTI_NAME(*this)
 
inline QDebug& operator<<(QDebug& qd, const std::string& ss)
{
  return qd << QString::fromStdString(ss);
}
 
namespace sf
{
 
class _MISC_CLASS MessageHandler
{
  public:
    static void enable(bool enabled = true);
 
  private:
    static QtMessageHandler _initial;
 
    static void _handler(QtMsgType type, const QMessageLogContext& ctx, const QString& msg);
};
 
}// namespace sf
 
#endif
 
namespace sf
{
enum EDebugOutputType : int
{
  dotThrow = 1U << 0U,
  dotMessageBox = 1U << 1U,
  dotStdLog = 1U << 2U,
  dotStdOut = 1U << 3U,
  dotStdErr = 1U << 4U,
  dotDebugString = 1U << 5U,
  dotDebugBreak = 1U << 6U,
  dotDefault = 1U << 7U
};
 
_MISC_FUNC void UserOutputDebugString(unsigned int type, const char* str) noexcept;
 
_MISC_FUNC void SetDefaultDebugOutput(unsigned int type);
 
_MISC_FUNC unsigned int GetDefaultDebugOutput();
 
_MISC_FUNC std::string getBacktrace();
 
_MISC_FUNC void printBacktrace(std::ostream& os);
 
_MISC_FUNC bool isDebug();
 
_MISC_FUNC bool isDebuggerActive();
 
_MISC_FUNC void debugBreak();
 
_MISC_FUNC void freeConsole(bool always = false);
 
_MISC_FUNC std::string demangleTypeName(const char* name);
 
template<typename T>
std::string getTypeName(const T ptr)
{
  // Only pointer are allowed.
  static_assert(std::is_pointer_v<T>);
  // When not null dereference to get the implementation name.
  if (ptr)
    return demangleTypeName(typeid(*ptr).name());
  //
  return demangleTypeName(typeid(ptr).name());
}
 
class notify_exception : public std::exception
{
  public:
    explicit notify_exception(std::string s)
      : msg(std::move(s))
    {}
 
    [[nodiscard]] const char* what() const noexcept override
    {
      return msg.c_str();
    }
 
  private:
    std::string msg;
};
 
class _MISC_CLASS debug_ostream : public std::ostringstream
{
  public:
    explicit debug_ostream(int type)
      : std::ostringstream()
      , _type(type)
    {}
 
    ~debug_ostream() override;
 
  private:
    int _type;
};
 
}// namespace sf
 
// Defined types of debug output of which combinations are allowed.
#define DO_DEFAULT sf::dotDefault
#define DO_COUT sf::dotStdOut
#define DO_CLOG sf::dotStdLog
#define DO_CERR sf::dotStdErr
#define DO_MSGBOX sf::dotMessageBox
#define DO_DBGSTR sf::dotDebugString
#define DO_DBGBRK sf::dotDebugBreak
 
// Class name and file name separator character
#define SF_CLS_SEP ';'
 
// clang-format off
 
#if (SF_DEBUG_LEVEL == 1)
 
  #define SF_NORM_NOTIFY(f, a) \
    { \
      sf::debug_ostream(f) << a; \
    }
// Only Clang and GNU have __PRETTY_FUNCTION__ defined.
  #if defined(__clang__) || defined(__GNUC__)
    #define SF_FUNC_NOTIFY(f, a) \
      { \
        sf::debug_ostream(f) << __PRETTY_FUNCTION__ << ' ' << a; \
      }
  #else
    #define SF_FUNC_NOTIFY(f, a) \
      { \
        sf::debug_ostream(f) << __FUNCTION__ << "() " << a; \
      }
  #endif
  #define SF_RTTI_NOTIFY(f, a) \
    { \
      sf::debug_ostream(f) << SF_RTTI_TYPENAME << "::" << __FUNCTION__ << SF_CLS_SEP << " " << a; \
    }
  #define SF_COND_NORM_NOTIFY(p, f, a) \
    { \
      if (p) \
      { \
        SF_NORM_NOTIFY(f, a); \
      } \
    }
  #define SF_COND_FUNC_NOTIFY(p, f, a) \
    { \
      if (p) \
      { \
        SF_FUNC_NOTIFY(f, a); \
      } \
    }
  #define SF_COND_RTTI_NOTIFY(p, f, a) \
    { \
      if (p) \
      { \
        SF_RTTI_NOTIFY(f, a); \
      } \
    }
  #if IS_QT
    #define SF_Q_NOTIFY(a) \
      { \
        qDebug() << a; \
      }
  #endif
 
#elif (SF_DEBUG_LEVEL == 2)
 
  #define _NORM_NOTIFY(f, a) \
    { \
      sf::debug_ostream(f) << __FUNCTION__ << ' ' << __FILENAME__ << ':' << __LINE__ << '@' << '\t' << a; \
    }
// Only Clang and GNU have __PRETTY_FUNCTION__ defined.
  #if defined(__clang__) || defined(__GNUC__)
    #define SF_FUNC_NOTIFY(f, a) \
      { \
        sf::debug_ostream(f) << __PRETTY_FUNCTION__ << ' ' << __FILENAME__ << ':' << __LINE__ << '@' << '\t' << a; \
      }
  #else
    #define SF_FUNC_NOTIFY(f, a) \
      { \
        sf::debug_ostream(f) << __FUNCTION__ << "() " << __FILENAME__ << ':' << __LINE__ << '@' << '\t' << a; \
      }
  #endif
  #define _RTTI_NOTIFY(f, a) \
    { \
      sf::debug_ostream(f) << _RTTI_TYPENAME << "::" << __FUNCTION__ << ' ' << SF_CLS_SEP << __FILENAME__ << ':' << __LINE__ << '@' << '\t' << a; \
    }
  #define _COND_NORM_NOTIFY(p, f, a) \
    { \
      if (p) \
      { \
        _NORM_NOTIFY(f, a); \
      } \
    }
  #define _COND_FUNC_NOTIFY(p, f, a) \
    { \
      if (p) \
      { \
        _FUNC_NOTIFY(f, a); \
      } \
    }
  #define _COND_RTTI_NOTIFY(p, f, a) \
    { \
      if (p) \
      { \
        _RTTI_NOTIFY(f, a); \
      } \
    }
  #if IS_QT
    #define SF_Q_NOTIFY(a) \
      { \
        qDebug() << a; \
      }
  #endif
 
#else// _DEBUG_LEVEL == 0
 
  #define _NORM_NOTIFY(f, a) {}
  #define _FUNC_NOTIFY(f, a) {}
  #define _RTTI_NOTIFY(f, a) {}
  #define _COND_NOTIFY(p, f, a) {}
  #define _COND_FUNC_NOTIFY(p, f, a) {}
  #define _COND_RTTI_NOTIFY(p, f, a) {}
  #if IS_QT
    #define SF_Q_NOTIFY(a) {}
  #endif
 
#endif//DEBUG_LEVEL
 
// clang-format on