Logging.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_LOGGER_HPP
#define CUBBYFLOW_LOGGER_HPP
 
#include <cstdint>
#include <sstream>
 
namespace CubbyFlow
{
enum class LogLevel : uint8_t
{
    All = 0,
    Debug = 1,
    Info = 2,
    Warn = 3,
    Error = 4,
    Off = 5
};
 
class Logger final
{
 public:
    explicit Logger(LogLevel level);
 
    Logger(const Logger&) = delete;
 
    Logger(Logger&&) noexcept = delete;
 
    ~Logger();
 
    Logger& operator=(const Logger&) = delete;
 
    Logger& operator=(Logger&&) noexcept = delete;
 
    template <typename T>
    const Logger& operator<<(const T& x) const
    {
        m_buffer << x;
        return *this;
    }
 
 private:
    LogLevel m_level;
    mutable std::stringstream m_buffer{};
};
 
class Logging
{
 public:
    static void SetInfoStream(std::ostream* stream);
 
    static void SetWarnStream(std::ostream* stream);
 
    static void SetErrorStream(std::ostream* stream);
 
    static void SetDebugStream(std::ostream* stream);
 
    static void SetAllStream(std::ostream* stream);
 
    static std::string GetHeader(LogLevel level);
 
    static void SetLevel(LogLevel level);
 
    static void Mute();
 
    static void Unmute();
};
 
extern Logger infoLogger;
 
extern Logger warnLogger;
 
extern Logger errorLogger;
 
extern Logger debugLogger;
 
#define CUBBYFLOW_INFO                                               \
    (Logger(LogLevel::Info)                                          \
     << Logging::GetHeader(LogLevel::Info) << "[" << __FILE__ << ":" \
     << __LINE__ << " (" << __func__ << ")] ")
#define CUBBYFLOW_WARN                                               \
    (Logger(LogLevel::Warn)                                          \
     << Logging::GetHeader(LogLevel::Warn) << "[" << __FILE__ << ":" \
     << __LINE__ << " (" << __func__ << ")] ")
#define CUBBYFLOW_ERROR                                               \
    (Logger(LogLevel::Error)                                          \
     << Logging::GetHeader(LogLevel::Error) << "[" << __FILE__ << ":" \
     << __LINE__ << " (" << __func__ << ")] ")
#define CUBBYFLOW_DEBUG                                               \
    (Logger(LogLevel::Debug)                                          \
     << Logging::GetHeader(LogLevel::Debug) << "[" << __FILE__ << ":" \
     << __LINE__ << " (" << __func__ << ")] ")
}  // namespace CubbyFlow
 
#endif