assert.hpp

#ifndef SIPLASPLAS_UTILITY_ASSERT_HPP
#define SIPLASPLAS_UTILITY_ASSERT_HPP

#include <stdexcept>
#include <functional>
#include "preprocessor.hpp"
#include "exception.hpp"
#include <siplasplas/utility/export.hpp>

namespace cpp
{

class SIPLASPLAS_UTILITY_EXPORT AssertException : public std::logic_error
{
public:
    using std::logic_error::logic_error;
};

class SIPLASPLAS_UTILITY_EXPORT AssertExpression
{
public:
    AssertExpression(bool expressionResult,
                     const std::string& message,
                     const std::string& file,
                     std::size_t line);

    ~AssertExpression() noexcept(false);

    AssertExpression& onFailure(const std::function<void()>& callback);

    template<typename String, typename... Args>
    AssertExpression& detail(String&& messageBody, Args&&... messageArgs)
    {
        _detail = ::fmt::format(std::forward<String>(messageBody), std::forward<Args>(messageArgs)...);
        return *this;
    }

    template<typename String, typename... Args>
    AssertExpression& operator()(String&& messageBody, Args&&... args)
    {
        return detail(std::forward<String>(messageBody), std::forward<Args>(args)...);
    }

private:
    std::string _message;
    std::string _detail;
    std::string _file;
    std::size_t _line;
    std::function<void()> _onFailureCallback;
    bool _assertionFailed;
};

class SIPLASPLAS_UTILITY_EXPORT DummyAssertExpression
{
public:
    template<typename Function>
    DummyAssertExpression& onFailure(Function)
    {
        return *this;
    }

    template<typename String, typename... Args>
    DummyAssertExpression& detail(String&&, Args&&...)
    {
        return *this;
    }

    template<typename String, typename... Args>
    DummyAssertExpression& operator()(String&&, Args&&...)
    {
        return *this;
    }
};

}

#if !defined(NDEBUG) || defined(SIPLASPLAS_ENABLE_ASSERTS)
#define SIPLASPLAS_ASSERTS_ENABLED
#define SIPLASPLAS_ASSERT_IMPL(MESSAGE, ...) ::cpp::AssertExpression((__VA_ARGS__), MESSAGE, __FILE__, __LINE__)
#else
#define SIPLASPLAS_ASSERT_IMPL(MESSAGE, ...) ::cpp::DummyAssertExpression()
#endif

#define SIPLASPLAS_ASSERT(...) SIPLASPLAS_ASSERT_IMPL(SIPLASPLAS_PP_STR((__VA_ARGS__)), __VA_ARGS__)

#define SIPLASPLAS_ASSERT_COMP_IMPL(a, b, op, wording) SIPLASPLAS_ASSERT_IMPL(::fmt::format( \
                    "Expected '{}' ({}) {} '{}' ({})",                                       \
                    SIPLASPLAS_PP_STR(a),                                                    \
                    a,                                                                       \
                    wording,                                                                 \
                    SIPLASPLAS_PP_STR(b),                                                    \
                    b                                                                        \
                ), ((a) op (b)))

#define SIPLASPLAS_ASSERT_EQ(a, b) SIPLASPLAS_ASSERT_COMP_IMPL(a, b, ==, "equal to")


#define SIPLASPLAS_ASSERT_NE(a, b) SIPLASPLAS_ASSERT_COMP_IMPL(a, b, !=, "not equal to")


#define SIPLASPLAS_ASSERT_BT(a, b) SIPLASPLAS_ASSERT_COMP_IMPL(a, b, > , "bigger than")


#define SIPLASPLAS_ASSERT_LT(a, b) SIPLASPLAS_ASSERT_COMP_IMPL(a, b, < , "less than")


#define SIPLASPLAS_ASSERT_BE(a, b) SIPLASPLAS_ASSERT_COMP_IMPL(a, b, >=, "bigger or equal to")


#define SIPLASPLAS_ASSERT_LE(a, b) SIPLASPLAS_ASSERT_COMP_IMPL(a, b, <=, "less or equal to")

#define SIPLASPLAS_ASSERT_TRUE(...) SIPLASPLAS_ASSERT_IMPL(::fmt::format( \
                "Expected '{}' to be true. Got false instead",            \
                SIPLASPLAS_PP_STR((__VA_ARGS__))                          \
            ), __VA_ARGS__)

#define SIPLASPLAS_ASSERT_FALSE(...) SIPLASPLAS_ASSERT_IMPL(::fmt::format( \
                "Expected '{}' to be false. Got true instead",            \
                SIPLASPLAS_PP_STR((__VA_ARGS__))                          \
            ), !(__VA_ARGS__))


#endif // SIPLASPLAS_UTILITY_ASSERT_HPP