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) noexcept
    : m_category(category)
  {
  }

  constexpr explicit LogCategory(int category)
    : m_category(SDL_LogCategory(category))
  {
  }

  constexpr operator LogCategoryRaw() const noexcept { 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 = void(SDLCALL*)(void* userdata,
                                         int category,
                                         LogPriority priority,
                                         const char* message);

using LogOutputCB = MakeFrontCallback<
  void(int category, LogPriority priority, const char* message)>;

inline LogOutputFunction GetDefaultLogOutputFunction()
{
  return SDL_GetDefaultLogOutputFunction();
}

inline void GetLogOutputFunction(LogOutputFunction* callback, void** userdata)
{
  SDL_GetLogOutputFunction(callback, userdata);
}

inline void SetLogOutputFunction(LogOutputFunction callback, void* userdata)
{
  SDL_SetLogOutputFunction(callback, userdata);
}

inline void SetLogOutputFunction(LogOutputCB callback)
{
  SetLogOutputFunction(callback.wrapper, callback.data);
}

inline void ResetLogOutputFunction()
{
  return SetLogOutputFunction(GetDefaultLogOutputFunction(), nullptr);
}

 
} // namespace SDL
 
#endif /* SDL3PP_LOG_H_ */