Core.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_CORE_HPP
#define SL_LOG_CORE_HPP
 
#pragma once
 
#include "ISink.hpp"
#include "Record.hpp"
#include "RecordQueue.hpp"
 
#include <algorithm>
#include <execution>
#include <future>
#include <memory>
#include <mutex>
#include <vector>
 
namespace sl::log
{
    template <Record TRecord>
    class Core
    {
    public:
        using Record_t = std::remove_cvref_t<TRecord>;
 
    private:
        using ISink_t = ISink<Record_t>;
        using RecordQueue_t = RecordQueue<Record_t>;
        using SinkContainer_t = std::vector<std::unique_ptr<ISink_t>>;
 
    public:
        Core() noexcept :
            m_Worker{ m_WorkerInstruction, m_Records, m_SinkMx, m_Sinks }
        {
            m_WorkerFuture = std::async(std::launch::async, m_Worker);
        }
 
        ~Core() noexcept
        {
            try
            {
                m_WorkerInstruction = Worker::Instruction::quit;
                m_WorkerFuture.wait();
            }
            catch (...)
            {
                m_WorkerInstruction = Worker::Instruction::forceQuit;
            }
        }
 
        Core(const Core&) = delete;
        Core& operator =(const Core&) = delete;
 
        Core(Core&&) = delete;
        Core& operator =(Core&&) = delete;
 
        void log(Record_t&& record)
        {
            // will reject newly generated records, after run has become false
            if (m_WorkerInstruction == Worker::Instruction::run)
            {
                m_Records.push(std::move(record));
            }
        }
 
        template <std::derived_from<ISink_t> TSink, class... TArgs>
        requires std::constructible_from<TSink, TArgs...>
        TSink& makeSink(TArgs&&... args)
        {
            auto& ref = makeSinkImpl<TSink>(std::forward<TArgs>(args)...);
            ref.setEnabled();
            return ref;
        }
 
        template <std::derived_from<ISink_t> TSink, class... TArgs>
        requires std::constructible_from<TSink, TArgs...>
        ScopedSinkDisabling<Record_t, TSink> makeDisabledSink(TArgs&&... args)
        {
            auto& ref = makeSinkImpl<TSink>(std::forward<TArgs>(args)...);
            return ScopedSinkDisabling<Record_t, TSink>{ ref };
        }
 
        bool removeSink(const ISink_t& sink)
        {
            std::scoped_lock lock{ m_SinkMx };
 
            if (auto itr = std::ranges::find(m_Sinks, &sink, &std::unique_ptr<ISink_t>::get); itr != std::end(m_Sinks))
            {
                using std::swap;
                swap(*itr, m_Sinks.back());
                m_Sinks.resize(std::size(m_Sinks) - 1);
                return true;
            }
            return false;
        }
 
    private:
        class Worker
        {
        public:
            enum class Instruction
            {
                run,
                quit,
                forceQuit
            };
 
            Worker(
                const std::atomic<Instruction>& instruction,
                RecordQueue_t& records,
                std::mutex& sinkMx,
                const SinkContainer_t& sinks
            ) :
                m_Instruction{ instruction },
                m_Records{ records },
                m_SinkMx{ sinkMx },
                m_Sinks{ sinks }
            {
            }
 
            void operator ()() const
            {
                for (auto instruction = m_Instruction.load();
                    instruction != Instruction::forceQuit &&
                    (instruction != Instruction::quit || !std::empty(m_Records));
                    instruction = m_Instruction)
                {
                    if (auto optRecord = m_Records.take(std::chrono::milliseconds{ 200 }))
                    {
                        std::scoped_lock lock{ m_SinkMx };
                        std::for_each(
                                    std::execution::par,
                                    std::begin(m_Sinks),
                                    std::end(m_Sinks),
                                    [&record = *optRecord](auto& sink)
                                    {
                                        sink->log(record);
                                    }
                                    );
                    }
                }
            }
 
        private:
            const std::atomic<Instruction>& m_Instruction;
 
            RecordQueue_t& m_Records;
 
            std::mutex& m_SinkMx;
            const SinkContainer_t& m_Sinks;
        };
 
        RecordQueue_t m_Records;
 
        std::mutex m_SinkMx;
        SinkContainer_t m_Sinks;
 
        std::atomic<typename Worker::Instruction> m_WorkerInstruction{ Worker::Instruction::run };
        Worker m_Worker;
        std::future<void> m_WorkerFuture;
 
        template <std::derived_from<ISink_t> TSink, class... TArgs>
        requires std::constructible_from<TSink, TArgs...>
        TSink& makeSinkImpl(TArgs&&... args)
        {
            auto sink = std::make_unique<TSink>(std::forward<TArgs>(args)...);
            auto& ref = *sink;
            std::scoped_lock lock{ m_SinkMx };
            m_Sinks.emplace_back(std::move(sink));
            return ref;
        }
    };
 
}
 
#endif