message.h

Go to the documentation of this file.

 
#ifndef CPPTRAIL_MESSAGE_H
#define CPPTRAIL_MESSAGE_H
 
#include <memory>
#include <string>
#include <exception>
 
#if __cplusplus >= 201703L
#include <string_view>
#endif
 
#include "cpptrail/def.h"
 
namespace CppTrail {
    template<typename char_t>
    class BasicMessageImpl {
    public:
        using char_type = char_t;
 
        using string_type = std::basic_string<char_type>;
 
    public:
        virtual ~BasicMessageImpl() = default;
 
    public:
        virtual string_type stealString() = 0;
    };
 
    using MessageImpl = BasicMessageImpl<char>;
 
    using wMessageImpl = BasicMessageImpl<wchar_t>;
 
#if __cplusplus >= 202002L
    using u8MessageImpl = BasicMessageImpl<char8_t>;
#endif
 
    using u16MessageImpl = BasicMessageImpl<char16_t>;
 
    using u32MessageImpl = BasicMessageImpl<char32_t>;
 
    template<typename char_t>
    class BasicMessage {
    public:
        using impl_type = BasicMessageImpl<char_t>;
 
        using char_type = char_t;
 
        using string_type = std::basic_string<char_type>;
 
    protected:
        explicit BasicMessage(
            string_type sLevel,
            std::shared_ptr<impl_type> pImpl
        ) : m_sLevel(std::move(sLevel)),
            m_pImpl(std::move(pImpl)) {
        }
 
    public:
        BasicMessage() = default;
 
        string_type stealString() {
            if (!this->m_pImpl) return string_type{};
            return this->m_pImpl->stealString();
        }
 
        string_type stealLevel() noexcept {
            return std::move(this->m_sLevel);
        }
 
        std::weak_ptr<impl_type> getImplementation() noexcept {
            return this->m_pImpl;
        }
 
    private:
        string_type m_sLevel;
        std::shared_ptr<impl_type> m_pImpl;
    };
 
    using Message = BasicMessage<char>;
 
    using wMessage = BasicMessage<wchar_t>;
 
#if __cplusplus >= 202002L
    using u8Message = BasicMessage<char8_t>;
#endif
 
    using u16Message = BasicMessage<char16_t>;
 
    using u32Message = BasicMessage<char32_t>;
 
    template<typename char_t>
    class BasicStringMessage : public BasicMessage<char_t> {
    public:
        using impl_type = BasicMessageImpl<char_t>;
 
        using char_type = char_t;
 
        using string_type = std::basic_string<char_type>;
 
#if __cplusplus >= 201703L
        using string_view_type = std::basic_string_view<char_type>;
#endif
 
    public:
        BasicStringMessage(
            string_type sLevel,
            string_type sMessage
        ) : BasicMessage<char_t>(
            std::move(sLevel),
            std::make_shared<Impl>(std::move(sMessage))
        ) {
        }
 
#if __cplusplus >= 201703L
        BasicStringMessage(
            string_type sLevel,
            string_view_type sMessage
        ) : BasicMessage<char_t>(
            std::move(sLevel),
            std::make_shared<Impl>(string_type{sMessage})
        ) {
        }
#endif
 
        template<typename T = char_t,
            typename std::enable_if<std::is_same<T, char>::value, int>::type = 0>
        BasicStringMessage(
            string_type sLevel,
            const std::exception &oMessage
        ) : BasicMessage<char_t>(
            std::move(sLevel),
            std::make_shared<Impl>(oMessage.what())
        ) {
        }
 
    private:
        class Impl : public BasicMessageImpl<char_t> {
        public:
            explicit Impl(string_type sString)
                : m_sString(std::move(sString)) {
            }
 
        public:
            string_type stealString() override {
                return std::move(this->m_sString);
            }
 
        private:
            string_type m_sString;
        };
    };
 
    using StringMessage = BasicStringMessage<char>;
 
    using wStringMessage = BasicStringMessage<wchar_t>;
 
#if __cplusplus >= 202002L
    using u8StringMessage = BasicStringMessage<char8_t>;
#endif
 
    using u16StringMessage = BasicStringMessage<char16_t>;
 
    using u32StringMessage = BasicStringMessage<char32_t>;
 
}
 
#endif