/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AsgTools/AsgTools/MessageCheck.h

#ifndef ASG_TOOLS__MESSAGE_CHECK_H
#define ASG_TOOLS__MESSAGE_CHECK_H

//        Copyright Iowa State University 2014.
//                  Author: Nils Krumnack
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

// Please feel free to contact me (nils.erik.krumnack@cern.ch) for bug
// reports, feature suggestions, praise and complaints.





#include <type_traits>

#include <xAODRootAccess/tools/TReturnCode.h>
#ifdef ROOTCORE
#include <AsgTools/MsgStream.h>
#else
#include "AthenaBaseComps/AthMessaging.h"
#endif

#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 ROOTCORE
#define ASG_TOOLS_MSG_STREAM(NAME,TITLE)    \
  static MsgStream NAME (TITLE);
#else
#define ASG_TOOLS_MSG_STREAM(NAME,TITLE)            \
  static MsgStream NAME (::asg::detail::getMessageSvcAthena(), TITLE);
#endif

#define ANA_MSG_SOURCE(NAME,TITLE)      \
  namespace NAME                \
  {                     \
  namespace                 \
    {                       \
  MSG::Level& msgLevel ()           \
    {                       \
  static MSG::Level level = MSG::INFO;      \
  return level;                 \
    }                       \
  }                     \
                        \
                        \
                        \
  MsgStream& msg ()             \
  {                     \
    ASG_TOOLS_MSG_STREAM (result, TITLE);   \
  return result;                \
  }                     \
                        \
                        \
  MsgStream& msg (MSG::Level level)     \
  {                     \
    return msg() << level;          \
  }                     \
                        \
                        \
                        \
  bool msgLvl (MSG::Level lvl)          \
  {                     \
    return msgLevel() <= lvl;           \
  }                     \
                        \
                        \
                        \
  void setMsgLevel (MSG::Level level)       \
  {                     \
    msgLevel() = level;             \
  }                     \
  }

namespace asg
{
  ANA_MSG_HEADER (msgProperty)
  ANA_MSG_HEADER (msgToolHandle)
  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 inline decltype(StatusCode::SUCCESS) successCode () {
      return StatusCode::SUCCESS;}

    static inline decltype(StatusCode::FAILURE) failureCode () {
      return StatusCode::FAILURE;}
  };

  template<> struct CheckHelper<xAOD::TReturnCode>
  {
    static inline bool isSuccess (const xAOD::TReturnCode& sc) {
      return sc.isSuccess(); }

    static inline decltype (xAOD::TReturnCode::kSuccess) successCode () {
      return xAOD::TReturnCode::kSuccess;}

    static inline decltype (xAOD::TReturnCode::kFailure) failureCode () {
      return xAOD::TReturnCode::kFailure;}
  };

  template<> struct CheckHelper<int>
  {
    static inline int successCode () {
      return 0;}

    static inline int failureCode () {
      return 1;}
  };

  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
  {
#ifndef ROOTCORE
    IMessageSvc* getMessageSvcAthena();
#endif

    [[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 __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 __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 (!::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 (!::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

---