logger.h

Go to the documentation of this file.

#pragma once
 
#include "global.h"
#include <array>
#include <iomanip>
#include <ios>
#include <ostream>
#include <sstream>
#include <string>
#if IS_QT
  #include <QString>
#else
  #include <cstdint>
#endif
 
namespace sf
{

_LOG_FUNC void setLogMessagePattern(const std::string& pattern);

enum class LogLevel : uint8_t
{
  Debug = 0,
  Info,
  Warning,
  Critical,
};

class _LOG_CLASS LoggingCategory
{
 
  public:
    explicit LoggingCategory(const char* name);

    ~LoggingCategory();
 
    // Prevent copying and moving to preserve category identity and bridge safety.
    LoggingCategory(const LoggingCategory&) = delete;
    LoggingCategory& operator=(const LoggingCategory&) = delete;
    LoggingCategory(LoggingCategory&&) = delete;
    LoggingCategory& operator=(LoggingCategory&&) = delete;

    const char* categoryName() const noexcept;

    bool isEnabled(LogLevel level) const noexcept;

    void setEnabled(LogLevel level, bool enable) noexcept;
 
  private:
    const char* _name{nullptr};
    std::array<bool, 4> _enabledLevels{true, true, true, true};
 
    class Private;
    Private* _d{nullptr};
};

struct LogLocation
{
    const char* file{nullptr};
    int line{0};
    const char* function{nullptr};
    const char* categoryName{nullptr};
};

using LogHandler = void (*)(LogLevel level, const LogLocation& location, const std::string& message);

_LOG_FUNC LogHandler installLogHandler(LogHandler handler);

_LOG_FUNC LogHandler defaultLogHandler();

class _LOG_CLASS LogStream
{
  public:
    LogStream()
    {
      _buffer << std::boolalpha;
    }

    LogStream(const LogStream&) = delete;

    LogStream(const LogStream&&) = delete;

    LogStream& operator=(const LogStream&) = delete;

    LogStream& operator=(const LogStream&&) = delete;

    ~LogStream() = default;

    void escapeString(const std::string& str);

    template<typename T>
    LogStream& operator<<(const T& value)
    {
      if constexpr (std::is_base_of_v<std::string, std::decay_t<T>>)
      {
        escapeString(value);
      }
#if IS_QT_TARGET
      else if constexpr (std::is_base_of_v<QString, std::decay_t<T>>)
      {
        escapeString(value.toStdString());
      }
#endif
      else
      {
        _buffer << value;
      }
      if (_space)
      {
        _buffer << ' ';
      }
      return *this;
    }

    LogStream& operator<<(std::ostream& (*manip)(std::ostream&) )
    {
      manip(_buffer);
      return *this;
    }

    LogStream& operator<<(std::ios_base& (*manip)(std::ios_base&) )
    {
      manip(_buffer);
      return *this;
    }

    std::string str() const
    {
      return _buffer.str();
    }
 
    LogStream& nospace()
    {
      _space = false;
      return *this;
    }
 
  private:
    std::ostringstream _buffer;
    bool _space{true};
};

class _LOG_CLASS LogMessage
{
  public:
    LogMessage(LogLevel level, const LoggingCategory& category, const char* file, int line, const char* function);

    ~LogMessage();
 
    LogMessage(const LogMessage&) = delete;
    LogMessage& operator=(const LogMessage&) = delete;
    LogMessage(LogMessage&&) = delete;
    LogMessage& operator=(LogMessage&&) = delete;

    LogStream& stream() noexcept
    {
      return _stream;
    }
 
  private:
    LogLevel _level;
    const LoggingCategory& _category;
    const char* _file{nullptr};
    int _line{0};
    const char* _function{nullptr};
    LogStream _stream;
};

class LogMessageVoidify
{
  public:
    template<typename T>
    void operator&(const T& value) const noexcept
    {}
};
 
}// namespace sf

#define SF_DECLARE_LOGGING_CATEGORY(name) static const sf::LoggingCategory& name();

#define SF_LOGGING_CATEGORY(name, stringName)                                                                                                                  \
  static const sf::LoggingCategory& name()                                                                                                                     \
  {                                                                                                                                                            \
    static const sf::LoggingCategory category(stringName);                                                                                                     \
    return category;                                                                                                                                           \
  }
 
#define SF_MESSAGE_LOGGER_COMMON(category, level)                                                                                                              \
  if (category().isEnabled(level))                                                                                                                             \
  sf::LogMessage(level, category(), __FILE__, __LINE__, __func__).stream()
 
#ifndef SF_NO_DEBUG_OUTPUT
  #define sfCDebug(category) SF_MESSAGE_LOGGER_COMMON(category, sf::LogLevel::Debug)
#else
  #define sfCDebug(category)                                                                                                                                   \
    while (false)                                                                                                                                              \
    sf::LogMessageVoidify() & sf::LogMessage(sf::LogLevel::Debug, category(), __FILE__, __LINE__, __func__).stream()
#endif
 
#ifndef SF_NO_INFO_OUTPUT
  #define sfCInfo(category) SF_MESSAGE_LOGGER_COMMON(category, sf::LogLevel::Info)
#else
  #define sfCInfo(category)                                                                                                                                    \
    while (false)                                                                                                                                              \
    sf::LogMessageVoidify() & sf::LogMessage(sf::LogLevel::Info, category(), __FILE__, __LINE__, __func__).stream()
#endif
 
#ifndef SF_NO_WARNING_OUTPUT
  #define sfCWarning(category) SF_MESSAGE_LOGGER_COMMON(category, sf::LogLevel::Warning)
#else
  #define sfCWarning(category)                                                                                                                                 \
    while (false)                                                                                                                                              \
    sf::LogMessageVoidify() & sf::LogMessage(sf::LogLevel::Warning, category(), __FILE__, __LINE__, __func__).stream()
#endif
 
#define sfCCritical(category) SF_MESSAGE_LOGGER_COMMON(category, sf::LogLevel::Critical)