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),
    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;
};