LoggerStream.cpp

Go to the documentation of this file.

#include <Poco/FileChannel.h> 

#include "LoggerStream.hpp"

#ifndef USE_POCO_LOGGER
#define USE_POCO_LOGGER 1
#endif

#if USE_POCO_LOGGER == 1
  #include <Poco/Logger.h>
#else
  //TODO
#endif

namespace HCE
{
//-----------------------------------------------------------------------------
LoggerStream::LoggerStream(const std::string& source_)
: inherited(), logBuf(), pBuf(nullptr), prefix(""), suffix(""), logPriority(Priority::PRIO_NONE), source(source_)
{
  resetLogStream();
  resetLoggable();
}
//-----------------------------------------------------------------------------
LoggerStream::~LoggerStream(void)
{
}
//-----------------------------------------------------------------------------
void LoggerStream::resetLogStream(void)
{
  logBuf.str("");
  pBuf = &logBuf;
  this->rdbuf(pBuf);
}
//-----------------------------------------------------------------------------
void LoggerStream::setLogStream(std::ostream& os_)
{
  pBuf=os_.rdbuf();
  this->rdbuf(pBuf);
}
//-----------------------------------------------------------------------------
std::string LoggerStream::logMsg(bool isReset)
{
  std::string result = logBuf.str();
  if (isReset)
    logBuf.str("");
  return result;
}
//-----------------------------------------------------------------------------
std::ostream& LoggerStream::log(unsigned int logPriority_)
{
  logPriority = logPriority_;
  return *this;
}
//-----------------------------------------------------------------------------
std::ostream& LoggerStream::log(Priority priority)
{
  return log(static_cast<unsigned int>(priority));
}
//-----------------------------------------------------------------------------
void LoggerStream::setLoggable(Loggable loggable_)
{
  loggable = loggable_;
}
//-----------------------------------------------------------------------------
void LoggerStream::resetLoggable(void)
{
  loggable = [](const std::string& data) {return data;};
}
//-----------------------------------------------------------------------------
std::ostream& LoggerStream::put(const std::string& data)
{
  *this << prefix << loggable(data) << suffix;
  return *this;
}
//-----------------------------------------------------------------------------
LoggerStream& LoggerStream::endl(void)
{
  std::stringstream str;
  str << rdbuf();
  logBuf.str("");
  std::endl(put(str.str()));
  return *this;
}
//-----------------------------------------------------------------------------
LoggerStream& LoggerStream::flush(void)
{
  std::stringstream str;
  str << rdbuf();
  logBuf.str("");
  std::flush(put(str.str()));
  return *this;
}
//-----------------------------------------------------------------------------
void LoggerStream::saveSafe(void)
{
  try
  {
#if USE_POCO_LOGGER == 1
    static Poco::Logger& logger = Poco::Logger::root();
    logger.log(Poco::Message(getSource(), logMsg(), static_cast<Poco::Message::Priority>(getLogPriority())));
#else
  //TODO (implementation in future)
#endif
  }
  catch(Poco::Exception& e)
  {
    std::cerr << "LoggerStream: " << e.displayText() << std::endl;
  }
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
std::ostream& endl(std::ostream& os)
{
  if (typeid(os)==typeid(LoggerStream))
  {
    LoggerStream& ls = reinterpret_cast<LoggerStream&>(os);
    ls.endl();
    ls.saveSafe();
  }
  else
    std::endl(os);
  return os;
}
//-----------------------------------------------------------------------------
std::ostream& flush(std::ostream& os)
{
  if (typeid(os)==typeid(LoggerStream))
  {
    LoggerStream& ls = reinterpret_cast<LoggerStream&>(os);
    ls.flush();
    ls.saveSafe();
  }
  else
    std::flush(os);
  return os;
}
//-----------------------------------------------------------------------------
LoggerStream& operator<<(LoggerStream& os, const std::string& rhs)
{
  os.log(os.getLogPriority()) << rhs;
  return os;
}
//-----------------------------------------------------------------------------
LoggerStream& operator<<(LoggerStream& os, const char* rhs)
{
  os.log(os.getLogPriority()) << rhs;
  return os;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // end namespace HCE