Logger.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2021 - 2021.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SL_LOG_LOGGER_HPP
#define SL_LOG_LOGGER_HPP
 
#pragma once
 
#include "Core.hpp"
#include "Record.hpp"
#include "RecordBuilder.hpp"
 
#include <cassert>
#include <functional>
#include <version>
 
#ifdef __cpp_lib_source_location
#include <source_location>
#endif
 
namespace sl::log
{
    template <class TLogger>
    struct LoggerTypedefs
    {
        using Record_t = typename TLogger::Record_t;
    };
 
    template <class TLogger>
    requires requires
    {
        typename LoggerTypedefs<TLogger>::Record_t;
    }
    using LoggerRecord_t = typename LoggerTypedefs<TLogger>::Record_t;
 
    template <class T>
    concept Logger =
    requires
    {
        typename LoggerRecord_t<T>;
    } &&
    Record<LoggerRecord_t<T>> &&
    std::is_invocable_r_v<RecordBuilder<LoggerRecord_t<T>>, T>;
 
    template <Record TRecord>
    class BaseLogger
    {
    public:
        using Record_t = std::remove_cvref_t<TRecord>;
        using RecordSetters_t = RecordSetters<Record_t>;
        using SeverityLevel_t = RecordSeverity_t<Record_t>;
        using Channel_t = RecordChannel_t<Record_t>;
        using RecordBuilder_t = RecordBuilder<Record_t>;
        using LogCallback_t = std::function<void(Record_t)>;
 
        explicit BaseLogger(
            LogCallback_t logCallback,
            SeverityLevel_t defaultSeverityLvl = {},
            Channel_t defaultChannel = {}
        ) noexcept :
            m_LogCallback{ std::move(logCallback) },
            m_DefaultSeverityLvl{ std::move(defaultSeverityLvl) },
            m_DefaultChannel{ std::move(defaultChannel) }
        {
        }
 
        ~BaseLogger() noexcept = default;
 
        BaseLogger(const BaseLogger&) noexcept = default;
        BaseLogger& operator =(const BaseLogger&) noexcept = default;
 
        BaseLogger(BaseLogger&&) noexcept = default;
        BaseLogger& operator =(BaseLogger&&) noexcept = default;
 
        [[nodiscard]]
#ifdef __cpp_lib_source_location
        RecordBuilder_t operator ()(const std::source_location& srcLoc = std::source_location::current())
#else
        RecordBuilder_t operator ()()
#endif
        {
            assert(m_LogCallback != nullptr && "Log callback must be set.");
            Record_t prefabRec;
            RecordSetters_t::setTimePoint(prefabRec, std::chrono::system_clock::now());
            RecordSetters_t::setSeverity(prefabRec, m_DefaultSeverityLvl);
            RecordSetters_t::setChannel(prefabRec, m_DefaultChannel);
            RecordBuilder_t builder{ std::move(prefabRec), m_LogCallback };
 
#ifdef __cpp_lib_source_location
            builder.record().sourceLocation = srcLoc;
#endif
 
            return builder;
        }
 
        template <std::convertible_to<SeverityLevel_t> USeverityLevel>
        void setDefaultSeverity(USeverityLevel&& sevLvl) noexcept
        {
            m_DefaultSeverityLvl = std::forward<USeverityLevel>(sevLvl);
        }
 
        [[nodiscard]]
        const SeverityLevel_t& defaultSeverity() const noexcept
        {
            return m_DefaultSeverityLvl;
        }
 
        template <std::convertible_to<Channel_t> UChannel>
        void setDefaultChannel(UChannel&& channel) noexcept
        {
            m_DefaultChannel = std::forward<UChannel>(channel);
        }
 
        [[nodiscard]]
        const Channel_t& defaultChannel() const noexcept
        {
            return m_DefaultChannel;
        }
 
    private:
        LogCallback_t m_LogCallback;
        SeverityLevel_t m_DefaultSeverityLvl;
        Channel_t m_DefaultChannel;
    };
 
    template <Logger TLogger, class... TArgs>
    TLogger makeLogger(Core<LoggerRecord_t<TLogger>>& core, TArgs&&... args)
    {
        return TLogger{
            [&core](LoggerRecord_t<TLogger>&& rec)
            {
                core.log(std::move(rec));
            },
            std::forward<TArgs>(args)...
        };
    }
 
}
 
#endif