debug.h

Go to the documentation of this file.

 
#ifndef SEMF_UTILS_CORE_DEBUG_H_
#define SEMF_UTILS_CORE_DEBUG_H_
 
#include <semf/utils/core/lists/linkedlist.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
 
#ifdef USE_SEMF_DEBUG
 
#define SEMF_DEBUG_ADD_CLASS(T, level) semf::Debug<T>::debugClass(level)
#define SEMF_DEBUG_ADD_OBJECT(object, level) semf::debugObject<__COUNTER__>(object, level, #object)
 
#define SEMF_ERROR(...) semf::internalDebug(this, semf::DebugLevel::DebuglevelError, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_WARNING(...) semf::internalDebug(this, semf::DebugLevel::DebuglevelWarning, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_INFO(...) semf::internalDebug(this, semf::DebugLevel::DebuglevelInfo, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_DEBUG(...) semf::internalDebug(this, semf::DebugLevel::DebuglevelDebug, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_TRACE(...) semf::internalDebug(this, semf::DebugLevel::DebuglevelTrace, __PRETTY_FUNCTION__, ##__VA_ARGS__)
 
#define SEMF_SINGLETON_ERROR(object, ...) semf::internalDebug(object, semf::DebugLevel::DebuglevelError, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_SINGLETON_WARNING(object, ...) semf::internalDebug(object, semf::DebugLevel::DebuglevelWarning, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_SINGLETON_INFO(object, ...) semf::internalDebug(object, semf::DebugLevel::DebuglevelInfo, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_SINGLETON_DEBUG(object, ...) semf::internalDebug(object, semf::DebugLevel::DebuglevelDebug, __PRETTY_FUNCTION__, ##__VA_ARGS__)
#define SEMF_SINGLETON_TRACE(object, ...) semf::internalDebug(object, semf::DebugLevel::DebuglevelTrace, __PRETTY_FUNCTION__, ##__VA_ARGS__)
 
#else
#define SEMF_DEBUG_ADD_CLASS(T, level)
#define SEMF_DEBUG_ADD_OBJECT(object, level)
 
#define SEMF_ERROR(...)
#define SEMF_WARNING(...)
#define SEMF_INFO(...)
#define SEMF_DEBUG(...)
#define SEMF_TRACE(...)
 
#define SEMF_SINGLETON_ERROR(object, ...)
#define SEMF_SINGLETON_WARNING(object, ...)
#define SEMF_SINGLETON_INFO(object, ...)
#define SEMF_SINGLETON_DEBUG(object, ...)
#define SEMF_SINGLETON_TRACE(object, ...)
#endif  // USE_SEMF_DEBUG
 
namespace semf
{
enum class DebugLevel
{
    DebuglevelError = 0,
    DebuglevelWarning,
    DebuglevelInfo,
    DebuglevelDebug,
    DebuglevelTrace,
    DebuglevelIgnore = 255
};
 
template <class T>
class Debug : public LinkedList<Debug<T>>::Node
{
public:
    Debug(T& object, DebugLevel level, const char* name);
    virtual ~Debug() = default;
 
    static void debugClass(DebugLevel maxLevel);
    void setEnabled(bool enable = true);
    void setDisabled(bool disable = true);
    template <class... Args>
    static void print(T& object, DebugLevel level, const char* name, const char* format, Args... args);
 
private:
    static const char* levelText(DebugLevel level);
 
    static LinkedList<Debug<T>> m_list;
    static bool m_debugClass;
    static DebugLevel m_debugClassMaxLevel;
    T& m_object;
    DebugLevel m_level;
    const char* m_name;
    bool m_isEnabled = true;
};
 
template <class T>
LinkedList<Debug<T>> Debug<T>::m_list;
 
template <class T>
#ifdef SEMF_DEBUG_ALL
bool Debug<T>::m_debugClass = true;
#else
bool Debug<T>::m_debugClass = false;
#endif
 
template <class T>
DebugLevel Debug<T>::m_debugClassMaxLevel = DebugLevel::DebuglevelIgnore;
 
template <class T>
Debug<T>::Debug(T& object, DebugLevel level, const char* name)
: m_object(object),
  m_level(level),
  m_name(name)
{
    m_list.pushFront(*this);
}
 
template <class T>
void Debug<T>::debugClass(DebugLevel maxLevel)
{
    m_debugClass = true;
    m_debugClassMaxLevel = maxLevel;
}
 
template <class T>
void Debug<T>::setEnabled(bool enable)
{
    m_isEnabled = enable;
}
 
template <class T>
void Debug<T>::setDisabled(bool disable)
{
    setEnabled(!disable);
}
 
template <class T>
template <class... Args>
void Debug<T>::print(T& object, DebugLevel level, const char* name, const char* format, Args... args)
{
    // Returning for nothing to debug
    if (m_list.empty() && !m_debugClass)
        return;
 
    // Checking all registered objects
    for (auto& it : m_list)
    {
        if (&object == &it.m_object && level <= it.m_level && it.m_isEnabled)
        {
            printf("%s %s %s: ", name, it.m_name, levelText(level));
            printf(format, args...);
            printf("\n");
            return;
        }
    }
 
    // Checking whole class debug settings
    if (m_debugClass && level <= m_debugClassMaxLevel)
    {
        printf("%s %s: ", name, levelText(level));
        printf(format, args...);
        printf("\n");
    }
}
 
template <class T>
const char* Debug<T>::levelText(DebugLevel level)
{
    switch (level)
    {
        case DebugLevel::DebuglevelError:
            return "(e)";
        case DebugLevel::DebuglevelWarning:
            return "(w)";
        case DebugLevel::DebuglevelInfo:
            return "(i)";
        case DebugLevel::DebuglevelDebug:
            return "(d)";
        case DebugLevel::DebuglevelTrace:
        default:
            return "(t)";
    }
}
 
template <class T, class... Args>
void internalDebug(T* object, DebugLevel level, const char* name, const char* format, Args... args)
{
    Debug<T>::print(*object, level, name, format, args...);
}
 
template <int i, class T>
void debugObject(T& object, DebugLevel level, const char* name)
{
    static Debug<T> debugObj(object, level, name);
}
}  // namespace semf
#endif /* SEMF_UTILS_CORE_DEBUG_H_ */