Logger.h

Go to the documentation of this file.

 
#pragma once
#include "enrollment/Exception/EnrollmentException.h"
#include "enrollment/Export.h"
#include <memory>
#include <mutex>
 
namespace inno
{
     */
    class LogMessage
    {
    public:
        virtual const char* Compose() = 0;
 
        LogMessage() = default;
        LogMessage(LogMessage&&) = delete;
        LogMessage(const LogMessage&) = delete;
        LogMessage& operator=(LogMessage&&) = delete;
        LogMessage& operator=(const LogMessage&) = delete;
        virtual ~LogMessage() = default;
    };
     */
    class Logger
    {
    public:
        virtual void LogInfo(LogMessage& composer) = 0;
        virtual void LogError(LogMessage& composer) = 0;
        virtual void LogDebug(LogMessage& composer) = 0;
 
        Logger(const Logger&) = delete;
        Logger(Logger&&) = delete;
        Logger& operator=(const Logger&) = delete;
        Logger& operator=(Logger&&) = delete;
        Logger() = default;
        virtual ~Logger() = default;
    };

     */
    class NullLogger : public Logger
    {
    public:
         */
        void LogInfo(LogMessage& /* composer */) final
        {
        }
         */
        void LogError(LogMessage& /* composer */) final
        {
        }
         */
        void LogDebug(LogMessage& /* composer */) final
        {
        }
 
        NullLogger(const NullLogger&) = delete;
        NullLogger(NullLogger&&) = delete;
        NullLogger& operator=(const NullLogger&) = delete;
        NullLogger& operator=(NullLogger&&) = delete;
        NullLogger() = default;
        virtual ~NullLogger() = default;
    };

    using LogMessageCallback = const char* (*)(void* composerData);

    using LoggerCallback = void (*)(void* logger, LogMessageCallback composer, void* composerData);
 
    // See doc/Main.markdown "Header and Binary parts" for reason why we use pragma pack 1
#pragma pack(push, 1)
     */
    extern "C" struct LoggerCallBacks
    {
        void* log;
        LoggerCallback logInfo;
        LoggerCallback logError;
        LoggerCallback logDebug;
    };
#pragma pack(pop)

     */
    class CallbackLogger
    {
    public:
        // The clang-tidy generates false positive. The function uses member variable log
        // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
        [[nodiscard]] LoggerCallBacks GetCallbacks() const
        {
            LoggerCallBacks cb = {};
            cb.log = log.get();
            cb.logInfo = &CallbackLogger::LogInfo;
            cb.logDebug = &CallbackLogger::LogDebug;
            cb.logError = &CallbackLogger::LogError;
            return cb;
        }

         */
        static void LogInfo(void* log, LogMessageCallback composer, void* composerData)
        {
            if (log != nullptr)
            {
                ForwardingComposer msg(composer, composerData);
                static_cast<Logger*>(log)->LogInfo(msg);
            }
        }
         */
        static void LogError(void* log, LogMessageCallback composer, void* composerData)
        {
            if (log != nullptr)
            {
                ForwardingComposer msg(composer, composerData);
                static_cast<Logger*>(log)->LogError(msg);
            }
        }
         */
        static void LogDebug(void* log, LogMessageCallback composer, void* composerData)
        {
            if (log != nullptr)
            {
                ForwardingComposer msg(composer, composerData);
                static_cast<Logger*>(log)->LogDebug(msg);
            }
        }
         */
        explicit CallbackLogger(std::shared_ptr<Logger> logger)
          : log(std::move(logger))
        {
        }
        CallbackLogger() = delete;
        CallbackLogger(const CallbackLogger&) = delete;
        CallbackLogger(CallbackLogger&&) = delete;
        CallbackLogger& operator=(const CallbackLogger&) = delete;
        CallbackLogger& operator=(CallbackLogger&&) = delete;
        ~CallbackLogger() = default;
 
    private:
        std::shared_ptr<Logger> log;
 
        class ForwardingComposer : public LogMessage
        {
        public:
            const char* Compose() final
            {
                return msg(data);
            }
 
            ForwardingComposer(LogMessageCallback composer, void* composerData)
              : msg(composer)
              , data(composerData)
            {
            }
            ForwardingComposer() = delete;
            ForwardingComposer(ForwardingComposer&&) = delete;
            ForwardingComposer(const ForwardingComposer&) = delete;
            ForwardingComposer& operator=(ForwardingComposer&&) = delete;
            ForwardingComposer& operator=(const ForwardingComposer&) = delete;
            ~ForwardingComposer() = default;
 
        private:
            LogMessageCallback msg;
            void* data;
        };
    };
 
    extern "C" INNO_ENROLLMENT_API void inno_local_image_redirect_error(LoggerCallBacks lcb);

     */
    class GlobalLogger
    {
    public:
         */
        static std::shared_ptr<Logger> Get()
        {
            return GlobalLogger::Instance().GetInternal();
        }

         */
        static void Set(std::shared_ptr<Logger> logger)
        {
            if (logger == nullptr)
            {
                throw NullArgumentException("logger can not be null");
            }
 
            GlobalLogger::Instance().SetInternal(std::move(logger));
        }
 
        GlobalLogger() = delete;
        virtual ~GlobalLogger() = default;
        GlobalLogger(const GlobalLogger&) = delete;
        GlobalLogger(GlobalLogger&&) = delete;
        GlobalLogger& operator=(const GlobalLogger&) = delete;
        GlobalLogger& operator=(GlobalLogger&&) = delete;
 
    private:
        std::shared_ptr<Logger> pe;
        std::unique_ptr<CallbackLogger> cbLogger;
        std::mutex peMux;
 
        // The clang-tidy generates false positive. The function uses member variable peMux and pe
        // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
        std::shared_ptr<Logger> GetInternal()
        {
            const std::scoped_lock lock(peMux);
            return pe;
        }
 
        static GlobalLogger& Instance()
        {
            static GlobalLogger e(std::make_shared<NullLogger>());
            return e;
        }
 
        void SetInternal(std::shared_ptr<Logger> logger)
        {
            if (logger != nullptr)
            {
                UpdateLogger(std::move(logger));
            }
            else
            {
                UpdateLogger(std::make_shared<NullLogger>());
            }
        }
 
        // The clang-tidy generates false positive for cbLogger
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
        explicit GlobalLogger(std::shared_ptr<Logger> e)
          : pe(std::move(e))
          , cbLogger(std::make_unique<CallbackLogger>(pe))
        {
            inno_local_image_redirect_error(cbLogger->GetCallbacks());
        }
 
        // The clang-tidy generates false positive. The function uses member variable peMux and cbLogger
        // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
        void UpdateLogger(std::shared_ptr<Logger> logger)
        {
            const std::scoped_lock lock(peMux);
            pe = std::move(logger);
            auto replacingCallbackLogger = std::make_unique<CallbackLogger>(pe);
            inno_local_image_redirect_error(replacingCallbackLogger->GetCallbacks());
            cbLogger = std::move(replacingCallbackLogger);
        }
    };
} // namespace inno