grapheme.hpp

// Copyright Take Vos 2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../utility/module.hpp"
#include "../strings.hpp"
#include "../stable_set.hpp"
#include "../log.hpp"
#include "unicode_normalization.hpp"
#include "ucd_general_categories.hpp"
#include <cstdint>
#include <string>
#include <string_view>
#include <cstddef>
#include <memory>
#include <vector>
#include <algorithm>
#include <bit>
 
namespace hi::inline v1 {
namespace detail {
 
inline auto long_graphemes = ::hi::stable_set<std::u32string>{};
 
} // namespace detail
 
struct composed_t {};
 
struct grapheme {
    using value_type = uint32_t;
 
    value_type _value;
 
    constexpr grapheme() noexcept = default;
    constexpr grapheme(grapheme const&) noexcept = default;
    constexpr grapheme(grapheme&&) noexcept = default;
    constexpr grapheme& operator=(grapheme const&) noexcept = default;
    constexpr grapheme& operator=(grapheme&&) noexcept = default;
 
    constexpr grapheme(intrinsic_t, value_type value) : _value(value) {}
 
    constexpr value_type& intrinsic() noexcept
    {
        return _value;
    }
 
    constexpr value_type const& intrinsic() const noexcept
    {
        return _value;
    }
 
    constexpr grapheme(char32_t code_point) noexcept : _value(truncate<value_type>(code_point))
    {
        hi_axiom(code_point <= 0x10'ffff);
    }
 
    constexpr grapheme(char ascii_char) noexcept : _value(truncate<value_type>(ascii_char))
    {
        hi_axiom(ascii_char >= 0 and ascii_char <= 0x7f);
    }
 
    constexpr grapheme& operator=(char32_t code_point) noexcept
    {
        _value = truncate<value_type>(code_point);
        return *this;
    }
 
    constexpr grapheme& operator=(char ascii_char) noexcept
    {
        hi_axiom(ascii_char >= 0 and ascii_char <= 0x7f);
        _value = truncate<value_type>(ascii_char);
        return *this;
    }
 
    constexpr grapheme(composed_t, std::u32string_view code_points) noexcept
    {
        switch (code_points.size()) {
        case 0:
            hi_no_default();
 
        case 1:
            _value = truncate<value_type>(code_points[0]);
            break;
 
        default:
            hilet index = detail::long_graphemes.insert(std::u32string{code_points});
            if (index < 0x0f'0000) {
                _value = narrow_cast<value_type>(index + 0x11'0000);
            } else {
                [[unlikely]] hi_log_error_once(
                    "grapheme::error::too-many", "Too many long graphemes encoded, replacing with U+fffd");
                _value = 0x00'fffd;
            }
        }
    }
 
    constexpr explicit grapheme(std::u32string_view code_points) noexcept :
        grapheme(composed_t{}, unicode_normalize(code_points, unicode_normalize_config::NFC()))
    {
    }
 
    [[nodiscard]] constexpr std::u32string decomposed() const noexcept
    {
        return unicode_decompose(composed(), unicode_normalize_config::NFD());
    }
 
    [[nodiscard]] constexpr bool valid() const noexcept
    {
        if (is_noncharacter(get<0>(*this))) {
            return false;
        }
 
        hilet general_category = ucd_get_general_category(get<0>(*this));
        if (is_C(general_category)) {
            return false;
        }
        if (is_M(general_category)) {
            return false;
        }
        return true;
    }
 
    [[nodiscard]] std::u32string const& long_grapheme() const noexcept
    {
        hi_assert(_value > 0x10'ffff and _value <= 0x1f'ffff);
        return detail::long_graphemes[_value - 0x11'0000];
    }
 
    [[nodiscard]] constexpr std::size_t size() const noexcept
    {
        if (_value <= 0x10'ffff) {
            return 1;
 
        } else {
            return long_grapheme().size();
        }
    }
 
    [[nodiscard]] constexpr char32_t operator[](size_t i) const noexcept
    {
        hi_assert_bounds(i, *this);
 
        if (_value <= 0x10'ffff) {
            return truncate<char32_t>(_value);
        } else {
            return long_grapheme()[i];
        }
    }
 
    template<size_t I>
    [[nodiscard]] friend constexpr char32_t get(grapheme const& rhs) noexcept
    {
        hi_assert_bounds(I, rhs);
 
        if (rhs._value <= 0x10'ffff) {
            return rhs._value;
        } else {
            return rhs.long_grapheme()[I];
        }
    }
 
    [[nodiscard]] constexpr std::u32string composed() const noexcept
    {
        if (_value <= 0x10'ffff) {
            return std::u32string{truncate<char32_t>(_value)};
        } else {
            return long_grapheme();
        }
    }
 
    [[nodiscard]] friend constexpr bool operator==(grapheme const&, grapheme const&) noexcept = default;
 
    [[nodiscard]] friend constexpr bool operator==(grapheme const& lhs, char32_t const& rhs) noexcept
    {
        return lhs._value == char_cast<value_type>(rhs);
    }
 
    [[nodiscard]] friend constexpr bool operator==(grapheme const& lhs, char const& rhs) noexcept
    {
        hi_axiom(rhs <= 0x7f);
        return lhs._value == char_cast<value_type>(rhs);
    }
 
    [[nodiscard]] friend constexpr std::strong_ordering operator<=>(grapheme const& lhs, grapheme const& rhs) noexcept
    {
        return lhs.decomposed() <=> rhs.decomposed();
    }
 
    [[nodiscard]] friend constexpr std::strong_ordering operator<=>(grapheme const& lhs, char32_t const& rhs) noexcept
    {
        return lhs <=> grapheme{rhs};
    }
 
    [[nodiscard]] friend constexpr std::strong_ordering operator<=>(grapheme const& lhs, char const& rhs) noexcept
    {
        return lhs <=> grapheme{rhs};
    }
 
    [[nodiscard]] friend constexpr std::string to_string(grapheme const& rhs) noexcept
    {
        return hi::to_string(rhs.composed());
    }
 
    [[nodiscard]] friend constexpr std::wstring to_wstring(grapheme const& rhs) noexcept
    {
        return hi::to_wstring(rhs.composed());
    }
 
    [[nodiscard]] friend constexpr std::u32string to_u32string(grapheme const& rhs) noexcept
    {
        return rhs.composed();
    }
};
 
} // namespace hi::inline v1
 
template<>
struct std::hash<hi::grapheme> {
    [[nodiscard]] std::size_t operator()(hi::grapheme const& rhs) const noexcept
    {
        return std::hash<hi::grapheme::value_type>{}(rhs._value);
    }
};