Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
 
#ifndef ASG_MESSAGING__MESSAGE_CHECK_H
#define ASG_MESSAGING__MESSAGE_CHECK_H
 
#include "CxxUtils/AthUnlikelyMacros.h"
 
 
 
 
#include <type_traits>
 
#include <AsgMessaging/MsgHelpers.h>
#include <AsgMessaging/StatusCode.h>
 
#include "CxxUtils/checker_macros.h"
#include "CxxUtils/normalizeFunctionName.h"
#include <atomic>
 
#define ANA_MSG_HEADER(NAME)        \
  namespace NAME {              \
  MsgStream& msg ();                \
  MsgStream& msg (MSG::Level level);        \
  bool msgLvl (MSG::Level lvl);         \
  void setMsgLevel (MSG::Level level); }
 
#ifdef XAOD_STANDALONE
#define ASG_TOOLS_MSG_STREAM(NAME,TITLE)    \
  static MsgStream& NAME {::asg::MsgHelpers::pkgMsgStream (TITLE)};
#else
#define ASG_TOOLS_MSG_STREAM(NAME,TITLE)            \
  static thread_local MsgStream NAME {::asg::MsgHelpers::pkgMsgStream (TITLE)};
#endif
 
#define ANA_MSG_SOURCE(NAME,TITLE)      \
  namespace NAME                \
  {                     \
    MsgStream& msg ()               \
    {                                           \
      ASG_TOOLS_MSG_STREAM (result, TITLE); \
      return result;                \
    }                       \
                        \
    MsgStream& msg (MSG::Level level)       \
    {                       \
      return msg() << level;            \
    }                       \
                                                \
    bool msgLvl (MSG::Level lvl)                \
    {                       \
      if (msg().level() <= lvl)                 \
      {                                         \
        msg() << lvl;                           \
        return true;                            \
      } else                                    \
      {                                         \
        return false;                           \
      }                                         \
    }                       \
                        \
    void setMsgLevel (MSG::Level level)     \
    {                       \
      ::asg::MsgHelpers::setPkgMsgLevel (TITLE, level); \
    }                       \
  }
 
namespace asg
{
  ANA_MSG_HEADER (msgUserCode)
}
 
namespace asg
{
  template<typename T> struct CheckHelper;
 
  template<> struct CheckHelper<StatusCode>
  {
    static inline bool isSuccess (const StatusCode& sc) {
      return sc.isSuccess(); }
 
    static constexpr inline auto successCode () {
      return StatusCode::SUCCESS;}
 
    static constexpr inline auto failureCode () {
      return StatusCode::FAILURE;}
  };
 
  template<> struct CheckHelper<int>
  {
    static inline int successCode () {
      return 0;}
 
    static inline int failureCode () {
      return 220;}
  };
 
  template<> struct CheckHelper<bool>
  {
    static inline bool isSuccess (const bool& sc) {
      return sc; }
 
    static inline bool successCode () {
      return true;}
 
    static inline bool failureCode () {
      return false;}
  };
 
  template<typename T> struct CheckHelper<T*>
  {
    static inline bool isSuccess (const T *sc) {
      return sc; }
 
    static inline T *failureCode () {
      return nullptr;}
  };
 
  namespace detail
  {
    [[noreturn]] void throw_check_fail (const std::string& str);
  }
}
 
 
// This is a GCC extension for getting the name of the current function.
#if defined( __GNUC__ )
#   define MSGSTREAM_FNAME CxxUtils::normalizeFunctionName(__PRETTY_FUNCTION__)
#else
#   define MSGSTREAM_FNAME ""
#endif
 
 
// This is a GCC extension for getting the name of the current function.
#if defined( __GNUC__ )
#   define ASG_TOOLS_MSGSTREAM_FNAME CxxUtils::normalizeFunctionName(__PRETTY_FUNCTION__)
#else
#   define ASG_TOOLS_MSGSTREAM_FNAME ""
#endif
 
#define ASG_TOOLS_MSGSTREAM_PREFIX \
   __FILE__ << ":" << __LINE__ << " (" << ASG_TOOLS_MSGSTREAM_FNAME << "): "
 
#define ANA_MSG_LVL_SERIOUS( lvl, xmsg )                    \
   msg( lvl ) << ASG_TOOLS_MSGSTREAM_PREFIX << xmsg << endmsg
 
#define ANA_MSG_LVL_NOCHK( lvl, xmsg )          \
   msg( lvl ) << xmsg << endmsg
 
#define ANA_MSG_LVL( lvl, xmsg )                \
   do {                                         \
      if( msg().level() <= lvl ) {             \
         ANA_MSG_LVL_NOCHK( lvl, xmsg );        \
      }                                         \
   } while( 0 )
 
#define ANA_MSG_VERBOSE( xmsg )  ANA_MSG_LVL( MSG::VERBOSE, xmsg )
#define ANA_MSG_DEBUG( xmsg )    ANA_MSG_LVL( MSG::DEBUG, xmsg )
#define ANA_MSG_INFO( xmsg )     ANA_MSG_LVL_NOCHK( MSG::INFO,  xmsg )
#define ANA_MSG_WARNING( xmsg )  ANA_MSG_LVL_NOCHK( MSG::WARNING, xmsg )
#define ANA_MSG_ERROR( xmsg )    ANA_MSG_LVL_SERIOUS( MSG::ERROR, xmsg )
#define ANA_MSG_FATAL( xmsg )    ANA_MSG_LVL_SERIOUS( MSG::FATAL, xmsg )
#define ANA_MSG_ALWAYS( xmsg )   ANA_MSG_LVL_NOCHK( MSG::ALWAYS, xmsg )
 
 
 
typedef StatusCode AsgToolsCheckResultType;
 
 
#define ANA_CHECK_SET_TYPE(TYPE)            \
  typedef TYPE AsgToolsCheckResultType;
 
 
#define ANA_CHECK(EXP)                          \
  { const auto sc__ = EXP;                      \
    typedef typename std::decay<decltype(sc__)>::type scType__;     \
    if (ATH_UNLIKELY(!::asg::CheckHelper<scType__>::isSuccess (sc__))) { \
      ANA_MSG_ERROR ("Failed to call \"" << #EXP << "\"");      \
      return ::asg::CheckHelper<AsgToolsCheckResultType>::failureCode(); \
    } }
 
 
#define ANA_CHECK_THROW(EXP)                        \
  { const auto sc__ = EXP;                      \
    typedef typename std::decay<decltype(sc__)>::type scType__;     \
    if (ATH_UNLIKELY(!::asg::CheckHelper<scType__>::isSuccess (sc__))) { \
      std::ostringstream str;                       \
      str << #EXP;                          \
      ANA_MSG_ERROR ("Failed to call \"" << str.str() << "\", throwing exception"); \
      ::asg::detail::throw_check_fail (str.str());          \
    } }
 
#endif