Control/AthenaKernel/AthenaKernel/errorcheck.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

 
 
#ifndef ATHENAKERNEL_ERRORCHECK_H
#define ATHENAKERNEL_ERRORCHECK_H
 
 
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/IMessageSvc.h"
#include "boost/preprocessor/facilities/overload.hpp"
#include <string>
#include <atomic>
 
class INamedInterface;
 
 
// Internal out-of-line functions go in this namespace.
namespace errorcheck {
 

std::string context_name (const INamedInterface* context);
 

std::string context_name (const void* context);
 

class ReportMessage
  : public MsgStream
{
public:
  ReportMessage (MSG::Level level,
                 int line,
                 const char* file,
                 const char* func,
                 const char* pkg,
                 const std::string& context,
                 StatusCode sc);
 

  ReportMessage (MSG::Level level,
                 int line,
                 const char* file,
                 const char* func,
                 const char* pkg,
                 const std::string& context);
 

  ~ReportMessage();
 

  virtual MsgStream& doOutput() override;

  MsgStream& msgstream() { return *this; }
 

  static void hideErrorLocus (bool flag = true);
 

  static void hideFunctionNames (bool flag = true);
 
 
private:
  void format_common (MSG::Level level,
                      int line,
                      const char* file,
                      const char* func,
                      const char* pkg);

  std::string::size_type m_pos;

  static std::atomic<bool> s_hide_error_locus;

  static std::atomic<bool> s_hide_function_names;
};
 
 
} // namespace errorcheck
 
 
// Macro to get the current function name.
// Currently, this relies on a gcc extension, and will just return
// an empty string for another compiler.  A similar mechanism (__func__)
// has been proposed for the next revision of the C++ standard (cf. n1642);
// if that makes it in, it can be used instead.
#if defined(__GNUC__)
# define ERRORCHECK_FNAME __PRETTY_FUNCTION__
#else
# define ERRORCHECK_FNAME ""
#endif
 
// Define empty package name in case there is none defined already
#ifndef ATLAS_PACKAGE_NAME
# define ATLAS_PACKAGE_NAME nullptr
#endif
 
// Collect all the arguments describing the source location:
// line number, file name, function name, package.
#define ERRORCHECK_ARGS __LINE__, __FILE__, ERRORCHECK_FNAME, ATLAS_PACKAGE_NAME
 

#define REPORT_ERROR_WITH_CONTEXT(SC, CONTEXT_NAME)             \
  errorcheck::ReportMessage (MSG::ERROR, ERRORCHECK_ARGS, CONTEXT_NAME, SC) \
    . msgstream()
 

#define REPORT_MESSAGE_WITH_CONTEXT(LVL, CONTEXT_NAME)             \
  errorcheck::ReportMessage (LVL, ERRORCHECK_ARGS, CONTEXT_NAME).msgstream()
 

#define REPORT_ERROR(SC)                                           \
  REPORT_ERROR_WITH_CONTEXT(SC, errorcheck::context_name (this))
 

#define REPORT_MESSAGE(LVL)                                           \
  REPORT_MESSAGE_WITH_CONTEXT(LVL, errorcheck::context_name (this))
 

#define CHECK_FAILED(EXP, CONTEXT_NAME, SC, RET) do {     \
      errorcheck::ReportMessage (MSG::ERROR,              \
                                 ERRORCHECK_ARGS,         \
                                 CONTEXT_NAME,            \
                                 SC) . msgstream()        \
                                   << #EXP;               \
      return RET;                                         \
  } while(0)
 

#ifndef __CPPCHECK__ // The varadic macros here confuse cppcheck.
#define CHECK_WITH_CONTEXT(...)  \
    BOOST_PP_OVERLOAD(CHECK_WITH_CONTEXT_, __VA_ARGS__)(__VA_ARGS__)
 
#define CHECK_WITH_CONTEXT_2(EXP, CONTEXT_NAME) do {       \
    StatusCode sc__(EXP);                                  \
    if (! sc__.isSuccess())                                \
      CHECK_FAILED(EXP, CONTEXT_NAME, sc__, sc__);         \
  } while (0)
 
#define CHECK_WITH_CONTEXT_3(EXP, CONTEXT_NAME, RET) do {  \
    StatusCode sc__(EXP);                                  \
    if (! sc__.isSuccess())                                \
      CHECK_FAILED(EXP, CONTEXT_NAME, sc__, RET);          \
  } while (0)
 

#define CHECK(...)  \
    BOOST_PP_OVERLOAD(CHECK_, __VA_ARGS__)(__VA_ARGS__)
 
#define CHECK_1(EXP) CHECK_WITH_CONTEXT(EXP, errorcheck::context_name(this))
#define CHECK_2(EXP, RET) CHECK_WITH_CONTEXT(EXP, errorcheck::context_name(this), RET)
#endif
 

#define CHECK_CODE_WITH_CONTEXT(EXP, CONTEXT_NAME, CODE) do {  \
    StatusCode sc__ = (EXP);                                          \
    if (! sc__.isSuccess()) {                                         \
      sc__ = CODE;                                                    \
      CHECK_FAILED(EXP, CONTEXT_NAME, sc__, sc__);                    \
    }                                                                 \
  } while (0)
 

#define CHECK_CODE(EXP, CODE) \
  CHECK_CODE_WITH_CONTEXT(EXP, errorcheck::context_name(this), CODE)
 

#define CHECK_RECOVERABLE_WITH_CONTEXT(EXP, CONTEXT_NAME) \
  CHECK_CODE_WITH_CONTEXT(EXP, CONTEXT_NAME, StatusCode::RECOVERABLE)
 

#define CHECK_RECOVERABLE(EXP) \
  CHECK_RECOVERABLE_WITH_CONTEXT(EXP, errorcheck::context_name(this))
 

#define CHECK_FATAL_WITH_CONTEXT(EXP, CONTEXT_NAME) \
  CHECK_CODE_WITH_CONTEXT(EXP, CONTEXT_NAME, StatusCode::FAILURE)
 

#define CHECK_FATAL(EXP) \
  CHECK_FATAL_WITH_CONTEXT(EXP, errorcheck::context_name(this))
 
 
#endif // not ATHENAKERNEL_ERRORCODE_H