MessageLogger.h

Go to the documentation of this file.

#ifndef MessageLogger_MessageLogger_h
#define MessageLogger_MessageLogger_h

// -*- C++ -*-
//
// Package:     MessageLogger
// Class  :     <none>
// Functions:   LogSystem,   LogError,   LogWarning, LogInfo,     LogDebug
//              LogAbsolute, LogProblem, LogPrint,   LogVerbatim, LogTrace
//               LogImportant
//

//
// Original Author:  W. Brown and M. Fischler
//         Created:  Fri Nov 11 16:38:19 CST 2005
//     Major Split:  Tue Feb 14 11:00:00 CST 2006
//           See MessageService/interface/MessageLogger.h
//
// =================================================
// Change log
//
// 1 mf 5/11/06     Added a space before the file/line string in LogDebug_
//          to avoid the run-together with the run and event number
//
// 2 mf 6/6/06      Added LogVerbatim and LogTrace
//
// 3 mf 10/30/06    Added LogSystem and LogPrint
//
// 4 mf 6/1/07      Added LogAbsolute and LogProblem
//
// 5 mf 7/24/07     Added HaltMessageLogging
//
// 6 mf 8/7/07      Added FlushMessageLog
//
// 7 mf 8/7/07      Added GroupLogStatistics(category)
//
// 8 mf 12/12/07    Reworked LogDebug macro, LogDebug_class,, and similarly
//          for LogTrace, to avoid the need for the static dummy
//          objects.  This cures the use-of-thread-commands-after-
//          exit problem in programs that link but do not use the
//          MessageLogger.
//
// 9  mf 12/12/07   Check for subtly terrible situation of copying and then
//          writing to a LogDebug_ object.  Also forbid copying any
//          of the ordinary LogXXX objects (since that implies either
//          copying a MessageSender, or having a stale copy available
//          to lose message contents).
//
// 10 mf 12/14/07   Moved the static free function onlyLowestDirectory
//          to a class member function of LogDebug_, changing
//          name to a more descriptive stripLeadingDirectoryTree.
//          Cures the 2600-copies-of-this-function complaint.
//
// 11 mf  6/24/08   Added LogImportant which is LogProblem.  For output
//          which "obviously" ought to emerge, but allowing specific
//          suppression as if it were at the LogError level, rather
//          than the non-suppressible LogAbsolute.
//
// 12 ge  9/12/08   MessageLogger now works even when compiled with -DNDEBUG.
//                  The problem was that Suppress_LogDebug_ was missing the operator<<
//                  needed for streaming `std::iomanip`s.
//
// 13 wmtan 11/18/08 Use explicit non-inlined destructors
//
// 14 mf  3/23/09   ap.valid() used whenever possible suppression, to avoid
//          null pointer usage
//
// 15 mf  8/11/09   provision for control of standalone threshold and ignores
//
// 16 mf  10/2/09  Correct mission in logVerbatim and others of check for
//         whether this severity is enabled
//
// 17 wmtan 10/29/09 Out of line LogDebug_ and LogTrace_ constructors.
//
// 18 wmtan 07/08/10 Remove unnecessary includes
//
// 19 mf  09/21/10 !!! BEHAVIOR CHANGE: LogDebug suppression.
//                 The sole preprocessor symbol controlling suppression of
//                 LogDebug is EDM_ML_DEBUG.  If EDM_ML_DEBUG is not defined
//                 then LogDebug is suppressed.  Thus by default LogDebug is
//                 suppressed.
//
// 20 mf  09/21/10 The mechanism of LogDebug is modified such that if LogDebug
//                 is suppressed, whether via lack of the EDM_ML_DEBUG symbol
//                 or dynabically via !debgEnabled, all code past the
//                 LogDebug(...), including operator<< and functions to
//                 prepare the output strings, is squelched.  This was the
//                 original intended behavior.
//
//  ************   Note that in this regard, LogDebug behaves like assert:
//                 The use of functions having side effects, on a LogDebug
//                 statement (just as within an assert()), is unwise as it
//                 makes turning on the debugging aid alter the program
//                 behavior.
//
// 21  mf 9/23/10  Support for situations where no thresholds are low
//                 enough to react to LogDebug (or info, or warning).
//         A key observation is that while debugEnabled
//         should in principle be obtained via an instance() of
//         MessageDrop, debugAlwaysSuppressed is universal across
//         threads and hence is properly just a class static, which
//         is much quicker to check.
//
// 22  mf 9/27/10  edmmltest::LogWarningThatSuppressesLikeLogInfo,
//         a class provided solely to allow testing of the feature
//         that if all destinations have threshold too high, then
//         a level of messages (in this case, INFO) will be suppressed
//         without even being seen by the destinations.
//
// 23 mf 11/30/10  SnapshotMessageLog() method to force MessageDrop to
//         capture any pointed-to strings in anticipation of key
//         objects going away before a message is going to be issued.
//
// 24 fwyzard 7/6/11    Add support for discarding LogError-level messages
//                      on a per-module basis (needed at HLT)
//
// 25 wmtan 7/17/11 Allocate MessageSender on stack rather than heap
//
// 26 wmtan 7/22/11 Fix clang compilation errors for LogDebug and LogTrace
//                  by making MessageSender copyable, and holding
//                  the ErrorObj in a shared pointer with a custom deleter.
//
// 27 mkortela 2/27/17 Add IfLogTrace and IfLogDebug
// =================================================

// system include files

#include <memory>
#include <string>

// user include files

// forward declarations

#include "FWCore/MessageLogger/interface/MessageSender.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"
#include "FWCore/Utilities/interface/EDMException.h"  // Change log 8

namespace edm {

  class LogWarning {
  public:
    explicit LogWarning(std::string const& id)
        : ap(ELwarning,
             id,
             false,
             (MessageDrop::warningAlwaysSuppressed || !MessageDrop::instance()->warningEnabled))  // Change log 21
    {}
    ~LogWarning();  // Change log 13

    template <class T>
    LogWarning& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    LogWarning& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogWarning& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }

    template <typename F>
    LogWarning& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    LogWarning(LogWarning const&) = delete;  // Change log 9
    LogWarning& operator=(LogWarning const&) = delete;

  };  // LogWarning

  class LogError {
  public:
    explicit LogError(std::string const& id)
        : ap(ELerror, id, false, !MessageDrop::instance()->errorEnabled)  // Change log 24
    {}
    ~LogError();  // Change log 13

    template <class T>
    LogError& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    LogError& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogError& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }

    template <typename F>
    LogError& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    LogError(LogError const&) = delete;  // Change log 9
    LogError& operator=(LogError const&) = delete;

  };  // LogError

  class LogSystem {
  public:
    explicit LogSystem(std::string const& id) : ap(ELsevere, id) {}
    ~LogSystem();  // Change log 13

    template <class T>
    LogSystem& operator<<(T const& t) {
      ap << t;
      return *this;
    }
    LogSystem& operator<<(std::ostream& (*f)(std::ostream&)) {
      ap << f;
      return *this;
    }
    LogSystem& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      ap << f;
      return *this;
    }

    template <typename F>
    LogSystem& log(F&& iF) {
      iF(ap);
      return *this;
    }

  private:
    MessageSender ap;
    LogSystem(LogSystem const&) = delete;  // Change log 9
    LogSystem& operator=(LogSystem const&) = delete;

  };  // LogSystem

  class LogInfo {
  public:
    explicit LogInfo(std::string const& id)
        : ap(ELinfo,
             id,
             false,
             (MessageDrop::infoAlwaysSuppressed || !MessageDrop::instance()->infoEnabled))  // Change log 21
    {}
    ~LogInfo();  // Change log 13

    template <class T>
    LogInfo& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    LogInfo& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogInfo& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }

    template <typename F>
    LogInfo& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    LogInfo(LogInfo const&) = delete;  // Change log 9
    LogInfo& operator=(LogInfo const&) = delete;

  };  // LogInfo

  // verbatim version of LogInfo
  class LogVerbatim  // change log 2
  {
  public:
    explicit LogVerbatim(std::string const& id)
        : ap(ELinfo,
             id,
             true,
             (MessageDrop::infoAlwaysSuppressed || !MessageDrop::instance()->infoEnabled))  // Change log 21
    {}
    ~LogVerbatim();  // Change log 13

    template <class T>
    LogVerbatim& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    // Change log 14
    LogVerbatim& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogVerbatim& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }

    template <typename F>
    LogVerbatim& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    LogVerbatim(LogVerbatim const&) = delete;  // Change log 9
    LogVerbatim& operator=(LogVerbatim const&) = delete;

  };  // LogVerbatim

  // verbatim version of LogWarning
  class LogPrint  // change log 3
  {
  public:
    explicit LogPrint(std::string const& id)
        : ap(ELwarning,
             id,
             true,
             (MessageDrop::warningAlwaysSuppressed || !MessageDrop::instance()->warningEnabled))  // Change log 21
    {}
    ~LogPrint();  // Change log 13

    template <class T>
    LogPrint& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    // Change log 14
    LogPrint& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogPrint& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }

    template <typename F>
    LogPrint& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    LogPrint(LogPrint const&) = delete;  // Change log 9
    LogPrint& operator=(LogPrint const&) = delete;

  };  // LogPrint

  // verbatim version of LogError
  class LogProblem  // change log 4
  {
  public:
    explicit LogProblem(std::string const& id)
        : ap(ELerror, id, true, !MessageDrop::instance()->errorEnabled)  // Change log 24
    {}
    ~LogProblem();  // Change log 13

    template <class T>
    LogProblem& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    LogProblem& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogProblem& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }

    template <typename F>
    LogProblem& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    LogProblem(LogProblem const&) = delete;  // Change log 9
    LogProblem& operator=(LogProblem const&) = delete;

  };  // LogProblem

  // less judgemental verbatim version of LogError
  class LogImportant  // change log 11
  {
  public:
    explicit LogImportant(std::string const& id)
        : ap(ELerror, id, true, !MessageDrop::instance()->errorEnabled)  // Change log 24
    {}
    ~LogImportant();  // Change log 13

    template <class T>
    LogImportant& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    LogImportant& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogImportant& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }

    template <typename F>
    LogImportant& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    LogImportant(LogImportant const&) = delete;  // Change log 9
    LogImportant& operator=(LogImportant const&) = delete;

  };  // LogImportant

  // verbatim version of LogSystem
  class LogAbsolute  // change log 4
  {
  public:
    explicit LogAbsolute(std::string const& id)
        : ap(ELsevere, id, true)  // true for verbatim
    {}
    ~LogAbsolute();  // Change log 13

    template <class T>
    LogAbsolute& operator<<(T const& t) {
      ap << t;
      return *this;
    }
    LogAbsolute& operator<<(std::ostream& (*f)(std::ostream&)) {
      ap << f;
      return *this;
    }
    LogAbsolute& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      ap << f;
      return *this;
    }

    template <typename F>
    LogAbsolute& log(F&& iF) {
      iF(ap);
      return *this;
    }

  private:
    MessageSender ap;
    LogAbsolute(LogAbsolute const&) = delete;  // Change log 9
    LogAbsolute& operator=(LogAbsolute const&) = delete;

  };  // LogAbsolute

  std::string stripLeadingDirectoryTree(const std::string& file);

  // change log 10:  removed onlyLowestDirectory()

  void LogStatistics();

  class LogDebug_ {
  public:
    LogDebug_() : ap() {}
    explicit LogDebug_(std::string const& id, std::string const& file, int line);  // Change log 17
    ~LogDebug_();

    template <class T>
    LogDebug_& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    LogDebug_& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogDebug_& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    // Change log 8:  The tests for ap.valid() being null

    template <typename F>
    LogDebug_& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;
    std::string stripLeadingDirectoryTree(const std::string& file) const;
    // change log 10
  };  // LogDebug_

  class LogTrace_ {
  public:
    LogTrace_() : ap() {}
    explicit LogTrace_(std::string const& id);  // Change log 13
    ~LogTrace_();

    template <class T>
    LogTrace_& operator<<(T const& t) {
      if (ap.valid())
        ap << t;
      return *this;
    }
    LogTrace_& operator<<(std::ostream& (*f)(std::ostream&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    LogTrace_& operator<<(std::ios_base& (*f)(std::ios_base&)) {
      if (ap.valid())
        ap << f;
      return *this;
    }
    // Change log 8:  The tests for ap.valid() being null

    template <typename F>
    LogTrace_& log(F&& iF) {
      if (ap.valid()) {
        iF(ap);
      }
      return *this;
    }

  private:
    MessageSender ap;

  };  // LogTrace_

  // Change log 22
  namespace edmmltest {
    class LogWarningThatSuppressesLikeLogInfo {
    public:
      explicit LogWarningThatSuppressesLikeLogInfo(std::string const& id)
          : ap(ELwarning,
               id,
               false,
               (MessageDrop::infoAlwaysSuppressed || !MessageDrop::instance()->warningEnabled))  // Change log 22
      {}
      ~LogWarningThatSuppressesLikeLogInfo();
      template <class T>
      LogWarningThatSuppressesLikeLogInfo& operator<<(T const& t) {
        if (ap.valid())
          ap << t;
        return *this;
      }
      LogWarningThatSuppressesLikeLogInfo& operator<<(std::ostream& (*f)(std::ostream&)) {
        if (ap.valid())
          ap << f;
        return *this;
      }
      LogWarningThatSuppressesLikeLogInfo& operator<<(std::ios_base& (*f)(std::ios_base&)) {
        if (ap.valid())
          ap << f;
        return *this;
      }

      template <typename F>
      LogWarningThatSuppressesLikeLogInfo& log(F&& iF) {
        if (ap.valid()) {
          iF(ap);
        }
        return *this;
      }

    private:
      MessageSender ap;
      LogWarningThatSuppressesLikeLogInfo(LogWarningThatSuppressesLikeLogInfo const&) = delete;  // Change log 9
      LogWarningThatSuppressesLikeLogInfo& operator=(LogWarningThatSuppressesLikeLogInfo const&) = delete;

    };  // LogWarningThatSuppressesLikeLogInfo
  }     // end namespace edmmltest

  class Suppress_LogDebug_ {
    // With any decent optimization, use of Suppress_LogDebug_ (...)
    // including streaming of items to it via operator<<
    // will produce absolutely no executable code.
  public:
    template <class T>
    Suppress_LogDebug_& operator<<(T const&) {
      return *this;
    }                                                                                     // Change log 12
    Suppress_LogDebug_& operator<<(std::ostream& (*)(std::ostream&)) { return *this; }    // Change log 12
    Suppress_LogDebug_& operator<<(std::ios_base& (*)(std::ios_base&)) { return *this; }  // Change log 12

    template <typename F>
    Suppress_LogDebug_& log(F&& iF) {
      return *this;
    }
  };  // Suppress_LogDebug_

  bool isDebugEnabled();
  bool isInfoEnabled();
  bool isWarningEnabled();
  void HaltMessageLogging();
  void FlushMessageLog();
  void clearMessageLog();
  void GroupLogStatistics(std::string const& category);
  bool isMessageProcessingSetUp();

  // Change Log 15
  // The following two methods have no effect except in stand-alone apps
  // that do not create a MessageServicePresence:
  void setStandAloneMessageThreshold(edm::ELseverityLevel const& severity);
  void squelchStandAloneMessageCategory(std::string const& category);

}  // namespace edm

// change log 19 and change log 20
// The preprocessor symbol controlling suppression of LogDebug is EDM_ML_DEBUG.  Thus by default (BEHAVIOR CHANGE) LogDebug is
// If LogDebug is suppressed, all code past the LogDebug(...) is squelched.
// See doc/suppression.txt.

#ifndef EDM_ML_DEBUG
#define LogDebug(id) true ? edm::Suppress_LogDebug_() : edm::Suppress_LogDebug_()
#define LogTrace(id) true ? edm::Suppress_LogDebug_() : edm::Suppress_LogDebug_()
#else
// change log 21
#define LogDebug(id)                                                                       \
  (edm::MessageDrop::debugAlwaysSuppressed || !edm::MessageDrop::instance()->debugEnabled) \
      ? edm::LogDebug_()                                                                   \
      : edm::LogDebug_(id, __FILE__, __LINE__)
#define LogTrace(id)                                                                                          \
  (edm::MessageDrop::debugAlwaysSuppressed || !edm::MessageDrop::instance()->debugEnabled) ? edm::LogTrace_() \
                                                                                           : edm::LogTrace_(id)
#endif

// change log 27
//
// These macros reduce the need to pollute the code with #ifdefs. The
// idea is that the condition is checked only if debugging is enabled.
// That way the condition expression may use variables that are
// declared only if EDM_ML_DEBUG is enabled. If it is disabled, rely
// on the fact that LogDebug/LogTrace should compile to no-op.
#ifdef EDM_ML_DEBUG
#define IfLogDebug(cond, cat) \
  if (cond)                   \
  LogDebug(cat)
#define IfLogTrace(cond, cat) \
  if (cond)                   \
  LogTrace(cat)
#else
#define IfLogDebug(cond, cat) LogDebug(cat)
#define IfLogTrace(cond, cat) LogTrace(cat)
#endif

#endif  // MessageLogger_MessageLogger_h