base_logger.h

Go to the documentation of this file.

 
#ifndef CPPTRAIL_BASE_LOGGER_H
#define CPPTRAIL_BASE_LOGGER_H
 
#include "cpptrail/message.h"
 
namespace CppTrail {
    template<typename char_t>
    class BasicLoggerImpl {
    public:
        using char_type = char_t;
 
        using string_type = std::basic_string<char_type>;
 
        using message_type = BasicMessage<char_type>;
 
#if __cplusplus >= 201703L
        using string_view_type = std::basic_string_view<char_type>;
#endif
 
    public:
        virtual ~BasicLoggerImpl() = default;
 
        virtual void log(message_type oMessage) = 0;
 
        virtual void start() = 0;
 
        virtual void stop() = 0;
 
        virtual void signalStop() = 0;
 
        virtual void join() = 0;
 
        virtual Status status() = 0;
    };
 
    using LoggerImpl = BasicLoggerImpl<char>;
 
    using wLoggerImpl = BasicLoggerImpl<wchar_t>;
 
#if __cplusplus >= 202002L
    using u8LoggerImpl = BasicLoggerImpl<char8_t>;
#endif
 
    using u16LoggerImpl = BasicLoggerImpl<char16_t>;
 
    using u32LoggerImpl = BasicLoggerImpl<char32_t>;
 
    template<typename char_t>
    class BasicLogger {
    public:
        BasicLogger(nullptr_t) = delete;
 
    protected:
        BasicLogger(std::shared_ptr<BasicLoggerImpl<char_t> > pLogger)
            : m_pLogger(std::move(pLogger)) {
        }
 
        ~BasicLogger() {
            if (this->m_pLogger && this->m_pLogger.use_count() == 1) {
                this->m_pLogger->stop();
                this->m_pLogger->join();
            }
        }
 
    public:
        BasicLogger(const BasicLogger &pLogger) = default;
 
        BasicLogger(BasicLogger &&pLogger) = default;
 
        BasicLogger &operator=(const BasicLogger &pLogger) = default;
 
        BasicLogger &operator=(BasicLogger &&pLogger) = default;
 
    public:
        using char_type = typename BasicLoggerImpl<char_t>::char_type;
 
        using string_type = typename BasicLoggerImpl<char_t>::string_type;
 
        using message_type = typename BasicLoggerImpl<char_t>::message_type;
 
#if __cplusplus >= 201703L
        using string_view_type = typename BasicLoggerImpl<char_t>::string_view_type;
#endif
 
    public:
        void start() {
            if (this->m_pLogger) this->m_pLogger->start();
        }
 
        void stop() {
            if (this->m_pLogger) this->m_pLogger->stop();
        }
 
        void signalStop() {
            if (this->m_pLogger) this->m_pLogger->signalStop();
        }
 
        void join() {
            if (this->m_pLogger) this->m_pLogger->join();
        }
 
        [[nodiscard]] Status status() {
            if (this->m_pLogger) return this->m_pLogger->status();
        }
 
    public:
        BasicLogger &log(message_type oMessage) {
            if (this->m_pLogger) this->m_pLogger->log(std::move(oMessage));
            return *this;
        }
 
        BasicLogger &log(const Level nLevel, string_type sMessage) {
            return this->log(BasicStringMessage<char_t>(
                tgetName<char_t>(nLevel), std::move(sMessage)
            ));
        }
 
        BasicLogger &log(string_type sLevel, string_type sMessage) {
            return this->log(BasicStringMessage<char_t>(
                std::move(sLevel), std::move(sMessage)
            ));
        }
 
    public:
        BasicLogger &success(string_type sMessage) { return this->log(Level::SUCCESS, std::move(sMessage)); }
 
        BasicLogger &trace(string_type sMessage) { return this->log(Level::TRACE, std::move(sMessage)); }
 
        BasicLogger &debug(string_type sMessage) { return this->log(Level::DEBUG, std::move(sMessage)); }
 
        BasicLogger &info(string_type sMessage) { return this->log(Level::INFO, std::move(sMessage)); }
 
        BasicLogger &message(string_type sMessage) { return this->log(Level::MESSAGE, std::move(sMessage)); }
 
        BasicLogger &warning(string_type sMessage) { return this->log(Level::WARNING, std::move(sMessage)); }
 
        BasicLogger &error(string_type sMessage) { return this->log(Level::ERROR, std::move(sMessage)); }
 
        BasicLogger &critical(string_type sMessage) { return this->log(Level::CRITICAL, std::move(sMessage)); }
 
        BasicLogger &fatal(string_type sMessage) { return this->log(Level::FATAL, std::move(sMessage)); }
#if __cplusplus >= 201703L
    public:
        BasicLogger &log(const Level nLevel, string_view_type sMessage) {
            return this->log(BasicStringMessage<char_t>(tgetName<char_t>(nLevel), sMessage));
        }
 
        BasicLogger &log(string_type sLevel, string_view_type sMessage) {
            return this->log(BasicStringMessage<char_t>(std::move(sLevel), sMessage));
        }
 
    public:
        BasicLogger &success(string_view_type sMsg) { return this->log(Level::SUCCESS, sMsg); }
        BasicLogger &trace(string_view_type sMsg) { return this->log(Level::TRACE, sMsg); }
        BasicLogger &debug(string_view_type sMsg) { return this->log(Level::DEBUG, sMsg); }
        BasicLogger &info(string_view_type sMsg) { return this->log(Level::INFO, sMsg); }
        BasicLogger &message(string_view_type sMsg) { return this->log(Level::MESSAGE, sMsg); }
        BasicLogger &warning(string_view_type sMsg) { return this->log(Level::WARNING, sMsg); }
        BasicLogger &error(string_view_type sMsg) { return this->log(Level::ERROR, sMsg); }
        BasicLogger &critical(string_view_type sMsg) { return this->log(Level::CRITICAL, sMsg); }
        BasicLogger &fatal(string_view_type sMsg) { return this->log(Level::FATAL, sMsg); }
    public:
        BasicLogger &log(const Level nLevel, const char_t *sMessage) {
            return this->log(BasicStringMessage<char_t>(tgetName<char_t>(nLevel), string_type{sMessage}));
        }
 
        BasicLogger &log(string_type sLevel, const char_t *sMessage) {
            return this->log(BasicStringMessage<char_t>(std::move(sLevel), string_type{sMessage}));
        }
 
    public:
        BasicLogger &success(const char_t *sMsg) { return this->log(Level::SUCCESS, sMsg); }
        BasicLogger &trace(const char_t *sMsg) { return this->log(Level::TRACE, sMsg); }
        BasicLogger &debug(const char_t *sMsg) { return this->log(Level::DEBUG, sMsg); }
        BasicLogger &info(const char_t *sMsg) { return this->log(Level::INFO, sMsg); }
        BasicLogger &message(const char_t *sMsg) { return this->log(Level::MESSAGE, sMsg); }
        BasicLogger &warning(const char_t *sMsg) { return this->log(Level::WARNING, sMsg); }
        BasicLogger &error(const char_t *sMsg) { return this->log(Level::ERROR, sMsg); }
        BasicLogger &critical(const char_t *sMsg) { return this->log(Level::CRITICAL, sMsg); }
        BasicLogger &fatal(const char_t *sMsg) { return this->log(Level::FATAL, sMsg); }
#endif
 
    public:
        template<typename T = char_t, typename std::enable_if<std::is_same<T, char>::value, int>::type = 0>
        BasicLogger &log(const std::exception &oException) {
            return this->log(BasicStringMessage<char_t>(tgetName<char_t>(Level::ERROR), oException));
        }
 
        template<typename T = char_t, typename std::enable_if<std::is_same<T, char>::value, int>::type = 0>
        BasicLogger &log(const Level nLevel, const std::exception &oException) {
            return this->log(BasicStringMessage<char_t>(tgetName<char_t>(nLevel), oException));
        }
 
        template<typename T = char_t, typename std::enable_if<std::is_same<T, char>::value, int>::type = 0>
        BasicLogger &log(string_type sLevel, const std::exception &oException) {
            return this->log(BasicStringMessage<char_t>(std::move(sLevel), oException));
        }
 
    private:
        std::shared_ptr<BasicLoggerImpl<char_t> > m_pLogger;
    };
 
    using Logger = BasicLogger<char>;
 
    using wLogger = BasicLogger<wchar_t>;
 
#if __cplusplus >= 202002L
    using u8Logger = BasicLogger<char8_t>;
#endif
 
    using u16Logger = BasicLogger<char16_t>;
 
    using u32Logger = BasicLogger<char32_t>;
 
}
 
#endif