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(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 final
  {
    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_ */