icharacter.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_INTERFACE_ICHARACTER_HPP__
#define NEFORCE_CORE_INTERFACE_ICHARACTER_HPP__

 
#include "NeForce/core/interface/ipackage.hpp"
#include "NeForce/core/string/string.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename T, typename CharT>
struct icharacter : ipackage<T, CharT> {
    static_assert(is_character_v<CharT>, "CharT must be character.");
 
    constexpr icharacter() noexcept = default;
    NEFORCE_CONSTEXPR20 ~icharacter() = default;
 
    constexpr icharacter(const icharacter&) noexcept = default;
    constexpr icharacter(icharacter&&) noexcept = default;
 
    constexpr icharacter& operator=(const icharacter&) noexcept = default;
    constexpr icharacter& operator=(icharacter&&) noexcept = default;

    constexpr icharacter(CharT value) noexcept :
    ipackage<T, CharT>(value) {}

    NEFORCE_NODISCARD constexpr explicit operator bool() const noexcept {
        return ipackage<T, CharT>::value_ != static_cast<CharT>(0);
    }

    static NEFORCE_CONSTEXPR20 string to_string(const basic_string_view<CharT>& obj) { return T::to_string(obj); }

    static NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string_view<CharT>& obj) { return T::to_wstring(obj); }
 
#ifdef NEFORCE_STANDARD_20
    static NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string_view<CharT>& obj) { return T::to_u8string(obj); }
#endif

    static NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string_view<CharT>& obj) {
        return T::to_u16string(obj);
    }

    static NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string_view<CharT>& obj) {
        return T::to_u32string(obj);
    }
};
 // CRTPInterfaces


template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 string to_string(const CharT& c) {
    return icharacter<package_t<CharT>, CharT>::to_string(basic_string<CharT>(1, c).view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 string to_string(const CharT* x) {
    return icharacter<package_t<CharT>, CharT>::to_string(basic_string_view<CharT>(x));
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 string to_string(const basic_string_view<CharT> x) {
    return icharacter<package_t<CharT>, CharT>::to_string(x);
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 string to_string(const basic_string<CharT>& x) {
    return icharacter<package_t<CharT>, CharT>::to_string(x.view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 string to_string(basic_string<CharT>&& x) {
    return icharacter<package_t<CharT>, CharT>::to_string(x.view());
}

template <>
NEFORCE_CONSTEXPR20 string to_string<char>(string&& x) {
    return _NEFORCE move(x);
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 wstring to_wstring(const CharT& x) {
    return icharacter<package_t<CharT>, CharT>::to_wstring(basic_string<CharT>(1, x).view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 wstring to_wstring(const CharT* x) {
    return icharacter<package_t<CharT>, CharT>::to_wstring(basic_string_view<CharT>(x));
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string_view<CharT> x) {
    return icharacter<package_t<CharT>, CharT>::to_wstring(x);
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 wstring to_wstring(const basic_string<CharT>& x) {
    return icharacter<package_t<CharT>, CharT>::to_wstring(x.view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 wstring to_wstring(basic_string<CharT>&& x) {
    return icharacter<package_t<CharT>, CharT>::to_wstring(x.view());
}

template <>
NEFORCE_CONSTEXPR20 wstring to_wstring<wchar_t>(wstring&& x) {
    return _NEFORCE move(x);
}
 
#ifdef NEFORCE_STANDARD_20

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u8string to_u8string(const CharT& x) {
    return icharacter<package_t<CharT>, CharT>::to_u8string(basic_string<CharT>(1, x).view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u8string to_u8string(const CharT* x) {
    return icharacter<package_t<CharT>, CharT>::to_u8string(basic_string_view<CharT>(x));
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string_view<CharT> x) {
    return icharacter<package_t<CharT>, CharT>::to_u8string(x);
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u8string to_u8string(const basic_string<CharT>& x) {
    return icharacter<package_t<CharT>, CharT>::to_u8string(x.view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u8string to_u8string(basic_string<CharT>&& x) {
    return icharacter<package_t<CharT>, CharT>::to_u8string(x.view());
}

template <>
NEFORCE_CONSTEXPR20 u8string to_u8string<char8_t>(u8string&& x) {
    return _NEFORCE move(x);
}
 
#endif

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u16string to_u16string(const CharT& x) {
    return icharacter<package_t<CharT>, CharT>::to_u16string(basic_string<CharT>(1, x).view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u16string to_u16string(const CharT* x) {
    return icharacter<package_t<CharT>, CharT>::to_u16string(basic_string_view<CharT>(x));
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string_view<CharT> x) {
    return icharacter<package_t<CharT>, CharT>::to_u16string(x);
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u16string to_u16string(const basic_string<CharT>& x) {
    return icharacter<package_t<CharT>, CharT>::to_u16string(x.view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u16string to_u16string(basic_string<CharT>&& x) {
    return icharacter<package_t<CharT>, CharT>::to_u16string(x.view());
}

template <>
NEFORCE_CONSTEXPR20 u16string to_u16string<char16_t>(u16string&& x) {
    return _NEFORCE move(x);
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u32string to_u32string(const CharT& x) {
    return icharacter<package_t<CharT>, CharT>::to_u32string(basic_string<CharT>(1, x).view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u32string to_u32string(const CharT* x) {
    return icharacter<package_t<CharT>, CharT>::to_u32string(basic_string_view<CharT>(x));
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string_view<CharT> x) {
    return icharacter<package_t<CharT>, CharT>::to_u32string(x);
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u32string to_u32string(const basic_string<CharT>& x) {
    return icharacter<package_t<CharT>, CharT>::to_u32string(x.view());
}

template <typename CharT, enable_if_t<is_character_v<CharT>, int> = 0>
NEFORCE_CONSTEXPR20 u32string to_u32string(basic_string<CharT>&& x) {
    return icharacter<package_t<CharT>, CharT>::to_u32string(x.view());
}

template <>
NEFORCE_CONSTEXPR20 u32string to_u32string<char32_t>(u32string&& x) {
    return _NEFORCE move(x);
}
 // UTFConverts
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_INTERFACE_ICHARACTER_HPP__