Logger.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Logger.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2016-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once
// STL include(s)
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <thread>

// clang-format off
//         <tt>std::unique_ptr<const Acts::Logger></tt>
#define ACTS_LOCAL_LOGGER(log_object)                                          \
  struct __local_acts_logger                                                   \
  {                                                                            \
    __local_acts_logger(std::unique_ptr<const ::Acts::Logger> logger):         \
      m_logger(std::move(logger))                                              \
    {}                                                                         \
                                                                               \
    const ::Acts::Logger& operator()() const                                   \
    {                                                                          \
      return *m_logger;                                                        \
    }                                                                          \
                                                                               \
    std::unique_ptr<const ::Acts::Logger> m_logger;                            \
  };                                                                           \
  __local_acts_logger logger(log_object);

#define ACTS_VERBOSE(x)                                                        \
  if (logger().doPrint(Acts::Logging::VERBOSE))                                \
    logger().log(Acts::Logging::VERBOSE) << x;

#define ACTS_DEBUG(x)                                                          \
  if (logger().doPrint(Acts::Logging::DEBUG))                                  \
    logger().log(Acts::Logging::DEBUG) << x;

#define ACTS_INFO(x)                                                           \
  if (logger().doPrint(Acts::Logging::INFO))                                   \
    logger().log(Acts::Logging::INFO) << x;

#define ACTS_WARNING(x)                                                        \
  if (logger().doPrint(Acts::Logging::WARNING))                                \
    logger().log(Acts::Logging::WARNING) << x;

#define ACTS_ERROR(x)                                                          \
  if (logger().doPrint(Acts::Logging::ERROR))                                  \
    logger().log(Acts::Logging::ERROR) << x;

#define ACTS_FATAL(x)                                                          \
  if (logger().doPrint(Acts::Logging::FATAL))                                  \
    logger().log(Acts::Logging::FATAL) << x;
// clang-format on

namespace Acts {

namespace Logging {
enum Level {
  VERBOSE = 0,  
  DEBUG,        
  INFO,         
  WARNING,      
  ERROR,        
  FATAL         
};

class OutputPrintPolicy {
 public:
  virtual ~OutputPrintPolicy() = default;

  virtual void flush(const Level& lvl, const std::ostringstream& input) = 0;
};

class OutputFilterPolicy {
 public:
  virtual ~OutputFilterPolicy() = default;

  virtual bool doPrint(const Level& lvl) const = 0;
};

class OutStream final {
  using OutputFunc = std::function<void(const std::ostringstream&)>;

 public:
  explicit OutStream(OutputFunc output)
      : m_stream(), m_outputFunctor(std::move(output)) {}

  OutStream(const OutStream& copy)
      : m_stream(), m_outputFunctor(copy.m_outputFunctor) {
    m_stream << copy.m_stream.str();
  }

  ~OutStream() { m_outputFunctor(m_stream); }

  template <typename T>
  OutStream& operator<<(T&& input) {
    m_stream << std::forward<T>(input);
    return *this;
  }

  template <typename T>
  OutStream& operator<<(T& (*f)(T&)) {
    f(m_stream);
    return *this;
  }

 private:
  std::ostringstream m_stream;

  OutputFunc m_outputFunctor;
};

class DefaultFilterPolicy final : public OutputFilterPolicy {
 public:
  explicit DefaultFilterPolicy(const Level& lvl) : m_level(lvl) {}

  ~DefaultFilterPolicy() override = default;

  bool doPrint(const Level& lvl) const override { return m_level <= lvl; }

 private:
  Level m_level;
};

class OutputDecorator : public OutputPrintPolicy {
 public:
  explicit OutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
      : m_wrappee(std::move(wrappee)) {}

  void flush(const Level& lvl, const std::ostringstream& input) override {
    m_wrappee->flush(lvl, input);
  }

 private:
  std::unique_ptr<OutputPrintPolicy> m_wrappee;
};

class NamedOutputDecorator final : public OutputDecorator {
 public:
  NamedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee,
                       const std::string& name, unsigned int maxWidth = 15)
      : OutputDecorator(std::move(wrappee)),
        m_name(name),
        m_maxWidth(maxWidth) {}

  void flush(const Level& lvl, const std::ostringstream& input) override {
    std::ostringstream os;
    os << std::left << std::setw(m_maxWidth) << m_name.substr(0, m_maxWidth - 3)
       << input.str();
    OutputDecorator::flush(lvl, os);
  }

 private:
  std::string m_name;

  unsigned int m_maxWidth;
};

class TimedOutputDecorator final : public OutputDecorator {
 public:
  TimedOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee,
                       const std::string& format = "%X")
      : OutputDecorator(std::move(wrappee)), m_format(format) {}

  void flush(const Level& lvl, const std::ostringstream& input) override {
    std::ostringstream os;
    os << std::left << std::setw(12) << now() << input.str();
    OutputDecorator::flush(lvl, os);
  }

 private:
  std::string now() const {
    char buffer[20];
    time_t t;
    std::time(&t);
    std::strftime(buffer, sizeof(buffer), m_format.c_str(), localtime(&t));
    return buffer;
  }

  std::string m_format;
};

class ThreadOutputDecorator final : public OutputDecorator {
 public:
  explicit ThreadOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
      : OutputDecorator(std::move(wrappee)) {}

  void flush(const Level& lvl, const std::ostringstream& input) override {
    std::ostringstream os;
    os << std::left << std::setw(20) << std::this_thread::get_id()
       << input.str();
    OutputDecorator::flush(lvl, os);
  }
};

class LevelOutputDecorator final : public OutputDecorator {
 public:
  explicit LevelOutputDecorator(std::unique_ptr<OutputPrintPolicy> wrappee)
      : OutputDecorator(std::move(wrappee)) {}

  void flush(const Level& lvl, const std::ostringstream& input) override {
    std::ostringstream os;
    os << std::left << std::setw(10) << toString(lvl) << input.str();
    OutputDecorator::flush(lvl, os);
  }

 private:
  std::string toString(const Level& lvl) const {
    static const char* const buffer[] = {"VERBOSE", "DEBUG", "INFO",
                                         "WARNING", "ERROR", "FATAL"};
    return buffer[lvl];
  }
};

class DefaultPrintPolicy final : public OutputPrintPolicy {
 public:
  explicit DefaultPrintPolicy(std::ostream* out = &std::cout) : m_out(out) {}

  void flush(const Level& /*lvl*/, const std::ostringstream& input) final {
    (*m_out) << input.str() << std::endl;
  }

 private:
  std::ostream* m_out;
};
}  // namespace Logging

class Logger {
 public:
  Logger(std::unique_ptr<Logging::OutputPrintPolicy> pPrint,
         std::unique_ptr<Logging::OutputFilterPolicy> pFilter)
      : m_printPolicy(std::move(pPrint)), m_filterPolicy(std::move(pFilter)) {}

  bool doPrint(const Logging::Level& lvl) const {
    return m_filterPolicy->doPrint(lvl);
  }

  Logging::OutStream log(const Logging::Level& lvl) const {
    return Logging::OutStream(std::bind(&Logging::OutputPrintPolicy::flush,
                                        m_printPolicy.get(), lvl,
                                        std::placeholders::_1));
  }

 private:
  std::unique_ptr<Logging::OutputPrintPolicy> m_printPolicy;

  std::unique_ptr<Logging::OutputFilterPolicy> m_filterPolicy;
};

std::unique_ptr<const Logger> getDefaultLogger(
    const std::string& name, const Logging::Level& lvl,
    std::ostream* log_stream = &std::cout);

}  // namespace Acts