Assert.h

Go to the documentation of this file.

//
// Copyright 2014 - 2026 (C). Alex Robenko. All rights reserved.
//
// SPDX-License-Identifier: MPL-2.0
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <cassert>
#include <type_traits>
#include <utility>
 
namespace comms
{
 
class Assert
{
public:
    virtual ~Assert() noexcept {}
 
    virtual void fail(
        const char* expr,
        const char* file,
        unsigned int line,
        const char* function) = 0;
 
private:
};
 
class AssertManager
{
public:
 
    static AssertManager& instance()
    {
        static AssertManager mgr;
        return mgr;
    }
 
    AssertManager(const AssertManager&) = delete;
 
    AssertManager& operator=(const AssertManager&) = delete;
 
    Assert* reset(Assert* newAssert = nullptr)
    {
        auto prevAssert = m_assert;
        m_assert = newAssert;
        return prevAssert;
    }
 
    Assert* getAssert()
    {
        return m_assert;
    }
 
    bool hasAssertRegistered() const
    {
        return (m_assert != nullptr);
    }
 
    static void infiniteLoop()
    {
        while (true) {};
    }
 
private:
    AssertManager() : m_assert(nullptr) {}
 
    Assert* m_assert;
};
 
 
template < typename TAssert>
class EnableAssert
{
    static_assert(std::is_base_of<Assert, TAssert>::value,
        "TAssert class must be derived class of Assert");
public:
    using AssertType = TAssert;
 
    template<typename... TParams>
    EnableAssert(TParams&&... args)
        : m_assert(std::forward<TParams>(args)...),
          m_prevAssert(AssertManager::instance().reset(&m_assert))
    {
    }
 
    ~EnableAssert() noexcept
    {
        AssertManager::instance().reset(m_prevAssert);
    }
 
    AssertType& getAssert()
    {
        return m_assert;
    }
 
private:
    AssertType m_assert;
    Assert* m_prevAssert;
};
 
#ifndef COMMS_ASSERT
#ifndef NDEBUG
 
// NOSTDLIB definition is treated as COMMS_NOSTDLIB for backward compatiblity
#if defined(NOSTDLIB) && !defined(COMMS_NOSTDLIB)
#define COMMS_NOSTDLIB
#endif
 
#ifndef __ASSERT_FUNCTION
#define COMMS_ASSERT_FUNCTION_STR __FUNCTION__
#else // #ifndef __ASSERT_FUNCTION
#define COMMS_ASSERT_FUNCTION_STR __ASSERT_FUNCTION
#endif // #ifndef __ASSERT_FUNCTION
 
#ifndef COMMS_NOSTDLIB
#define COMMS_ASSERT_FAIL_FUNC(expr) assert(expr)
#else // #ifndef COMMS_NOSTDLIB
#define COMMS_ASSERT_FAIL_FUNC(expr) comms::AssertManager::instance().infiniteLoop()
#endif // #ifndef COMMS_NOSTDLIB
 
 
#define COMMS_ASSERT(expr) \
    ((expr)                               \
      ? static_cast<void>(0)                     \
      : (comms::AssertManager::instance().hasAssertRegistered() \
            ? comms::AssertManager::instance().getAssert()->fail( \
                #expr, __FILE__, __LINE__, COMMS_ASSERT_FUNCTION_STR) \
            : COMMS_ASSERT_FAIL_FUNC(expr)))
 
#else // #ifndef NDEBUG
 
#define COMMS_ASSERT(expr) static_cast<void>(0)
 
#endif // #ifndef NDEBUG
#endif // #ifndef COMMS_ASSERT
 
#ifndef GASSERT
#define GASSERT(expr) COMMS_ASSERT(expr)
#endif // #ifndef GASSERT
 
}  // namespace comms