SDL3pp_error.h

#ifndef SDL3PP_ERROR_H_
#define SDL3PP_ERROR_H_
 
#include <exception>
#include <format>
#include <SDL3/SDL_error.h>
#include "SDL3pp_strings.h"
 
namespace SDL {
 
inline bool SetErrorUnformatted(StringParam message)
{
  return SDL_SetError("%s", static_cast<const char*>(message));
}
 
template<class... ARGS>
inline bool SetError(std::string_view fmt, ARGS... args)
{
  return SetError(
    std::vformat(fmt, std::make_format_args(std::forward<ARGS>(args)...)));
}
 
inline bool OutOfMemory() { return SDL_OutOfMemory(); }
 
inline const char* GetError() { return SDL_GetError(); }
 
class Error : public std::exception
{
  std::string m_message;
 
public:
  Error()
    : m_message(SDL_GetError())
  {
  }
 
  Error(std::string message)
    : m_message(std::move(message))
  {
  }
 
  constexpr const char* what() const noexcept { return m_message.c_str(); }
 
  constexpr const std::string& str() const noexcept { return m_message; }
};
 
constexpr void CheckError(bool result)
{
  if (!result) throw Error();
}
 
template<class T>
constexpr T CheckError(T result)
{
  if (!result) throw Error();
  return result;
}
 
template<class T>
constexpr T CheckError(T result, T invalidValue)
{
  if (result == invalidValue) throw Error();
  return result;
}
 
template<class T>
constexpr void CheckErrorIfNot(T result, T validValue)
{
  if (result != validValue) throw Error();
}
 
inline bool ClearError() { return SDL_ClearError(); }
 
#ifdef SDL3PP_DOC
 
#define SDL_Unsupported() SDL_SetError("That operation is not supported")
 
#define SDL_InvalidParamError(param)                                           \
  SDL_SetError("Parameter '%s' is invalid", (param))
 
#endif // SDL3PP_DOC
 
 
} // namespace SDL
 
#endif /* SDL3PP_ERROR_H_ */