SDL3pp_log.h

#ifndef SDL3PP_LOG_H_
#define SDL3PP_LOG_H_
 
#include <format>
#include <SDL3/SDL_log.h>
#include "SDL3pp_callbackWrapper.h"
#include "SDL3pp_error.h"
#include "SDL3pp_strings.h"
 
namespace SDL {
 
using LogCategoryRaw = SDL_LogCategory;
 
// Forward decl
struct LogCategory;
 
using LogPriority = SDL_LogPriority;
 
constexpr LogPriority LOG_PRIORITY_INVALID =
  SDL_LOG_PRIORITY_INVALID; 
 
constexpr LogPriority LOG_PRIORITY_TRACE = SDL_LOG_PRIORITY_TRACE; 
 
constexpr LogPriority LOG_PRIORITY_VERBOSE =
  SDL_LOG_PRIORITY_VERBOSE; 
 
constexpr LogPriority LOG_PRIORITY_DEBUG = SDL_LOG_PRIORITY_DEBUG; 
 
constexpr LogPriority LOG_PRIORITY_INFO = SDL_LOG_PRIORITY_INFO; 
 
constexpr LogPriority LOG_PRIORITY_WARN = SDL_LOG_PRIORITY_WARN; 
 
constexpr LogPriority LOG_PRIORITY_ERROR = SDL_LOG_PRIORITY_ERROR; 
 
constexpr LogPriority LOG_PRIORITY_CRITICAL =
  SDL_LOG_PRIORITY_CRITICAL; 
 
constexpr LogPriority LOG_PRIORITY_COUNT = SDL_LOG_PRIORITY_COUNT; 
 
 
class LogCategory
{
  LogCategoryRaw m_category;
 
public:
  constexpr LogCategory(LogCategoryRaw category = SDL_LOG_CATEGORY_APPLICATION)
    : m_category(category)
  {
  }
 
  constexpr explicit LogCategory(int category)
    : m_category(SDL_LogCategory(category))
  {
  }
 
  constexpr operator LogCategoryRaw() const { return m_category; }
 
  void SetLogPriority(LogPriority priority) const;
 
  LogPriority GetLogPriority() const;
 
  void LogUnformatted(LogPriority priority, StringParam message) const
  {
    SDL_LogMessage(m_category, priority, "%s", (const char*)(message));
  }
 
  template<class... ARGS>
  void LogMessage(LogPriority priority,
                  std::string_view fmt,
                  ARGS... args) const;
 
  template<class... ARGS>
  void LogTrace(std::string_view fmt, ARGS&&... args) const;
 
  template<class... ARGS>
  void LogVerbose(std::string_view fmt, ARGS&&... args) const;
 
  template<class... ARGS>
  void LogDebug(std::string_view fmt, ARGS&&... args) const;
 
  template<class... ARGS>
  void LogInfo(std::string_view fmt, ARGS&&... args) const;
 
  template<class... ARGS>
  void LogWarn(std::string_view fmt, ARGS&&... args) const;
 
  template<class... ARGS>
  void LogError(std::string_view fmt, ARGS&&... args) const;
 
  template<class... ARGS>
  void LogCritical(std::string_view fmt, ARGS&&... args) const;
};
 
constexpr LogCategory LOG_CATEGORY_APPLICATION =
  SDL_LOG_CATEGORY_APPLICATION; 
 
constexpr LogCategory LOG_CATEGORY_ERROR = SDL_LOG_CATEGORY_ERROR; 
 
constexpr LogCategory LOG_CATEGORY_ASSERT = SDL_LOG_CATEGORY_ASSERT; 
 
constexpr LogCategory LOG_CATEGORY_SYSTEM = SDL_LOG_CATEGORY_SYSTEM; 
 
constexpr LogCategory LOG_CATEGORY_AUDIO = SDL_LOG_CATEGORY_AUDIO; 
 
constexpr LogCategory LOG_CATEGORY_VIDEO = SDL_LOG_CATEGORY_VIDEO; 
 
constexpr LogCategory LOG_CATEGORY_RENDER = SDL_LOG_CATEGORY_RENDER; 
 
constexpr LogCategory LOG_CATEGORY_INPUT = SDL_LOG_CATEGORY_INPUT; 
 
constexpr LogCategory LOG_CATEGORY_TEST = SDL_LOG_CATEGORY_TEST; 
 
constexpr LogCategory LOG_CATEGORY_GPU = SDL_LOG_CATEGORY_GPU; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED2 =
  SDL_LOG_CATEGORY_RESERVED2; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED3 =
  SDL_LOG_CATEGORY_RESERVED3; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED4 =
  SDL_LOG_CATEGORY_RESERVED4; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED5 =
  SDL_LOG_CATEGORY_RESERVED5; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED6 =
  SDL_LOG_CATEGORY_RESERVED6; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED7 =
  SDL_LOG_CATEGORY_RESERVED7; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED8 =
  SDL_LOG_CATEGORY_RESERVED8; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED9 =
  SDL_LOG_CATEGORY_RESERVED9; 
 
constexpr LogCategory LOG_CATEGORY_RESERVED10 =
  SDL_LOG_CATEGORY_RESERVED10; 
 
constexpr LogCategory LOG_CATEGORY_CUSTOM = SDL_LOG_CATEGORY_CUSTOM; 
 
inline void SetLogPriorities(LogPriority priority)
{
  SDL_SetLogPriorities(priority);
}
 
inline void SetLogPriority(int category, LogPriority priority)
{
  SDL_SetLogPriority(category, priority);
}
 
inline void LogCategory::SetLogPriority(LogPriority priority) const
{
  SDL::SetLogPriority(m_category, priority);
}
 
inline LogPriority GetLogPriority(int category)
{
  return SDL_GetLogPriority(category);
}
 
inline LogPriority LogCategory::GetLogPriority() const
{
  return SDL::GetLogPriority(m_category);
}
 
inline void ResetLogPriorities() { SDL_ResetLogPriorities(); }
 
inline void SetLogPriorityPrefix(LogPriority priority, StringParam prefix)
{
  CheckError(SDL_SetLogPriorityPrefix(priority, prefix));
}
 
inline void LogUnformatted(LogCategory category,
                           LogPriority priority,
                           StringParam message)
{
  SDL_LogMessage(category, priority, "%s", static_cast<const char*>(message));
}
 
inline void LogUnformatted(StringParam message)
{
  SDL_Log("%s", static_cast<const char*>(message));
}
 
template<class... ARGS>
inline void Log(std::string_view fmt, ARGS&&... args)
{
  LOG_CATEGORY_APPLICATION.LogInfo(fmt, std::forward<ARGS>(args)...);
}
 
template<class... ARGS>
inline void LogMessage(LogCategory category,
                       LogPriority priority,
                       std::string_view fmt,
                       ARGS... args)
{
  LogUnformatted(
    category, priority, std::vformat(fmt, std::make_format_args(args...)));
}
 
template<class... ARGS>
inline void LogCategory::LogMessage(LogPriority priority,
                                    std::string_view fmt,
                                    ARGS... args) const
{
  SDL::LogMessage(m_category, priority, fmt, args...);
}
 
template<class... ARGS>
inline void LogTrace(LogCategory category, std::string_view fmt, ARGS&&... args)
{
  LogMessage(category, LOG_PRIORITY_TRACE, fmt, args...);
}
 
template<class... ARGS>
inline void LogCategory::LogTrace(std::string_view fmt, ARGS&&... args) const
{
  SDL::LogTrace(m_category, fmt, args...);
}
 
template<class... ARGS>
inline void LogVerbose(LogCategory category,
                       std::string_view fmt,
                       ARGS&&... args)
{
  LogMessage(category, LOG_PRIORITY_VERBOSE, fmt, args...);
}
 
template<class... ARGS>
inline void LogCategory::LogVerbose(std::string_view fmt, ARGS&&... args) const
{
  SDL::LogVerbose(m_category, fmt, args...);
}
 
template<class... ARGS>
inline void LogDebug(LogCategory category, std::string_view fmt, ARGS&&... args)
{
  LogMessage(category, LOG_PRIORITY_DEBUG, fmt, args...);
}
 
template<class... ARGS>
inline void LogCategory::LogDebug(std::string_view fmt, ARGS&&... args) const
{
  SDL::LogDebug(m_category, fmt, args...);
}
 
template<class... ARGS>
inline void LogInfo(LogCategory category, std::string_view fmt, ARGS&&... args)
{
  LogMessage(category, LOG_PRIORITY_INFO, fmt, args...);
}
 
template<class... ARGS>
inline void LogCategory::LogInfo(std::string_view fmt, ARGS&&... args) const
{
  SDL::LogInfo(m_category, fmt, args...);
}
 
template<class... ARGS>
inline void LogWarn(LogCategory category, std::string_view fmt, ARGS&&... args)
{
  LogMessage(category, SDL_LOG_PRIORITY_WARN, fmt, args...);
}
 
template<class... ARGS>
inline void LogCategory::LogWarn(std::string_view fmt, ARGS&&... args) const
{
  SDL::LogWarn(m_category, fmt, args...);
}
 
template<class... ARGS>
inline void LogError(LogCategory category, std::string_view fmt, ARGS&&... args)
{
  LogMessage(category, SDL_LOG_PRIORITY_ERROR, fmt, args...);
}
 
template<class... ARGS>
inline void LogCategory::LogError(std::string_view fmt, ARGS&&... args) const
{
  SDL::LogError(m_category, fmt, args...);
}
 
template<class... ARGS>
inline void LogCritical(LogCategory category,
                        std::string_view fmt,
                        ARGS&&... args)
{
  LogMessage(category, SDL_LOG_PRIORITY_CRITICAL, fmt, args...);
}
 
template<class... ARGS>
inline void LogCategory::LogCritical(std::string_view fmt, ARGS&&... args) const
{
  SDL::LogCritical(m_category, fmt, args...);
}
 
using LogOutputFunction = SDL_LogOutputFunction;
 
using LogOutputCB = std::function<void(LogCategory, LogPriority, const char*)>;
 
inline LogOutputFunction GetDefaultLogOutputFunction()
{
  return SDL_GetDefaultLogOutputFunction();
}
 
inline void GetLogOutputFunction(LogOutputFunction* callback, void** userdata)
{
  SDL_GetLogOutputFunction(callback, userdata);
}
 
inline LogOutputCB GetLogOutputFunction()
{
  using Wrapper = UniqueCallbackWrapper<LogOutputCB>;
  LogOutputFunction cb;
  void* userdata;
  GetLogOutputFunction(&cb, &userdata);
  if (userdata == nullptr) {
    return [cb](LogCategory c, LogPriority p, StringParam m) {
      cb(nullptr, c, p, m);
    };
  }
  if (auto cb = Wrapper::at(userdata)) return cb;
  return [cb, userdata](LogCategory c, LogPriority p, StringParam m) {
    cb(userdata, c, p, m);
  };
}
 
inline void SetLogOutputFunction(LogOutputFunction callback, void* userdata)
{
  UniqueCallbackWrapper<LogOutputCB>::erase();
  return SDL_SetLogOutputFunction(callback, userdata);
}
 
inline void SetLogOutputFunction(LogOutputCB callback)
{
  using Wrapper = UniqueCallbackWrapper<LogOutputCB>;
  SDL_SetLogOutputFunction(
    [](
      void* userdata, int category, LogPriority priority, const char* message) {
      return Wrapper::Call(userdata, LogCategory{category}, priority, message);
    },
    Wrapper::Wrap(std::move(callback)));
}
 
inline void ResetLogOutputFunction()
{
  return SetLogOutputFunction(GetDefaultLogOutputFunction(), nullptr);
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_LOG_H_ */