RecordBuilder.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_BUILDER_HPP
#define SL_LOG_RECORD_BUILDER_HPP
 
#pragma once
 
#include "Record.hpp"
 
#include <functional>
#include <sstream>
#include <type_traits>
 
namespace sl::log
{
    template <class TSeverityLevel>
    class SetSev
    {
    public:
        using Sev_t = TSeverityLevel;
 
        explicit constexpr SetSev(
            TSeverityLevel data
        )
        noexcept(std::is_nothrow_move_constructible_v<Sev_t>) :
            m_Data{ std::move(data) }
        {
        }
 
        template <Record TRecord>
        void operator ()(TRecord& rec) const
        {
            rec.setSeverity(m_Data);
        }
 
    private:
        Sev_t m_Data;
    };
 
    template <class TChannel>
    class SetChan
    {
    public:
        using Chan_t = TChannel;
 
        explicit constexpr SetChan(
            TChannel data
        ) noexcept(
            std::is_nothrow_move_constructible_v<Chan_t>) :
            m_Data{ std::move(data) }
        {
        }
 
        template <Record TRecord>
        void operator ()(TRecord& rec) const
        {
            rec.setChannel(m_Data);
        }
 
    private:
        Chan_t m_Data;
    };
 
    template <Record TRecord>
    class RecordBuilder
    {
    public:
        using Record_t = std::remove_cvref_t<TRecord>;
        using SeverityLevel_t = RecordSeverity_t<Record_t>;
        using Channel_t = RecordChannel_t<Record_t>;
 
    private:
        using LogCallback_t = std::function<void(Record_t)>;
 
    public:
        explicit RecordBuilder(Record_t prefabRec, LogCallback_t cb) noexcept :
            m_Record{ std::move(prefabRec) },
            m_LogCallback{ std::move(cb) }
        {
        }
 
        ~RecordBuilder() noexcept
        {
            if (m_LogCallback)
            {
                try
                {
                    m_Record.setMessage(std::move(m_Stream).str());
                    m_LogCallback(std::move(m_Record));
                }
                catch (...)
                {
                }
            }
        }
 
        RecordBuilder(RecordBuilder&& other) noexcept
        {
            *this = std::move(other);
        }
 
        RecordBuilder& operator =(RecordBuilder&& other) noexcept
        {
            using std::swap;
            swap(m_Record, other.m_Record);
            swap(m_Stream, other.m_Stream);
            m_LogCallback = std::exchange(other.m_LogCallback, {});
            return *this;
        }
 
        RecordBuilder(const RecordBuilder&) = delete;
        RecordBuilder& operator =(const RecordBuilder&) = delete;
 
        [[nodiscard]]
        Record_t& record() noexcept
        {
            return m_Record;
        }
 
        [[nodiscard]]
        const Record_t& record() const noexcept
        {
            return m_Record;
        }
 
        template <class T>
        requires requires(T&& data)
        {
            { std::declval<std::ostringstream>() << std::forward<T>(data) };
        }
        RecordBuilder& operator <<(T&& data)
        {
            m_Stream << std::forward<T>(data);
            return *this;
        }
 
        template <std::invocable<Record_t&> TAction>
        RecordBuilder& operator <<(TAction action)
        {
            std::invoke(action, m_Record);
            return *this;
        }
 
    private:
        Record_t m_Record;
        std::ostringstream m_Stream;
        LogCallback_t m_LogCallback;
    };
 
}
 
#endif