assert.hpp

Go to the documentation of this file.

/*
* Runtime assertion checking
*/
 
#ifndef IV_SRC_CORE_ASSERT_HPP_
#define IV_SRC_CORE_ASSERT_HPP_
 
#include <string>
 
namespace iv::assert
{
 
template<class...>
inline constexpr bool always_false = false;
 
void assertionFailure(const char *exprString, const char *assertionMade, const char *func, const char *file, int line);
 
void throwInvalidArgument(const char *message, const char *func, const char *file);
void throwInvalidState(const char *expr, const char *func, const char *file);
 
template<typename T>
void ignoreParam(T &&)
{
}
 
template<typename... T>
void ignoreParams(T &&...args)
{
    (iv::assert::ignoreParam(args), ...);
}
 
void assertUnreachable(const char *file, int line);
 
void assertionMessage(const char *message, const char *func, const char *file, int line);
 
void debugInfo(std::string_view message);
void debugMessage(std::string_view message);
void debugError(std::string_view message);
 
}//namespace iv::assert
 
#ifndef NDEBUG
#define ASSERT_FUNCTION_ __extension__ __PRETTY_FUNCTION__
#else
#define ASSERT_FUNCTION_ __func__
#endif
 
#define IV_ARG_CHECK(expr, msg, ...)                                                                                   \
    do                                                                                                                 \
    {                                                                                                                  \
        if (not(expr))                                                                                                 \
            iv::assert::throwInvalidArgument(msg, ASSERT_FUNCTION_, __FILE__);                                         \
    } while (0)
 
#define IV_STATE_CHECK(expr)                                                                                           \
    do                                                                                                                 \
    {                                                                                                                  \
        if (not(expr))                                                                                                 \
            iv::assert::throwInvalidState(#expr, ASSERT_FUNCTION_, __FILE__);                                          \
    } while (0)
 
#define IV_ASSERT(expr, assertion_made, ...)                                                                           \
    do                                                                                                                 \
    {                                                                                                                  \
        if (not(expr))                                                                                                 \
            iv::assert::assertionFailure(#expr, assertion_made, ASSERT_FUNCTION_, __FILE__, __LINE__);                 \
    } while (0)
 
#define IV_ASSERT_NOMSG(expr, ...)                                                                                     \
    do                                                                                                                 \
    {                                                                                                                  \
        if (not(expr))                                                                                                 \
            iv::assert::assertionFailure(#expr, "", ASSERT_FUNCTION_, __FILE__, __LINE__);                             \
    } while (0)
 
#define IV_ASSERT_IMPLICATION(expr1, expr2, msg, ...)                                                                  \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((expr1) && not(expr2))                                                                                     \
            iv::assert::assertionFailure(#expr1 " implies " #expr2, msg, ASSERT_FUNCTION_, __FILE__, __LINE__);        \
    } while (0)
 
#define IV_ASSERT_NULL_POINTER(ptr)                                                                                    \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((ptr) == nullptr)                                                                                          \
            iv::assert::assertionFailure(#ptr " is null", "", ASSERT_FUNCTION_, __FILE__, __LINE__);                   \
    } while (0)
 
#define IV_UNUSED iv::assert::ignoreParams
 
#define IV_ASSERT_UNREACHABLE() iv::assert::assertUnreachable(__FILE__, __LINE__)
 
#define IV_ASSERT_MSG(msg, ...)                                                                                        \
    do                                                                                                                 \
    {                                                                                                                  \
        iv::assert::assertionMessage(msg, ASSERT_FUNCTION_, __FILE__, __LINE__);                                       \
    } while (0)
 
static_assert(sizeof(std::size_t) == 8 || sizeof(std::size_t) == 4, "This platform has an unexpected size for size_t");
 
void throwMissingCase(const char *message, const char *func, const char *file);
 
#define IV_MISSING_CASE_CHECK(msg, ...)                                                                                \
    do                                                                                                                 \
    {                                                                                                                  \
        throwMissingCase(#msg, __func__, __FILE__);                                                                    \
    } while (0)
 
#define IV_ASSERT_EQUAL(expr1, expr2, assertion_made)                                                                  \
    do                                                                                                                 \
    {                                                                                                                  \
        if ((expr1) != (expr2))                                                                                        \
            iv::assert::assertionFailure(#expr1 " == " #expr2, assertion_made, __func__, __FILE__, __LINE__);          \
    } while (0)
 
#endif//IV_SRC_CORE_ASSERT_HPP_