ostream_logger.h

Go to the documentation of this file.

 
#ifndef CPPTRAIL_OSTREAM_LOGGER_H
#define CPPTRAIL_OSTREAM_LOGGER_H
 
#if __cplusplus >= 202002L
#include "rfc3339.h"
#endif
 
#include <iostream>
 
#include "cpptrail/logger.h"
 
namespace CppTrail {
    template<typename char_t>
    class BasicSyncOstreamLogger : public BasicLogger<char_t> {
    public:
        BasicSyncOstreamLogger(
            std::basic_ostream<char_t> &oOstream,
            const bool bUseLocalTime = true
        ) : BasicSyncOstreamLogger(
            std::reference_wrapper<std::basic_ostream<char_t> >(oOstream),
            bUseLocalTime
        ) {
        }
 
        BasicSyncOstreamLogger(
            std::reference_wrapper<std::basic_ostream<char_t> > oOstream,
            const bool bUseLocalTime = true
        ) : BasicLogger<char_t>(
            std::make_shared<Impl>(oOstream, bUseLocalTime)
        ) {
        }
 
    private:
        class Impl : public BasicSyncLoggerImpl<char_t> {
        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;
 
        public:
            Impl(
                std::reference_wrapper<std::basic_ostream<char_t> > oOstream,
                const bool bUseLocalTime
            ) : m_oOstream(oOstream),
                m_bUseLocalTime(bUseLocalTime) {
            }
 
            ~Impl() override {
                this->stop();
                this->join();
            }
 
        protected:
            void work(message_type oMessage) override;
 
            Status serviceStatus() override {
                return Status::TRASCENDENT;
            }
 
            void serviceStart() override {
            }
 
            void serviceStop() override {
            }
 
        private:
            std::reference_wrapper<std::basic_ostream<char_t> > m_oOstream;
 
            bool m_bUseLocalTime;
        };
    };
 
    using SyncOstreamLogger = BasicSyncOstreamLogger<char>;
 
    using wSyncOstreamLogger = BasicSyncOstreamLogger<wchar_t>;
 
#if __cplusplus >= 202002L
    using u8SyncOstreamLogger = BasicSyncOstreamLogger<char8_t>;
#endif
 
    using u16SyncOstreamLogger = BasicSyncOstreamLogger<char16_t>;
 
    using u32SyncOstreamLogger = BasicSyncOstreamLogger<char32_t>;
 
    class SyncCoutLogger : public SyncOstreamLogger {
    public:
        SyncCoutLogger() : SyncOstreamLogger(std::cout) {
        }
    };
 
    class SyncCerrLogger : public SyncOstreamLogger {
    public:
        SyncCerrLogger() : SyncOstreamLogger(std::cerr) {
        }
    };
 
    template<typename char_t>
    class BasicAsyncOstreamLogger : public BasicLogger<char_t> {
    public:
        BasicAsyncOstreamLogger(
            std::basic_ostream<char_t> &oOstream,
            const bool bUseLocalTime = true
        ) : BasicAsyncOstreamLogger(
            std::reference_wrapper<std::basic_ostream<char_t> >(oOstream),
            bUseLocalTime
        ) {
        }
 
        BasicAsyncOstreamLogger(
            std::reference_wrapper<std::basic_ostream<char_t> > oOstream,
            const bool bUseLocalTime = true
        ) : BasicLogger<char_t>(
            std::make_shared<Impl>(oOstream, bUseLocalTime)
        ) {
        }
 
        BasicAsyncOstreamLogger(
            std::reference_wrapper<std::basic_ostream<char_t> > oOstream,
            const bool bUseLocalTime,
            std::size_t nMaxEntryCount,
            bool bThrowOnOverflow
        ) : BasicLogger<char_t>(
            std::make_shared<Impl>(
                oOstream,
                bUseLocalTime,
                nMaxEntryCount,
                bThrowOnOverflow
            )
        ) {
        }
 
    private:
        class Impl : public BasicAsyncLoggerImpl<char_t> {
        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;
 
        public:
            Impl(
                std::reference_wrapper<std::basic_ostream<char_t> > oOstream,
                const bool bUseLocalTime
            ) : m_oOstream(oOstream),
                m_bUseLocalTime(bUseLocalTime) {
            }
 
            Impl(
                std::reference_wrapper<std::basic_ostream<char_t> > oOstream,
                const bool bUseLocalTime,
                std::size_t nMaxEntryCount,
                bool bThrowOnOverflow
            ) : BasicAsyncLoggerImpl<char_t>(
                    nMaxEntryCount,
                    bThrowOnOverflow,
                    1
                ), m_oOstream(oOstream),
                m_bUseLocalTime(bUseLocalTime) {
            }
 
            ~Impl() override {
                this->stop();
                this->join();
            }
 
        protected:
            void work(message_type oMessage) override;
 
            Status serviceStatus() override {
                return Status::TRASCENDENT;
            }
 
            void serviceStart() override {
            }
 
            void serviceStop() override {
            }
 
        private:
            std::reference_wrapper<std::basic_ostream<char_t> > m_oOstream;
            bool m_bUseLocalTime;
        };
    };
 
    using AsyncOstreamLogger = BasicAsyncOstreamLogger<char>;
 
    using wAsyncOstreamLogger = BasicAsyncOstreamLogger<wchar_t>;
 
#if __cplusplus >= 202002L
    using u8AsyncOstreamLogger = BasicAsyncOstreamLogger<char8_t>;
#endif
 
    using u16AsyncOstreamLogger = BasicAsyncOstreamLogger<char16_t>;
 
    using u32AsyncOstreamLogger = BasicAsyncOstreamLogger<char32_t>;
 
    class AsyncCoutLogger : public AsyncOstreamLogger {
    public:
        AsyncCoutLogger() : AsyncOstreamLogger(std::cout) {
        }
    };
 
    class AsyncCerrLogger : public AsyncOstreamLogger {
    public:
        AsyncCerrLogger() : AsyncOstreamLogger(std::cerr) {
        }
    };
 
    template<typename char_t>
    void BasicSyncOstreamLogger<char_t>::Impl::work(
        message_type oMessage
    ) {
        // Get ostream
        std::basic_ostream<char_t> &oOstream = m_oOstream.get();
 
#if __cplusplus >= 202002L
        // Write time
        Detail::toRfc3339<char_t>(oOstream, this->m_bUseLocalTime);
#endif
 
        // Write level + message
        oOstream << oMessage.stealLevel();
        oOstream.put(static_cast<char_t>(' '));
        oOstream << oMessage.stealString();
        oOstream.put(static_cast<char_t>('\n'));
 
        // Flush
        oOstream.flush();
    }
 
    template<typename char_t>
    void BasicAsyncOstreamLogger<char_t>::Impl::work(
        message_type oMessage
    ) {
        // Get ostream
        std::basic_ostream<char_t> &oOstream = m_oOstream.get();
 
#if __cplusplus >= 202002L
        // Write time
        Detail::toRfc3339<char_t>(oOstream, this->m_bUseLocalTime);
#endif
 
        // Write level
        oOstream << oMessage.stealLevel();
 
        // Write message
        oOstream.put(static_cast<char_t>(' '));
        oOstream << oMessage.stealString();
        oOstream.put(static_cast<char_t>('\n'));
 
        // Flush
        oOstream.flush();
    }
}
 
#endif