logger.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_LOGGER_HEADER
#define LIBFILEZILLA_LOGGER_HEADER
 
#include "format.hpp"
 
#include <atomic>
 
namespace fz {
namespace logmsg
{
    enum type : uint64_t
    {
        status        = 1ull,
 
        error         = 1ull << 1,
 
        command       = 1ull << 2,
 
        reply         = 1ull << 3,
 
        debug_warning = 1ull << 4,
        debug_info    = 1ull << 5,
        debug_verbose = 1ull << 6,
        debug_debug   = 1ull << 7,
 
        custom1     = 1ull << 32,
        custom32    = 1ull << 63
    };
}
 
class FZ_PUBLIC_SYMBOL logger_interface
{
public:
    logger_interface() noexcept = default;
    virtual ~logger_interface() = default;
 
    logger_interface(logger_interface const&) = delete;
    logger_interface& operator=(logger_interface const&) = delete;
 
 
    virtual void do_log(logmsg::type t, std::wstring && msg) = 0;
 
    template<typename String, typename...Args>
    void log(logmsg::type t, String&& fmt, Args&& ...args)
    {
        if (should_log(t)) {
            std::wstring formatted = fz::sprintf(fz::to_wstring(std::forward<String>(fmt)), args...);
            do_log(t, std::move(formatted));
        }
    }
 
    template<typename String, typename...Args>
    void log_u(logmsg::type t, String&& fmt, Args const& ...args)
    {
        if (should_log(t)) {
            std::wstring formatted = fz::sprintf(fz::to_wstring(std::forward<String>(fmt)), assume_strings_are_utf8(args)...);
            do_log(t, std::move(formatted));
        }
    }
 
    template<typename String>
    void log_raw(logmsg::type t, String&& msg)
    {
        if (should_log(t)) {
            std::wstring formatted = fz::to_wstring(std::forward<String>(msg));
            do_log(t, std::move(formatted));
        }
    }
 
    template<typename String>
    void log_u_raw(logmsg::type t, String&& msg)
    {
        if (should_log(t)) {
            std::wstring formatted = fz::to_wstring_from_utf8(std::forward<String>(msg));
            do_log(t, std::move(formatted));
        }
    }
 
    bool should_log(logmsg::type t) const {
        return level_ & t;
    }
 
    logmsg::type levels() const {
        return static_cast<logmsg::type>(level_.load());
    }
 
    virtual void set_all(logmsg::type t) {
        level_ = t;
    }
 
    void set(logmsg::type t, bool flag) {
        if (flag) {
            enable(t);
        }
        else {
            disable(t);
        }
    }
 
    virtual void enable(logmsg::type t) {
        level_ |= t;
    }
 
    virtual void disable(logmsg::type t) {
        level_ &= ~t;
    }
 
protected:
    std::atomic<uint64_t> level_{logmsg::status | logmsg::error | logmsg::command | logmsg::reply};
 
private:
    std::wstring assume_strings_are_utf8(std::string_view const& arg) {
        return fz::to_wstring_from_utf8(arg);
    }
    std::wstring assume_strings_are_utf8(std::string const& arg) {
        return fz::to_wstring_from_utf8(arg);
    }
    std::wstring assume_strings_are_utf8(char const* arg) {
        return fz::to_wstring_from_utf8(arg);
    }
 
    template <typename T>
    T const& assume_strings_are_utf8(T const& arg) {
        return arg;
    }
};
 
class FZ_PUBLIC_SYMBOL null_logger final : public logger_interface
{
public:
    null_logger() noexcept
    {
        disable(levels());
    }
 
    virtual void do_log(logmsg::type, std::wstring &&) override {}
    virtual void set_all(logmsg::type) override {}
    virtual void enable(logmsg::type) override {}
};
 
null_logger FZ_PUBLIC_SYMBOL & get_null_logger();
 
class FZ_PUBLIC_SYMBOL stdout_logger final : public logger_interface
{
public:
    virtual void do_log(logmsg::type, std::wstring &&) override;
};
 
 
}
 
#endif