sol::unicode Namespace Reference

Classes
struct	decoded_result
struct	encoded_result
struct	unicode_detail

Enumerations
enum	error_code {   error_code::ok = 0, error_code::invalid_code_point, error_code::invalid_code_unit, error_code::invalid_leading_surrogate,   error_code::invalid_trailing_surrogate, error_code::sequence_too_short, error_code::overlong_sequence }

Functions
const string_view &	to_string (error_code ec)
encoded_result< char >	code_point_to_utf8 (char32_t codepoint)
encoded_result< char16_t >	code_point_to_utf16 (char32_t codepoint)
encoded_result< char32_t >	code_point_to_utf32 (char32_t codepoint)
template<typename It >
decoded_result< It >	utf8_to_code_point (It it, It last)
template<typename It >
decoded_result< It >	utf16_to_code_point (It it, It last)
template<typename It >
decoded_result< It >	utf32_to_code_point (It it, It last)

Enumeration Type Documentation

error_code

enum sol::unicode::error_code

strong

Enumerator
ok
invalid_code_point
invalid_code_unit
invalid_leading_surrogate
invalid_trailing_surrogate
sequence_too_short
overlong_sequence

                              {
            ok = 0,
            invalid_code_point,
            invalid_code_unit,
            invalid_leading_surrogate,
            invalid_trailing_surrogate,
            sequence_too_short,
            overlong_sequence,
        };

Function Documentation

code_point_to_utf16()

encoded_result<char16_t> sol::unicode::code_point_to_utf16 ( char32_t  codepoint )

inline

                                                                                {
            encoded_result<char16_t> er;

            if (codepoint <= unicode_detail::last_bmp_value) {
                er.code_units_size = 1;
                er.code_units = std::array<char16_t, 4>{ { static_cast<char16_t>(codepoint) } };
                er.error = error_code::ok;
            }
            else {
                auto normal = codepoint - unicode_detail::normalizing_value;
                auto lead = unicode_detail::first_lead_surrogate + ((normal & unicode_detail::lead_surrogate_bitmask) >> unicode_detail::lead_shifted_bits);
                auto trail = unicode_detail::first_trail_surrogate + (normal & unicode_detail::trail_surrogate_bitmask);
                er.code_units = std::array<char16_t, 4>{ {
                    static_cast<char16_t>(lead),
                    static_cast<char16_t>(trail)
                } };
                er.code_units_size = 2;
                er.error = error_code::ok;
            }
            return er;
        }

code_point_to_utf32()

encoded_result<char32_t> sol::unicode::code_point_to_utf32 ( char32_t  codepoint )

inline

                                                                                {
            encoded_result<char32_t> er;
            er.code_units_size = 1;
            er.code_units[0] = codepoint;
            er.error = error_code::ok;
            return er;
        }

code_point_to_utf8()

encoded_result<char> sol::unicode::code_point_to_utf8 ( char32_t  codepoint )

inline

                                                                           {
            encoded_result<char> er;
            er.error = error_code::ok;
            if (codepoint <= unicode_detail::last_1byte_value) {
                er.code_units_size = 1;
                er.code_units = std::array<char, 4>{ { static_cast<char>(codepoint) } };
            }
            else if (codepoint <= unicode_detail::last_2byte_value) {
                er.code_units_size = 2;
                er.code_units = std::array<char, 4>{{
                    static_cast<char>(0xC0 | ((codepoint & 0x7C0) >> 6)),
                    static_cast<char>(0x80 | (codepoint & 0x3F)),
                }};
            }
            else if (codepoint <= unicode_detail::last_3byte_value) {
                er.code_units_size = 3;
                er.code_units = std::array<char, 4>{{
                    static_cast<char>(0xE0 | ((codepoint & 0xF000) >> 12)),
                    static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
                    static_cast<char>(0x80 | (codepoint & 0x3F)),
                }};
            }
            else {
                er.code_units_size = 4;
                er.code_units = std::array<char, 4>{ {
                    static_cast<char>(0xF0 | ((codepoint & 0x1C0000) >> 18)),
                        static_cast<char>(0x80 | ((codepoint & 0x3F000) >> 12)),
                        static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
                        static_cast<char>(0x80 | (codepoint & 0x3F)),
                } };
            }
            return er;
        }

to_string()

const string_view& sol::unicode::to_string ( error_code  ec )

inline

                                                           {
            static const string_view arr[4] = {
                "ok",
                "invalid code points",
                "invalid code unit",
                "overlong sequence"
            };
            return arr[static_cast<std::size_t>(ec)];
        }

utf16_to_code_point()

template<typename It >

decoded_result<It> sol::unicode::utf16_to_code_point ( It  it, It  last  )

inline

                                                                      {
            decoded_result<It> dr;
            if (it == last) {
                dr.next = it;
                dr.error = error_code::sequence_too_short;
                return dr;
            }

            char16_t lead = static_cast<char16_t>(*it);
            
            if (!unicode_detail::is_surrogate(lead)) {
                ++it;
                dr.codepoint = static_cast<char32_t>(lead);
                dr.next = it;
                dr.error = error_code::ok;
                return dr;
            }
            if (!unicode_detail::is_lead_surrogate(lead)) {
                dr.error = error_code::invalid_leading_surrogate;
                dr.next = it;
                return dr;
            }

            ++it;
            auto trail = *it;
            if (!unicode_detail::is_trail_surrogate(trail)) {
                dr.error = error_code::invalid_trailing_surrogate;
                dr.next = it;
                return dr;
            }
            
            dr.codepoint = unicode_detail::combine_surrogates(lead, trail);
            dr.next = ++it;
            dr.error = error_code::ok;
            return dr;
        }

utf32_to_code_point()

template<typename It >

decoded_result<It> sol::unicode::utf32_to_code_point ( It  it, It  last  )

inline

                                                                      {
            decoded_result<It> dr;
            if (it == last) {
                dr.next = it;
                dr.error = error_code::sequence_too_short;
                return dr;
            }
            dr.codepoint = static_cast<char32_t>(*it);
            dr.next = ++it;
            dr.error = error_code::ok;
            return dr;
        }

utf8_to_code_point()

template<typename It >

decoded_result<It> sol::unicode::utf8_to_code_point ( It  it, It  last  )

inline

                                                                     {
            decoded_result<It> dr;
            if (it == last) {
                dr.next = it;
                dr.error = error_code::sequence_too_short;
                return dr;
            }

            unsigned char b0 = *it;
            std::size_t length = unicode_detail::sequence_length(b0);

            if (length == 1) {
                dr.codepoint = static_cast<char32_t>(b0);
                dr.error = error_code::ok;
                ++it;
                dr.next = it;
                return dr;
            }

            auto is_invalid = [](unsigned char b) { return b == 0xC0 || b == 0xC1 || b > 0xF4; };
            auto is_continuation = [](unsigned char b) {
                return (b & unicode_detail::continuation_mask) == unicode_detail::continuation_signature;
            };

            if (is_invalid(b0) || is_continuation(b0)) {
                dr.error = error_code::invalid_code_unit;
                dr.next = it;
                return dr;
            }

            ++it;
            std::array<unsigned char, 4> b;
            b[0] = b0;
            for (std::size_t i = 1; i < length; ++i) {
                b[i] = *it;
                if (!is_continuation(b[i])) {
                    dr.error = error_code::invalid_code_unit;
                    dr.next = it;
                    return dr;
                }
                ++it;
            }

            char32_t decoded;
            switch (length) {
            case 2:
                decoded = unicode_detail::decode(b[0], b[1]);
                break;
            case 3:
                decoded = unicode_detail::decode(b[0], b[1], b[2]);
                break;
            default:
                decoded = unicode_detail::decode(b[0], b[1], b[2], b[3]);
                break;
            }

            auto is_overlong = [](char32_t u, std::size_t bytes) {
                return u <= unicode_detail::last_1byte_value
                    || (u <= unicode_detail::last_2byte_value && bytes > 2)
                    || (u <= unicode_detail::last_3byte_value && bytes > 3);
            };
            if (is_overlong(decoded, length)) {
                dr.error = error_code::overlong_sequence;
                return dr;
            }
            if (unicode_detail::is_surrogate(decoded) || decoded > unicode_detail::last_code_point) {
                dr.error = error_code::invalid_code_point;
                return dr;
            }
            
            // then everything is fine
            dr.codepoint = decoded;
            dr.error = error_code::ok;
            dr.next = it;
            return dr;
        }