LogVariableStream.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2018 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Thomas Hauth, Martin Ritter                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#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 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)
  {
    // 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;
  }
 
  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;
  }
 
private:
 
  std::stringstream m_stringStream;
 
  std::vector<LogVar> m_variables;
};