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 <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