utf42.h

Go to the documentation of this file.

 
#ifndef LIB_UTF_42
#define LIB_UTF_42
 
#include <type_traits>
#include <cstddef>
 
// Use std::basic_string_view if C++17 or custom basic_string_view otherwise
#if   __cplusplus >= 201703L
#include <string_view>
#else
#include <string>
#endif
 
// C++ version requirements
#if __cplusplus < 201103L
#pragma error "C++ minimum version required is 11"
#endif
 
#if __cplusplus >= 202002L
 
#define make_poly_enc(char_t, lit) utf42::visit_poly_enc<char_t>( \
    utf42::poly_enc{ \
        lit, \
        L##lit, \
        u8##lit, \
        u##lit, \
        U##lit, \
    } \
)
 
#else
 
#define make_poly_enc(char_t, lit) utf42::visit_poly_enc<char_t>( \
    utf42::poly_enc{ \
        lit, \
        L##lit, \
        u##lit, \
        U##lit, \
    } \
)
 
#endif
 
#if __cplusplus >= 202002L
 
#define cons_poly_enc(lit) utf42::poly_enc{ \
    lit, \
    L##lit, \
    u8##lit, \
    u##lit, \
    U##lit, \
}
 
#else
 
#define cons_poly_enc(lit) utf42::poly_enc{ \
    lit, \
    L##lit, \
    u##lit, \
    U##lit, \
}
 
#endif
 
namespace utf42 {
    template<typename T>
    struct is_character : std::integral_constant<bool,
                std::is_same<T, char>::value ||
                std::is_same<T, wchar_t>::value ||
#if __cplusplus >= 202002L
                std::is_same<T, char8_t>::value ||
#endif
                std::is_same<T, char16_t>::value ||
                std::is_same<T, char32_t>::value
            > {
    };
 
#if __cplusplus >= 201703L
    template<typename T>
    constexpr bool is_character_v = is_character<T>::value;
#endif
 
#if __cplusplus >= 201703L
 
    template<typename char_t>
    using basic_string_view = std::basic_string_view<char_t>;
 
#else
 
    template<typename char_t>
    class basic_string_view {
    public:
        using pointer = const char_t *; 
        using reference = const char_t &; 
        using char_type = char_t; 
        using size_type = std::size_t; 
 
        // Check char type
        static_assert(utf42::is_character<char_t>::value, "type_t must be a character.");
 
        constexpr basic_string_view() : m_pData(""), m_nSize(0) {
        }
 
        constexpr basic_string_view(nullptr_t) = delete;
 
        template<std::size_t N>
        constexpr basic_string_view(const char_t (&pStr)[N])
            : m_pData(pStr), m_nSize(N - 1) {
            static_assert(N > 0, "basic_string_view: invalid length");
        }
 
        constexpr size_type length() const noexcept { return m_nSize; }
 
        constexpr pointer data() const noexcept { return m_pData; }
 
        std::basic_string<char_t> str() const {
            return std::basic_string<char_t>(m_pData, m_nSize);
        }
 
    private:
        pointer m_pData; 
        size_type m_nSize; 
    };
 
#endif
 
#if __cplusplus >= 202002L
 
    template<typename T>
    concept CharacterType = is_character_v<T>;
 
    template<typename T>
    concept IntegralType = std::is_integral_v<T>;
 
    template<typename T>
    concept FloatingPointType = std::is_floating_point_v<T>;
#endif
 
    struct poly_enc {
        // String literal fields
        basic_string_view<char> TXT_CHAR; 
        basic_string_view<wchar_t> TXT_CHAR_W; 
#if __cplusplus >= 202002L
        basic_string_view<char8_t> TXT_CHAR_8; 
#endif
        basic_string_view<char16_t> TXT_CHAR_16; 
        basic_string_view<char32_t> TXT_CHAR_32; 
 
        constexpr poly_enc(
            const basic_string_view<char> txt_char,
            const basic_string_view<wchar_t> txt_char_w,
#if __cplusplus >= 202002L
            const basic_string_view<char8_t> txt_char_8,
#endif
            const basic_string_view<char16_t> txt_char_16,
            const basic_string_view<char32_t> txt_char_32
        ) noexcept
            : TXT_CHAR(txt_char),
              TXT_CHAR_W(txt_char_w),
#if __cplusplus >= 202002L
              TXT_CHAR_8(txt_char_8),
#endif
              TXT_CHAR_16(txt_char_16),
              TXT_CHAR_32(txt_char_32) {
        }
 
#if __cplusplus >= 202002L
        template<CharacterType char_t>
        constexpr basic_string_view<char_t>
        visit() const noexcept;
#else
        template<typename char_t>
        constexpr basic_string_view<char_t>
        visit() const noexcept;
#endif
    };
 
    // Primary template for unsupported types
#if __cplusplus >= 202002L
    template<CharacterType char_t>
    constexpr basic_string_view<char_t> poly_enc::visit() const noexcept {
        return {};
    }
#else
    template<typename char_t>
    constexpr basic_string_view<char_t> poly_enc::visit() const noexcept {
        static_assert(false, "Unsupported character type");
        return {};
    }
#endif
 
    template<>
    constexpr basic_string_view<char> poly_enc::visit<char>() const noexcept {
        return TXT_CHAR;
    }
 
    template<>
    constexpr basic_string_view<wchar_t> poly_enc::visit<wchar_t>() const noexcept {
        return TXT_CHAR_W;
    }
 
#if __cplusplus >= 202002L
    template<>
    constexpr basic_string_view<char8_t> poly_enc::visit<char8_t>() const noexcept {
        return TXT_CHAR_8;
    }
#endif
 
    template<>
    constexpr basic_string_view<char16_t> poly_enc::visit<char16_t>() const noexcept {
        return TXT_CHAR_16;
    }
 
    template<>
    constexpr basic_string_view<char32_t> poly_enc::visit<char32_t>() const noexcept {
        return TXT_CHAR_32;
    }
 
#if __cplusplus >= 202002L
    template<CharacterType char_t>
    consteval std::basic_string_view<char_t>
    visit_poly_enc(const poly_enc &oPolyEnv) {
        return oPolyEnv.visit<char_t>();
    }
#else
    template<typename char_t>
    constexpr basic_string_view<char_t>
    visit_poly_enc(const poly_enc &oPolyEnv) {
        return oPolyEnv.visit<char_t>();
    }
#endif
} // namespace utf42
 
// Clean up helper macro
#undef LIB_UTF_42_CHAR_TYPE
 
#endif //LIB_UTF_42