SDL3pp_log.h

#ifndef SDL3PP_LOG_H_
#define SDL3PP_LOG_H_
 
#include <format>
#include <SDL3/SDL_log.h>
#include "SDL3pp_stdinc.h"
 
namespace SDL {
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
{
  int m_category;
 
public:
  constexpr explicit LogCategory(int category)
    : m_category(category)
  {
  }
 
  constexpr LogCategory(SDL_LogCategory category = SDL_LOG_CATEGORY_APPLICATION)
    : m_category(category)
  {
  }
 
  constexpr operator int() { return m_category; }
 
  constexpr operator SDL_LogCategory() { return SDL_LogCategory(m_category); }
 
  constexpr auto operator<=>(const LogCategory& other) const = default;
 
  static void SetLogPriorities(LogPriority priority)
  {
    return SDL_SetLogPriorities(priority);
  }
 
  void SetLogPriority(LogPriority priority)
  {
    return SDL_SetLogPriority(m_category, priority);
  }
 
  LogPriority GetLogPriority() const { return SDL_GetLogPriority(m_category); }
 
  static void ResetLogPriorities() { return SDL_ResetLogPriorities(); }
 
  void LogUnformatted(LogPriority priority, StringParam message) const
  {
    return SDL_LogMessage(m_category, priority, "%s", (const char*)(message));
  }
 
  template<class... ARGS>
  void Log(LogPriority priority, std::string_view fmt, ARGS... args) const
  {
    return LogUnformatted(priority,
                          std::vformat(fmt, std::make_format_args(args...)));
  }
 
  template<class... ARGS>
  void LogTrace(std::string_view fmt, ARGS&&... args) const
  {
    return Log(SDL_LOG_PRIORITY_TRACE, fmt, std::forward<ARGS>(args)...);
  }
 
  template<class... ARGS>
  void LogVerbose(std::string_view fmt, ARGS&&... args) const
  {
    return Log(SDL_LOG_PRIORITY_VERBOSE, fmt, std::forward<ARGS>(args)...);
  }
 
  template<class... ARGS>
  void LogDebug(std::string_view fmt, ARGS&&... args) const
  {
    return Log(SDL_LOG_PRIORITY_DEBUG, fmt, std::forward<ARGS>(args)...);
  }
 
  template<class... ARGS>
  void LogInfo(std::string_view fmt, ARGS&&... args) const
  {
    return Log(SDL_LOG_PRIORITY_INFO, fmt, std::forward<ARGS>(args)...);
  }
 
  template<class... ARGS>
  void LogWarn(std::string_view fmt, ARGS&&... args) const
  {
    return Log(SDL_LOG_PRIORITY_WARN, fmt, std::forward<ARGS>(args)...);
  }
 
  template<class... ARGS>
  void LogError(std::string_view fmt, ARGS&&... args) const
  {
    return Log(SDL_LOG_PRIORITY_ERROR, fmt, std::forward<ARGS>(args)...);
  }
 
  template<class... ARGS>
  void LogCritical(std::string_view fmt, ARGS&&... args) const
  {
    return Log(SDL_LOG_PRIORITY_CRITICAL, fmt, std::forward<ARGS>(args)...);
  }
};
 
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 SetLogPriorityPrefix(LogPriority priority, StringParam prefix)
{
  CheckError(SDL_SetLogPriorityPrefix(priority, prefix));
}
 
template<class... ARGS>
inline void Log(std::string_view fmt, ARGS&&... args)
{
  LOG_CATEGORY_APPLICATION.Log(
    LOG_PRIORITY_INFO, fmt, std::forward<ARGS>(args)...);
}
 
inline void LogUnformatted(StringParam message)
{
  SDL_Log("%s", static_cast<const char*>(message));
}
 
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)
{
  return 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_ */