ISink.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_ISINK_HPP
#define SL_LOG_ISINK_HPP
 
#pragma once
 
#include "Record.hpp"
 
#include <stdexcept>
#include <type_traits>
 
namespace sl::log
{
    template <Record TRecord>
    class ISink
    {
    public:
        using Record_t = std::remove_cvref_t<TRecord>;
 
        ISink(const ISink&) = delete;
        ISink& operator =(const ISink&) = delete;
 
        virtual ~ISink() noexcept = default;
 
        virtual void log(const Record_t& record) = 0;
 
        virtual void setEnabled(bool enable = true) noexcept = 0;
 
        [[nodiscard]]
        virtual bool isEnabled() const noexcept = 0;
 
    protected:
        ISink() = default;
        ISink(ISink&&) = default;
        ISink& operator =(ISink&&) = default;
    };
 
    template <Record TRecord, std::derived_from<ISink<TRecord>> TSink>
    class ScopedSinkDisabling
    {
    public:
        explicit ScopedSinkDisabling(TSink& sink) noexcept :
            m_Sink{ &sink }
        {
            m_Sink->setEnabled(false);
        }
 
        ~ScopedSinkDisabling() noexcept
        {
            if (m_Sink)
            {
                m_Sink->setEnabled();
                m_Sink = nullptr;
            }
        }
 
        ScopedSinkDisabling(const ScopedSinkDisabling&) = delete;
 
        ScopedSinkDisabling& operator =(const ScopedSinkDisabling&) = delete;
 
        ScopedSinkDisabling(ScopedSinkDisabling&& other) noexcept
        {
            *this = std::move(other);
        }
 
        ScopedSinkDisabling& operator =(ScopedSinkDisabling&& other) noexcept
        {
            using std::swap;
            swap(m_Sink, other.m_Sink);
            return *this;
        }
 
        [[nodiscard]]
        TSink& operator *() const noexcept
        {
            return *m_Sink;
        }
 
        [[nodiscard]]
        TSink* operator ->() const noexcept
        {
            return m_Sink;
        }
 
        [[nodiscard]]
        TSink* get() const noexcept
        {
            return m_Sink;
        }
 
    private:
        TSink* m_Sink = nullptr;
    };
 
    class SinkException final :
        public std::runtime_error
    {
    public:
        explicit SinkException(const std::string& message) :
            runtime_error{ message }
        {
        }
 
        explicit SinkException(const char* message) :
            runtime_error{ message }
        {
        }
    };
 
}
 
#endif