LogSystem.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/logging/LogConfig.h>
#include <framework/logging/LogMessage.h>
 
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
 
 
namespace Belle2 {
  class LogConnectionBase;

  class LogSystem {
  public:
    static const unsigned int c_errorSummaryMaxLines = 10000; 

    static LogSystem& Instance();

    void addLogConnection(LogConnectionBase* logConnection);

    void resetLogConnections();

    void resetLogging();

    LogConfig* getLogConfig() {return &m_logConfig;}

    void addPackageLogConfig(const std::string& package, const LogConfig& logConfig) { m_packageLogConfigs[package] = logConfig; }

    LogConfig& getPackageLogConfig(const std::string& package) { return m_packageLogConfigs[package]; }

    LogConfig& getModuleLogConfig(const std::string& module) { return m_moduleLogConfigs[module]; }

    bool isLevelEnabled(LogConfig::ELogLevel level, int debugLevel = 0, const char* package = nullptr) const;

    bool sendMessage(LogMessage&& message);

    void resetMessageCounter();

    int getMessageCounter(LogConfig::ELogLevel logLevel) const;

    const LogConfig& getCurrentLogConfig(const char* package = nullptr) const;

    LogConfig::ELogLevel getCurrentLogLevel(const char* package = nullptr) const { return getCurrentLogConfig(package).getLogLevel(); }

    int getCurrentDebugLevel(const char* package = nullptr) const { return getCurrentLogConfig(package).getDebugLevel(); }

    unsigned getMaxMessageRepetitions() const { return m_maxErrorRepetition; }

    void setMaxMessageRepetitions(unsigned repetitions) { m_maxErrorRepetition = repetitions; }

    void printErrorSummary();

    void enableErrorSummary(bool on) { m_printErrorSummary = on; }

    void updateModule(const LogConfig* moduleLogConfig = nullptr, const std::string& moduleName = "") { m_moduleLogConfig = moduleLogConfig; m_moduleName = moduleName; }

    static void enableDebug() {s_debugEnabled = true;}

    inline static bool debugEnabled() {return s_debugEnabled;}
 
  private:
    std::vector<LogConnectionBase*> m_logConnections;
    LogConfig m_logConfig;
    const LogConfig* m_moduleLogConfig;
    std::string m_moduleName;
    std::map<std::string, LogConfig> m_packageLogConfigs;
    std::map<std::string, LogConfig> m_moduleLogConfigs;
    bool m_printErrorSummary;
    std::unordered_map<LogMessage, int, LogMessage::TextHasher, LogMessage::TextHasher> m_messageLog{100};
    unsigned int m_maxErrorRepetition{0};
    unsigned int m_suppressedMessages{0};
    int m_messageCounter[LogConfig::c_Default];
    static bool s_debugEnabled;

    LogSystem();

    LogSystem(const LogSystem&) = delete;

    LogSystem& operator=(const LogSystem&) = delete;

    ~LogSystem();

    void incMessageCounter(LogConfig::ELogLevel logLevel);

    bool deliverMessageToConnections(const LogMessage& msg);

    void showText(LogConfig::ELogLevel level, const std::string& txt, int info = LogConfig::c_Message);
  };
  class LogSystem {…};
 
  inline const LogConfig& LogSystem::getCurrentLogConfig(const char* package) const
  {
    //module specific config?
    if (m_moduleLogConfig && (m_moduleLogConfig->getLogLevel() != LogConfig::c_Default)) {
      return *m_moduleLogConfig;
    }
    //package specific config?
    if (package && !m_packageLogConfigs.empty()) {
      // cppcheck-suppress stlIfFind ; cppcheck doesn't like scoped variables in if statements
      if (auto it = m_packageLogConfigs.find(package); it != m_packageLogConfigs.end()) {
        const LogConfig& logConfig = it->second;
        if (logConfig.getLogLevel() != LogConfig::c_Default)
          return logConfig;
      }
    }
    //global config
    return m_logConfig;
  }
  inline const LogConfig& LogSystem::getCurrentLogConfig(const char* package) const {…}
 
  inline bool LogSystem::isLevelEnabled(LogConfig::ELogLevel level, int debugLevel, const char* package) const
  {
    const LogConfig& config = getCurrentLogConfig(package);
    const LogConfig::ELogLevel logLevelLimit = config.getLogLevel();
    const int debugLevelLimit = config.getDebugLevel();
    return logLevelLimit <= level && (level != LogConfig::c_Debug || debugLevelLimit >= debugLevel);
  }
  inline bool LogSystem::isLevelEnabled(LogConfig::ELogLevel level, int debugLevel, const char* package) const {…}

} //end of namespace Belle2