SDL3pp_assert.h

#ifndef SDL3PP_ASSERT_H_
#define SDL3PP_ASSERT_H_
 
#include <SDL3/SDL_assert.h>
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
#ifdef SDL3PP_DOC
 
#define SDL_ASSERT_LEVEL SomeNumberBasedOnVariousFactors
 
#define SDL_TriggerBreakpoint() TriggerABreakpointInAPlatformSpecificManner
 
#define SDL_FUNCTION __FUNCTION__
 
#define SDL_FILE __FILE__
 
#define SDL_LINE __LINE__
 
#define SDL_NULL_WHILE_LOOP_CONDITION (0)
 
#define SDL_disabled_assert(condition)                                         \
  do {                                                                         \
    (void)sizeof((condition));                                                 \
  } while (SDL_NULL_WHILE_LOOP_CONDITION)
#define SDL_disabled_assert(condition)                                         \ …
 
#endif // SDL3PP_DOC
 
using AssertState = SDL_AssertState;
 
constexpr AssertState ASSERTION_RETRY = SDL_ASSERTION_RETRY;
 
constexpr AssertState ASSERTION_BREAK = SDL_ASSERTION_BREAK;
 
constexpr AssertState ASSERTION_ABORT = SDL_ASSERTION_ABORT;
 
constexpr AssertState ASSERTION_IGNORE = SDL_ASSERTION_IGNORE;
 
constexpr AssertState ASSERTION_ALWAYS_IGNORE = SDL_ASSERTION_ALWAYS_IGNORE;
 
using AssertData = SDL_AssertData;
 
inline AssertState ReportAssertion(AssertData* data,
                                   StringParam func,
                                   StringParam file,
                                   int line)
{
  return SDL_ReportAssertion(data, func, file, line);
}
inline AssertState ReportAssertion(AssertData* data, {…}
 
#ifdef SDL3PP_DOC
 
#define SDL_AssertBreakpoint() SDL_TriggerBreakpoint()
 
#define SDL_enabled_assert(condition)                                          \
  do {                                                                         \
    while (!(condition)) {                                                     \
      static struct SDL_AssertData sdl_assert_data = {                         \
        0, 0, #condition, 0, 0, 0, 0};                                         \
      const SDL_AssertState sdl_assert_state = SDL_ReportAssertion(            \
        &sdl_assert_data, SDL_FUNCTION, SDL_FILE, SDL_LINE);                   \
      if (sdl_assert_state == SDL_ASSERTION_RETRY) {                           \
        continue; /* go again. */                                              \
      } else if (sdl_assert_state == SDL_ASSERTION_BREAK) {                    \
        SDL_AssertBreakpoint();                                                \
      }                                                                        \
      break; /* not retrying. */                                               \
    }                                                                          \
  } while (SDL_NULL_WHILE_LOOP_CONDITION)
#define SDL_enabled_assert(condition)                                          \ …
 
#define SDL_assert(condition)                                                  \
  if (assertion_enabled && (condition)) { trigger_assertion; }
#define SDL_assert(condition)                                                  \ …
 
#define SDL_assert_release(condition) SDL_disabled_assert(condition)
 
#define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
 
#define SDL_assert_always(condition) SDL_enabled_assert(condition)
 
#endif // SDL3PP_DOC
 
using AssertionHandler = SDL_AssertionHandler;
 
using AssertionHandlerCB =
  std::function<SDL_AssertState(const SDL_AssertData*)>;
 
inline void SetAssertionHandler(AssertionHandler handler, void* userdata)
{
  UniqueCallbackWrapper<AssertionHandlerCB>::erase();
  return SDL_SetAssertionHandler(handler, userdata);
}
inline void SetAssertionHandler(AssertionHandler handler, void* userdata) {…}
 
inline void SetAssertionHandler(AssertionHandlerCB handler)
{
  using Wrapper = UniqueCallbackWrapper<AssertionHandlerCB>;
  SetAssertionHandler(&Wrapper::CallSuffixed,
                      Wrapper::Wrap(std::move(handler)));
}
inline void SetAssertionHandler(AssertionHandlerCB handler) {…}
inline AssertionHandler GetDefaultAssertionHandler()
{
  return SDL_GetDefaultAssertionHandler();
}
inline AssertionHandler GetDefaultAssertionHandler() {…}
 
inline AssertionHandler GetAssertionHandler(void** puserdata)
{
  return SDL_GetAssertionHandler(puserdata);
}
inline AssertionHandler GetAssertionHandler(void** puserdata) {…}
 
inline AssertionHandlerCB GetAssertionHandler()
{
  using Wrapper = UniqueCallbackWrapper<AssertionHandlerCB>;
  void* userdata = nullptr;
  auto cb = GetAssertionHandler(&userdata);
  if (Wrapper::contains(userdata)) return Wrapper::Unwrap(userdata);
  return [cb, userdata](const AssertData* data) { return cb(data, userdata); };
}
inline AssertionHandlerCB GetAssertionHandler() {…}
 
inline const AssertData* GetAssertionReport()
{
  return SDL_GetAssertionReport();
}
inline const AssertData* GetAssertionReport() {…}
 
inline void ResetAssertionReport() { return SDL_ResetAssertionReport(); }
 
 
} // namespace SDL
namespace SDL {…}
 
#endif /* SDL3PP_ASSERT_H_ */