errorcheck.cxx

Go to the documentation of this file.

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

 
#include "AthenaKernel/errorcheck.h"
#include "AthenaKernel/getMessageSvc.h"
#include "CxxUtils/normalizeFunctionName.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/INamedInterface.h"
#include <ctype.h>
 
 
namespace errorcheck {
 

std::atomic<bool> ReportMessage::s_hide_error_locus;
 

std::atomic<bool> ReportMessage::s_hide_function_names;
 

std::string munge_filename (const std::string& file, const std::string& pkg)
{
  // Extract package name in case there is a version (MyPackage-00-00-00)
  const std::string p = pkg.substr(0, pkg.find('-'));
  if (!p.empty()) {
    // Find package name in path and remove any leading entries
    std::string::size_type ipos = file.find("/"+p+"/");
    if (ipos != std::string::npos) {
      return file.substr(ipos+1, std::string::npos);
    }
  }
  return file;
}
 

ReportMessage::ReportMessage (MSG::Level level,
                              int line,
                              const char* file,
                              const char* func,
                              const char* pkg,
                              const std::string& context,
                              StatusCode sc)
  : MsgStream (Athena::getMessageSvc(), context)
{
  // The common part.
  format_common (level, line, file, func, pkg);
 
  // The status code.
  *this << ": code " << sc;
 
  // Remember the end of the header.
  m_pos = stream().str().size();
}
 

ReportMessage::ReportMessage (MSG::Level level,
                              int line,
                              const char* file,
                              const char* func,
                              const char* pkg,
                              const std::string& context)
  : MsgStream (Athena::getMessageSvc(), context)
{
  // The common part.
  format_common (level, line, file, func, pkg);
 
  // Remember the end of the header.
  m_pos = stream().str().size();
}
 

void ReportMessage::format_common (MSG::Level level,
                                   int line,
                                   const char* file,
                                   const char* func,
                                   const char* pkg)
{
  // Logging level.
  *this << level;
 
  // Write the source file/line.
  if (s_hide_error_locus)
    *this << "FILE:LINE";
  else {
    if (pkg && pkg[0] != '\0')
      *this << munge_filename(file, pkg) << ":" << line;
    else
      *this << file << ":" << line;
  }
 
  // Include the function name if available.
  if (s_hide_function_names)
    *this << " (FUNC)";
  else {
    if (func && func[0] != '\0') {
      *this << " (" << CxxUtils::normalizeFunctionName(func) << ")";
    }
  }
}
 

ReportMessage::~ReportMessage()
{
  // Don't do anything if the message has already been emitted
  // (due to using << endmsg, for example).
  if (!stream().str().empty())
    *this << endmsg;
}
 

MsgStream& ReportMessage::doOutput()
{
  // The deal here is this.  We want
  //  REPORT_MESSAGE(MSG::INFO) << "foo";
  // to get a `: ' before the `foo'.
  // But we don't want
  //  REPORT_MESSAGE(MSG::INFO);
  // to have a trailing `: '.
  // So, after we generate the common header part, we remember
  // where we are in the string.  When the message is emitted, we look
  // to see if additional text has been added.  If not, then we don't
  // need to do anything.  But if so, we insert a `: ' after the header.
  if (m_pos != stream().str().size()) {
    std::string tmp1 = stream().str();
    std::string tmp2 = tmp1.substr(0, m_pos);
    tmp2 += ": ";
    tmp2.append( tmp1, m_pos);
    stream().str (tmp2);
  }
  return MsgStream::doOutput();
}
 

void ReportMessage::hideErrorLocus (bool flag /*= true*/)
{
  s_hide_error_locus = flag;
}
 

void ReportMessage::hideFunctionNames (bool flag /*= true*/)
{
  s_hide_function_names = flag;
}
 
 
} // namespace errorcheck
 
 
namespace errorcheck {
 

std::string context_name (const INamedInterface* context)
{
  return context->name();
}
 

std::string context_name (const void* /*context*/)
{
  return "";
}
 
 
} // namespace errorcheck