Record.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_RECORD_HPP
#define SL_LOG_RECORD_HPP
 
#pragma once
 
#include <chrono>
#include <string>
#include <version>
 
#ifdef __cpp_lib_source_location
    #include <source_location>
#endif
 
namespace sl::log
{
    template <class TRecord>
    struct RecordTypedefs
    {
        using Message_t = typename TRecord::Message_t;
        using Severity_t = typename TRecord::SeverityLevel_t;
        using Channel_t = typename TRecord::Channel_t;
        using TimePoint_t = typename TRecord::TimePoint_t;
    };
 
    template <class TRecord>
    requires requires { typename RecordTypedefs<TRecord>::Message_t; }
    using RecordMessage_t = typename RecordTypedefs<TRecord>::Message_t;
 
    template <class TRecord>
    requires requires { typename RecordTypedefs<TRecord>::Severity_t; }
    using RecordSeverity_t = typename RecordTypedefs<TRecord>::Severity_t;
 
    template <class TRecord>
    requires requires { typename RecordTypedefs<TRecord>::Channel_t; }
    using RecordChannel_t = typename RecordTypedefs<TRecord>::Channel_t;
 
    template <class TRecord>
    requires requires { typename RecordTypedefs<TRecord>::TimePoint_t; }
    using RecordTimePoint_t = typename RecordTypedefs<TRecord>::TimePoint_t;
 
    template <class TRecord>
    concept RecordMemberTypedefs =
    requires
    {
        typename RecordMessage_t<TRecord>;
        typename RecordSeverity_t<TRecord>;
        typename RecordChannel_t<TRecord>;
        typename RecordTimePoint_t<TRecord>;
    };
 
    template <class TRecord>
    struct RecordGetters
    {
        constexpr static auto message{ [](auto& record) { return record.message(); } };
        constexpr static auto severity{ [](auto& record) { return record.severity(); } };
        constexpr static auto channel{ [](auto& record) { return record.channel(); } };
        constexpr static auto timePoint{ [](auto& record) { return record.timePoint(); } };
    };
 
    template <class TRecord>
    concept RecordMemberGetters =
    RecordMemberTypedefs<TRecord> &&
    requires(const TRecord& rec)
    {
        { RecordGetters<TRecord>::message(rec) } -> std::convertible_to<RecordMessage_t<TRecord>>;
        { RecordGetters<TRecord>::severity(rec) } -> std::convertible_to<RecordSeverity_t<TRecord>>;
        { RecordGetters<TRecord>::channel(rec) } -> std::convertible_to<RecordChannel_t<TRecord>>;
        { RecordGetters<TRecord>::timePoint(rec) } -> std::convertible_to<RecordTimePoint_t<TRecord>>;
    };
 
    template <class TRecord>
    struct RecordSetters
    {
        using Record_t = std::remove_cvref_t<TRecord>;
 
        constexpr static auto setMessage
        {
            []<class TMessage>(Record_t& record, TMessage&& msg)
            {
                return record.setMessage(std::forward<TMessage>(msg));
            }
        };
 
        constexpr static auto setSeverity
        {
            []<class TSeverity>(Record_t& record, TSeverity&& sev)
            {
                return record.setSeverity(std::forward<TSeverity>(sev));
            }
        };
 
        constexpr static auto setChannel
        {
            []<class TChannel>(Record_t& record, TChannel&& chan)
            {
                return record.setChannel(std::forward<TChannel>(chan));
            }
        };
 
        constexpr static auto setTimePoint
        {
            []<class TTimePoint>(Record_t& record, TTimePoint&& timePoint)
            {
                return record.setTimePoint(std::forward<TTimePoint>(timePoint));
            }
        };
    };
 
    template <class TRecord>
    concept RecordMemberSetters =
    RecordMemberTypedefs<TRecord> &&
    requires(TRecord& rec)
    {
        { RecordSetters<TRecord>::setMessage(rec, std::declval<RecordMessage_t<TRecord>>()) };
        { RecordSetters<TRecord>::setTimePoint(rec, std::declval<RecordTimePoint_t<TRecord>>()) };
        { RecordSetters<TRecord>::setSeverity(rec, std::declval<RecordSeverity_t<TRecord>>()) };
        { RecordSetters<TRecord>::setChannel(rec, std::declval<RecordChannel_t<TRecord>>()) };
    };
 
    template <class TRecord>
    concept Record =
    std::movable<TRecord> &&
    RecordMemberTypedefs<TRecord> &&
    RecordMemberGetters<TRecord> &&
    RecordMemberSetters<TRecord>;
 
    template <std::semiregular TSeverityLevel,
        std::semiregular TChannel,
        std::semiregular TMessage = std::string,
        std::semiregular TTimePoint = std::chrono::system_clock::time_point>
    class BaseRecord
    {
    public:
        using Message_t = std::remove_cvref_t<TMessage>;
        using SeverityLevel_t = std::remove_cvref_t<TSeverityLevel>;
        using Channel_t = std::remove_cvref_t<TChannel>;
        using TimePoint_t = std::remove_cvref_t<TTimePoint>;
#ifdef __cpp_lib_source_location
        using SourceLocation_t = std::remove_cvref_t<std::source_location>;
#endif
 
        [[nodiscard]]
        const Message_t& message() const noexcept
        {
            return m_Message;
        }
 
        template <std::convertible_to<Message_t> UMessage>
        void setMessage(UMessage&& msg)
        {
            m_Message = std::forward<UMessage>(msg);
        }
 
        [[nodiscard]]
        const TimePoint_t& timePoint() const noexcept
        {
            return m_TimePoint;
        }
 
        template <std::convertible_to<TimePoint_t> UTimePoint>
        void setTimePoint(UTimePoint&& timePoint)
        {
            m_TimePoint = std::forward<UTimePoint>(timePoint);
        }
 
        [[nodiscard]]
        const SeverityLevel_t& severity() const noexcept
        {
            return m_Severity;
        }
 
        template <std::convertible_to<SeverityLevel_t> USeverityLevel>
        void setSeverity(USeverityLevel&& severity)
        {
            m_Severity = std::forward<USeverityLevel>(severity);
        }
 
        [[nodiscard]]
        const Channel_t& channel() const noexcept
        {
            return m_Channel;
        }
 
        template <std::convertible_to<Channel_t> UChannel>
        void setChannel(UChannel&& channel)
        {
            m_Channel = std::forward<UChannel>(channel);
        }
 
#ifdef __cpp_lib_source_location
        [[nodiscard]]
        const SourceLocation_t& sourceLocation() const noexcept
        {
            return m_SourceLocation;
        }
 
        
        template <std::convertible_to<SourceLocation_t> USourceLocation>
        void setChannel(USourceLocation&& sourceLocation)
        {
            m_SourceLocation = std::forward<USourceLocation>(sourceLocation);
        }
#endif
 
    private:
        Message_t m_Message{};
        TimePoint_t m_TimePoint{};
        SeverityLevel_t m_Severity{};
        Channel_t m_Channel{};
#ifdef __cpp_lib_source_location
        SourceLocation_t m_SourceLocation{};
#endif
    };
 
}
 
#endif