Assert.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef ROOT_CORE_UTILS__ASSERT_H
#define ROOT_CORE_UTILS__ASSERT_H




 

 
 
 
 
 
namespace RCU
{
  namespace Check
  {
    enum Type
      {
    assert_soft,
    assert_hard,
    assert_noimp,

    require_soft,
    require_hard,
    require_noimp,

    provide_soft,
    provide_hard,
    provide_noimp,

    invariant
      };
    const int typeNum = invariant + 1;
    extern const char * const typeLiteral [typeNum];
    extern const bool typeAbort [typeNum];
 

    void fail (const char *file, unsigned line,
           Type type, const char *error);
 

    typedef void (*TestInvariantFunction) (const void *object);
    template<class T> void
    testInvariantVoid (const void *object)
    {
      static_cast<const T *>(object)->testInvariant ();
    }
 
 
 
    struct TestInvariant
    {
 
      TestInvariant (TestInvariantFunction function,
             const void *object);
      ~TestInvariant ();
 
    private:
      TestInvariantFunction m_function;
      const void *m_object;
    };
 
 

    template<class T> inline TestInvariant invariant_tester (T *object)
    {
      return TestInvariant (testInvariantVoid<T>, object);
    }
  }
}
 
 
 
 

#define RCU_CHECK(type,condition,message)               \
  (condition) ? (void) 0 : ::RCU::Check::fail (__FILE__, __LINE__, ::RCU::Check::type, message)

#define RCU_CHECK_JOIN2(a,b)         RCU_CHECK_JOIN2_HIDDEN(a,b)
#define RCU_CHECK_JOIN2_HIDDEN(a,b)  a ## b
 
 
 
#define RCU_REQUIRE_SOFT(x)         \
  RCU_CHECK (require_soft,  x, #x)
#define RCU_REQUIRE2_SOFT(x,y)          \
  RCU_CHECK (require_soft,  x,  y)
#define RCU_REQUIRE0_SOFT(y)            \
  RCU_CHECK (require_soft,  0,  y)
 
#define RCU_PROVIDE_SOFT(x)         \
  RCU_CHECK (provide_soft,  x, #x)
#define RCU_PROVIDE2_SOFT(x,y)          \
  RCU_CHECK (provide_soft,  x,  y)
#define RCU_PROVIDE0_SOFT(y)            \
  RCU_CHECK (provide_soft,  0,  y)
 
#define RCU_ASSERT_SOFT(x)          \
  RCU_CHECK (assert_soft,   x, #x)
#define RCU_ASSERT2_SOFT(x,y)           \
  RCU_CHECK (assert_soft,   x,  y)
#define RCU_ASSERT0_SOFT(y)         \
  RCU_CHECK (assert_soft,   0,  y)
 
 
 
#define RCU_REQUIRE_NOIMP(x)            \
  RCU_CHECK (require_noimp,  x, #x)
#define RCU_REQUIRE2_NOIMP(x,y)         \
  RCU_CHECK (require_noimp,  x,  y)
#define RCU_REQUIRE0_NOIMP(y)           \
  RCU_CHECK (require_noimp,  0,  y)
 
#define RCU_PROVIDE_NOIMP(x)            \
  RCU_CHECK (provide_noimp,  x, #x)
#define RCU_PROVIDE2_NOIMP(x,y)         \
  RCU_CHECK (provide_noimp,  x,  y)
#define RCU_PROVIDE0_NOIMP(y)           \
  RCU_CHECK (provide_noimp,  0,  y)
 
#define RCU_ASSERT_NOIMP(x)         \
  RCU_CHECK (assert_noimp,   x, #x)
#define RCU_ASSERT2_NOIMP(x,y)          \
  RCU_CHECK (assert_noimp,   x,  y)
#define RCU_ASSERT0_NOIMP(y)            \
  RCU_CHECK (assert_noimp,   0,  y)
 
 
 
#define RCU_INVARIANT(x)            \
  RCU_CHECK (invariant, x, #x)
#define RCU_INVARIANT2(x,y)         \
  RCU_CHECK (invariant, x,  y)
#define RCU_INVARIANT0(y)           \
  RCU_CHECK (invariant, 0,  y)
 
#ifndef NDEBUG
 
#define RCU_REQUIRE(x)              \
  RCU_CHECK (require_hard,   x, #x)
#define RCU_REQUIRE2(x,y)           \
  RCU_CHECK (require_hard,   x,  y)
#define RCU_REQUIRE0(y)             \
  RCU_CHECK (require_hard,   0,  y)
 
#define RCU_PROVIDE(x)              \
  RCU_CHECK (provide_hard,   x, #x)
#define RCU_PROVIDE2(x,y)           \
  RCU_CHECK (provide_hard,   x,  y)
#define RCU_PROVIDE0(y)             \
  RCU_CHECK (provide_hard,   0,  y)
 
#define RCU_ASSERT(x)               \
  RCU_CHECK (assert_hard,    x, #x)
#define RCU_ASSERT2(x,y)            \
  RCU_CHECK (assert_hard,    x,  y)
#define RCU_ASSERT0(y)              \
  RCU_CHECK (assert_hard,    0,  y)
 
#define RCU_READ_INVARIANT(x)           \
  (x)->testInvariant ()
#define RCU_CHANGE_INVARIANT(x)                     \
  ::RCU::Check::TestInvariant RCU_CHECK_JOIN2 (invariant, __LINE__) = ::RCU::Check::invariant_tester (x);
#define RCU_NEW_INVARIANT(x)            \
  (x)->testInvariant ()
#define RCU_DESTROY_INVARIANT(x)        \
  (x)->testInvariant ()
 
#else
 
#define RCU_REQUIRE(x)              \
  (void) 0
#define RCU_REQUIRE2(x,y)           \
  (void) 0
#define RCU_REQUIRE0(y)             \
  (void) 0
#define RCU_PROVIDE(x)              \
  (void) 0
#define RCU_PROVIDE2(x,y)           \
  (void) 0
#define RCU_PROVIDE0(y)             \
  (void) 0
#define RCU_ASSERT(x)               \
  (void) 0
#define RCU_ASSERT2(x,y)            \
  (void) 0
#define RCU_ASSERT0(y)              \
  (void) 0
#define RCU_READ_INVARIANT(x)           \
  (void) 0
#define RCU_CHANGE_INVARIANT(x)         \
  (void) 0
#define RCU_NEW_INVARIANT(x)            \
  (void) 0
#define RCU_DESTROY_INVARIANT(x)        \
  (void) 0
 
#endif
 
 
 
 
 
#ifdef RCU_DEBUG_SLOW
 
#define RCU_REQUIRE_SLOW(x)         \
  RCU_REQUIRE(x)
#define RCU_REQUIRE2_SLOW(x,y)          \
  RCU_REQUIRE2(x,y)
#define RCU_PROVIDE_SLOW(x)         \
  RCU_PROVIDE(x)
#define RCU_PROVIDE2_SLOW(x,y)          \
  RCU_PROVIDE2(x,y)
#define RCU_ASSERT_SLOW(x)          \
  RCU_ASSERT(x)
#define RCU_ASSERT2_SLOW(x,y)           \
  RCU_ASSERT2(x,y)
#define RCU_READ_INVARIANT_SLOW(x)      \
  RCU_READ_INVARIANT (x)
#define RCU_CHANGE_INVARIANT_SLOW(x)        \
  RCU_CHANGE_INVARIANT (x)
#define RCU_NEW_INVARIANT_SLOW(x)       \
  RCU_NEW_INVARIANT (x)
#define RCU_DESTROY_INVARIANT_SLOW(x)       \
  RCU_DESTROY_INVARIANT (x)
 
#else
 
#define RCU_REQUIRE_SLOW(x)         \
  (void) 0
#define RCU_REQUIRE2_SLOW(x,y)          \
  (void) 0
#define RCU_PROVIDE_SLOW(x)         \
  (void) 0
#define RCU_PROVIDE2_SLOW(x,y)          \
  (void) 0
#define RCU_ASSERT_SLOW(x)          \
  (void) 0
#define RCU_ASSERT2_SLOW(x,y)           \
  (void) 0
#define RCU_READ_INVARIANT_SLOW(x)      \
  (void) 0
#define RCU_CHANGE_INVARIANT_SLOW(x)        \
  (void) 0
#define RCU_NEW_INVARIANT_SLOW(x)       \
  (void) 0
#define RCU_DESTROY_INVARIANT_SLOW(x)       \
  (void) 0
 
#endif
 
 
#endif