logger.h

#ifndef OE_CORE_LOGGER_H
#define OE_CORE_LOGGER_H
 
#include "../common.h"
#include "../util/non_copyable.h"
 
#include "../lib/fmt.h"
 
#include <sstream>
#include <string>
#include <mutex>
#include <memory>
 
namespace oe::core
{
    class Logger;
    class LogHandler;
 
    enum class LogLevel
    {
        LEVEL_TRACE, 
        LEVEL_DEBUG, 
        LEVEL_INFO, 
        LEVEL_WARNING, 
        LEVEL_ERROR, 
        LEVEL_CRITICAL 
    };
 
    constexpr LogLevel default_log_level = LogLevel::LEVEL_INFO;
 
    typedef uint64_t LogVerbosity;
 
    constexpr uint64_t default_log_verbosity = 0xFFFFFFFF;
 
    class LoggerStream : public util::NonCopyable
    {
        public:
            LoggerStream(LoggerStream&& other) noexcept;
 
            ~LoggerStream();
 
            LoggerStream& operator=(LoggerStream&& other) noexcept;
 
            template<typename T>
            LoggerStream& operator<<(T const& data)
            {
                _stream << data;
                return *this;
            }
 
        private:
            LoggerStream(Logger* logger, LogLevel level, const LogVerbosity verbosity);
 
            std::ostringstream _stream;
 
            LogLevel _level = default_log_level;
            LogVerbosity _verbosity = default_log_verbosity;
            Logger* _logger = nullptr;
 
            friend class Logger;
    };
 
    class Logger
    {
        public:
            Logger();
 
            std::string name;
 
            LogLevel minimum_level = LogLevel::LEVEL_TRACE;
 
            LogVerbosity verbosity = default_log_verbosity;
 
            static Logger& getGlobalInstance()
            {
                static oe::core::Logger instance;
                return instance;
            }
 
            LoggerStream trace(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_TRACE, verbosity);
            }
 
            LoggerStream debug(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_DEBUG, verbosity);
            }
 
            LoggerStream info(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_INFO, verbosity);
            }
 
            LoggerStream warn(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_WARNING, verbosity);
            }
 
            LoggerStream error(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_ERROR, verbosity);
            }
 
            LoggerStream critical(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_CRITICAL, verbosity);
            }
 
            LoggerStream as(LogLevel level, const LogVerbosity verbosity = default_log_verbosity)
            {
                return LoggerStream(this, level, verbosity);
            }
 
            Logger& setDefaultLevel(const LogLevel default_level)
            {
                _default_level = default_level;
                return *this;
            }
 
            Logger& setDefaultVerbosity(const LogVerbosity verbosity)
            {
                _default_verbosity = verbosity;
                return *this;
            }
 
            template <typename... Args>
            void operator()(fmt::format_string<Args...> format, Args&&... args)
            {
                _write(fmt::vformat(format, fmt::make_format_args(args...)), _default_level, _default_verbosity);
            }
 
            template<typename T>
            LoggerStream operator<<(T const& data)
            {
                LoggerStream stream(this, _default_level, _default_verbosity);
 
                stream << data;
 
                return stream;
            }
 
            void setHandler(std::unique_ptr<LogHandler> handler);
 
            LogHandler* getHandler()
            {
                return _handler.get();
            }
 
            void log(const std::ostringstream& stream, const LogLevel level = default_log_level, const LogVerbosity verbosity = default_log_verbosity);
 
        private:
            void _write(const std::string& message, const LogLevel level, const LogVerbosity verbosity);
 
            LogLevel _default_level = default_log_level;
            LogVerbosity _default_verbosity = default_log_verbosity;
 
            std::unique_ptr<LogHandler> _handler;
 
            std::mutex _mutex;
    };
 
    class LogHandler
    {
        public:
            virtual void write(const std::string& message, const LogLevel level) = 0;
 
            virtual bool canWrite(const LogLevel level, const LogVerbosity verbosity)
            {
                return (verbosity & _logger->verbosity) && level >= _logger->minimum_level;
            }
 
            virtual ~LogHandler() = default;
 
            bool write_stdout = true;
 
            bool write_file = false;
 
        protected:
            Logger* _logger = nullptr;
 
        friend class Logger;
    };
 
    class DefaultLogHandler : public LogHandler
    {
        public:
            virtual void write(const std::string& message, const LogLevel level) override;
    };
}
 
namespace oe
{
    extern core::Logger& log;
}
 
#endif