LogVariableStream.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 <sstream>
#include <vector>
#include <string>
#include <map>
#include <type_traits>
#include <boost/lexical_cast.hpp>

class LogVar {
public:
  template<class TVarType>
  LogVar(const std::string& name, const TVarType& v) : m_name(name)
  {
    if constexpr(std::is_enum_v<TVarType>) {
      // Convert an enum to its underlying integer type (int, short, etc.).
      // This avoids problematic boost::is_signed checks on the enum itself.
      auto underlying_value = static_cast<typename std::underlying_type_t<TVarType>>(v);
      m_value = std::to_string(underlying_value);
    } else {
      m_value = boost::lexical_cast<std::string>(v);
    }
  }

  std::string getValue() const
  {
    return m_value;
  }

  std::string getName() const
  {
    return m_name;
  }

  bool operator==(const LogVar& lv) const
  {
    return (lv.m_name == this->m_name) && (lv.m_value == this->m_value);
  }
 
private:
  std::string m_name;

  std::string m_value;
};

class LogModRealm {
public:
  LogModRealm(Belle2::LogConfig::ELogRealm realm, Belle2::LogConfig::ELogLevel logLevel) :
    m_realm(realm),
    m_logLevel(logLevel)
  {
  }

  Belle2::LogConfig::ELogRealm getRealm() const
  {
    return m_realm;
  }

  Belle2::LogConfig::ELogLevel getLogLevel() const
  {
    return m_logLevel;
  }
 
private:
  Belle2::LogConfig::ELogRealm m_realm;

  Belle2::LogConfig::ELogLevel m_logLevel;
};

class LogVariableStream {
public:

  typedef std::basic_ostream<std::stringstream::char_type, std::stringstream::traits_type > __basic_ostream_type;

  LogVariableStream() = default;

  LogVariableStream(LogVariableStream&&) = default;

  LogVariableStream(const LogVariableStream& other) :  m_variables(other.m_variables), m_logLevelOverride(other.m_logLevelOverride)
  {
    // copy manually because stringstream has no copy-constructor
    m_stringStream << other.m_stringStream.str();
  }

  explicit LogVariableStream(std::string const& text, std::map<std::string, std::string> variables = {})
  {
    m_stringStream << text;
    for (auto const& kv : variables) {
      m_variables.emplace_back(LogVar(kv.first, kv.second));
    }
  }

  // cppcheck-suppress constParameter ; no, this cannot be const otherwise e.g. std::endl doesn't work
  LogVariableStream& operator<<(__basic_ostream_type & (*__pf)(__basic_ostream_type&))
  {
    // execute provided function on the string stream
    __pf(m_stringStream);
    return *this;
  }

  LogVariableStream& operator<<(LogVar const& var)
  {
    m_variables.push_back(var);
    return *this;
  }

  LogVariableStream& operator<<(LogModRealm const& var);

  template<class TText>
  typename std::enable_if<not std::is_fundamental<TText>::value, LogVariableStream&>::type operator<<(TText const& text)
  {
    this->m_stringStream << text;
    return *this;
  }

  template<class PODTYPE>
  typename std::enable_if<std::is_fundamental<PODTYPE>::value, LogVariableStream&>::type operator<<(PODTYPE pod)
  {
    this->m_stringStream << pod;
    return *this;
  }

  bool operator==(const LogVariableStream& lvs) const
  {
    return (lvs.m_variables == this->m_variables) && (lvs.m_stringStream.str() == this->m_stringStream.str());
  }

  LogVariableStream& operator=(const LogVariableStream& lvs)
  {
    this->m_stringStream = std::stringstream();
    this->m_stringStream << lvs.m_stringStream.str();
    this->m_variables = lvs.m_variables;
    return *this;
  }

  std::string str(bool showVariables = true) const
  {
    // little optimization, so we don't need to copy the whole string
    // in the cases where there are no variables ...
    if (m_variables.size() == 0 or !showVariables) {
      return m_stringStream.str();
    }
 
    std::stringstream tmpBuffer;
    // put the string first
    tmpBuffer <<  m_stringStream.str();
    for (auto const& v : m_variables) {
      tmpBuffer << std::endl << "\t" << v.getName() << " = " << v.getValue();
    }
    return tmpBuffer.str();
  }

  std::string getMessage() const
  {
    return m_stringStream.str();
  }

  const std::vector<LogVar>& getVariables() const
  {
    return m_variables;
  }

  void adjustLogLevel(Belle2::LogConfig::ELogLevel& logLevel) const
  {
    if (m_logLevelOverride != Belle2::LogConfig::c_Default) {
      logLevel = m_logLevelOverride;
    }
  }
 
private:

  std::stringstream m_stringStream;

  std::vector<LogVar> m_variables;

  Belle2::LogConfig::ELogLevel m_logLevelOverride = Belle2::LogConfig::c_Default;
};