grapheme.hpp

// Copyright Take Vos 2019-2021.
// 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 "unicode_db_non_starter.hpp"
#include "../required.hpp"
#include "../strings.hpp"
#include <cstdint>
#include <string>
#include <cstddef>
 
namespace hi::inline v1 {
 
struct grapheme {
    using value_type = uint64_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 explicit grapheme(char32_t code_point) noexcept : value((static_cast<value_type>(code_point) << 43) | 1) {}
 
    constexpr grapheme &operator=(char32_t code_point) noexcept
    {
        value = (static_cast<value_type>(code_point) << 43) | 1;
        return *this;
    }
 
    constexpr explicit grapheme(char code_point) noexcept : value((static_cast<value_type>(code_point) << 43) | 1) {}
 
    constexpr grapheme &operator=(char code_point) noexcept
    {
        value = (static_cast<value_type>(code_point) << 43) | 1;
        return *this;
    }
 
    explicit grapheme(std::u32string_view code_points) noexcept;
 
    grapheme &operator=(std::u32string_view code_points) noexcept;
 
    [[nodiscard]] static grapheme from_composed(std::u32string_view code_points) noexcept;
 
    [[nodiscard]] static constexpr grapheme eof() noexcept
    {
        grapheme r;
        r.value = 0;
        return r;
    }
 
    constexpr void clear() noexcept
    {
        value = 0;
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return value == 0;
    }
 
    constexpr operator bool() const noexcept
    {
        return not empty();
    }
 
    [[nodiscard]] bool valid() const noexcept;
 
    [[nodiscard]] constexpr std::size_t size() const noexcept
    {
        hilet size_ = value & 0x7;
        return size_ <= 5 ? size_ : 5;
    }
 
    [[nodiscard]] constexpr bool overlong() const noexcept
    {
        return (value & 0x7) == 6;
    }
 
    [[nodiscard]] constexpr char32_t operator[](size_t i) const noexcept
    {
        hi_axiom(i < size());
 
        if (i == 0) {
            return static_cast<char32_t>(value >> 43);
 
        } else {
            hilet shift = (4 - i) * 10 + 3;
            return detail::unicode_db_non_starter_table[(value >> shift) & 0x3ff];
        }
    }
 
    template<size_t I>
    [[nodiscard]] friend constexpr char32_t get(grapheme const &rhs) noexcept
    {
        if constexpr (I == 0) {
            return static_cast<char32_t>(rhs.value >> 43);
 
        } else {
            constexpr auto shift = (4 - I) * 10 + 3;
            return detail::unicode_db_non_starter_table[(rhs.value >> shift) & 0x3ff];
        }
    }
 
    [[nodiscard]] constexpr std::u32string composed() const noexcept
    {
        auto r = std::u32string{};
        r.reserve(size());
        for (std::size_t i = 0; i != size(); ++i) {
            r += (*this)[i];
        }
        return r;
    }
 
    [[nodiscard]] std::u32string decomposed() const noexcept;
 
    [[nodiscard]] friend constexpr bool operator==(grapheme const &a, grapheme const &b) noexcept = default;
 
    [[nodiscard]] friend constexpr std::strong_ordering operator<=>(grapheme const &a, grapheme const &b) noexcept = default;
 
    [[nodiscard]] friend constexpr bool operator==(grapheme const &lhs, char32_t const &rhs) noexcept
    {
        return lhs == grapheme{rhs};
    }
 
    [[nodiscard]] friend constexpr std::strong_ordering operator<=>(grapheme const &lhs, char32_t const &rhs) noexcept
    {
        return lhs <=> grapheme{rhs};
    }
 
    [[nodiscard]] friend constexpr bool operator==(grapheme const &lhs, char 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 std::string to_string(grapheme const &rhs) noexcept
    {
        return hi::to_string(rhs.composed());
    }
 
    [[nodiscard]] friend 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);
    }
};