ThreadSafeLogStream.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//-----------------------------------------------
// Includes
//-----------------------------------------------
#include "MantidKernel/ThreadSafeLogStream.h"
 
#include <Poco/Logger.h>
#include <Poco/StreamUtil.h>
#include <Poco/UnbufferedStreamBuf.h>
 
using namespace Mantid::Kernel;
 
//************************************************************
// ThreadSafeLogStreamBuf
//************************************************************
 
ThreadSafeLogStreamBuf::ThreadSafeLogStreamBuf(Poco::Logger &logger, Poco::Message::Priority priority)
    : Poco::LogStreamBuf(logger, priority), m_messages() {}
 
int ThreadSafeLogStreamBuf::overflow(char c) { return Poco::UnbufferedStreamBuf::overflow(c); }
 
int ThreadSafeLogStreamBuf::writeToDevice(char c) {
  if (c == '\n' || c == '\r') {
    Poco::Message msg(logger().name(), m_messages[Poco::Thread::currentTid()], getPriority());
    m_messages[Poco::Thread::currentTid()] = "";
    logger().log(msg);
  } else {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_messages[Poco::Thread::currentTid()] += c;
  }
  return static_cast<int>(c);
}
 
void ThreadSafeLogStreamBuf::accumulate(const std::string &message) {
  std::lock_guard<std::mutex> lock(m_mutex);
  m_accumulator[Poco::Thread::currentTid()] += message;
}
 
std::string ThreadSafeLogStreamBuf::flush() {
  const std::string returnValue = m_accumulator[Poco::Thread::currentTid()];
  std::lock_guard<std::mutex> lock(m_mutex);
  m_accumulator[Poco::Thread::currentTid()] = "";
  return returnValue;
}
 
//************************************************************
// ThreadSafeLogIOS
//************************************************************
ThreadSafeLogIOS::ThreadSafeLogIOS(Poco::Logger &logger, Poco::Message::Priority priority) : m_buf(logger, priority) {
  poco_ios_init(&m_buf);
}
 
Poco::LogStreamBuf *ThreadSafeLogIOS::rdbuf() { return &m_buf; }
 
//************************************************************
// ThreadSafeLogStream
//************************************************************
ThreadSafeLogStream::ThreadSafeLogStream(Poco::Logger &logger, Poco::Message::Priority priority)
    : ThreadSafeLogIOS(logger, priority), std::ostream(&m_buf) {}
 
ThreadSafeLogStream::ThreadSafeLogStream(const std::string &loggerName, Poco::Message::Priority priority)
    : ThreadSafeLogIOS(Poco::Logger::get(loggerName), priority), std::ostream(&m_buf) {}
 
ThreadSafeLogStream &ThreadSafeLogStream::fatal() { return priority(Poco::Message::PRIO_FATAL); }
 
ThreadSafeLogStream &ThreadSafeLogStream::fatal(const std::string &message) {
  m_buf.logger().fatal(message);
  return priority(Poco::Message::PRIO_FATAL);
}
 
ThreadSafeLogStream &ThreadSafeLogStream::critical() { return priority(Poco::Message::PRIO_CRITICAL); }
 
ThreadSafeLogStream &ThreadSafeLogStream::critical(const std::string &message) {
  m_buf.logger().critical(message);
  return priority(Poco::Message::PRIO_CRITICAL);
}
 
ThreadSafeLogStream &ThreadSafeLogStream::error() { return priority(Poco::Message::PRIO_ERROR); }
 
ThreadSafeLogStream &ThreadSafeLogStream::error(const std::string &message) {
  m_buf.logger().error(message);
  return priority(Poco::Message::PRIO_ERROR);
}
 
ThreadSafeLogStream &ThreadSafeLogStream::warning() { return priority(Poco::Message::PRIO_WARNING); }
 
ThreadSafeLogStream &ThreadSafeLogStream::warning(const std::string &message) {
  m_buf.logger().warning(message);
  return priority(Poco::Message::PRIO_WARNING);
}
 
ThreadSafeLogStream &ThreadSafeLogStream::notice() { return priority(Poco::Message::PRIO_NOTICE); }
 
ThreadSafeLogStream &ThreadSafeLogStream::notice(const std::string &message) {
  m_buf.logger().notice(message);
  return priority(Poco::Message::PRIO_NOTICE);
}
 
ThreadSafeLogStream &ThreadSafeLogStream::information() { return priority(Poco::Message::PRIO_INFORMATION); }
 
ThreadSafeLogStream &ThreadSafeLogStream::information(const std::string &message) {
  m_buf.logger().information(message);
  return priority(Poco::Message::PRIO_INFORMATION);
}
 
ThreadSafeLogStream &ThreadSafeLogStream::debug() { return priority(Poco::Message::PRIO_DEBUG); }
 
ThreadSafeLogStream &ThreadSafeLogStream::debug(const std::string &message) {
  m_buf.logger().debug(message);
  return priority(Poco::Message::PRIO_DEBUG);
}
 
ThreadSafeLogStream &ThreadSafeLogStream::priority(Poco::Message::Priority priority) {
  m_buf.setPriority(priority);
  return *this;
}
 
ThreadSafeLogStream &ThreadSafeLogStream::accumulate(const std::string &message) {
  m_buf.accumulate(message);
  return *this;
}
 
std::string ThreadSafeLogStream::flush() { return m_buf.flush(); }