unicode_mask.hpp

// Copyright Take Vos 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 "../required.hpp"
#include "grapheme.hpp"
#include <cstdint>
#include <cstddef>
 
namespace hi::inline v1 {
namespace detail {
 
class unicode_mask_entry {
public:
    static constexpr std::size_t size_bit = 11;
    static constexpr std::size_t size_mask = (1_uz << size_bit) - 1;
 
    constexpr unicode_mask_entry() noexcept : _value(0) {}
 
    constexpr unicode_mask_entry(char32_t first, char32_t last) noexcept :
        _value(static_cast<uint32_t>((first << size_bit) | (last - first)))
    {
        hi_axiom(last >= first);
        hi_axiom(last - first <= capacity());
    }
 
    constexpr unicode_mask_entry(unicode_mask_entry const &) noexcept = default;
    constexpr unicode_mask_entry(unicode_mask_entry &&) noexcept = default;
    constexpr unicode_mask_entry &operator=(unicode_mask_entry const &) noexcept = default;
    constexpr unicode_mask_entry &operator=(unicode_mask_entry &&) noexcept = default;
 
    [[nodiscard]] static constexpr std::size_t capacity() noexcept
    {
        return size_mask;
    }
 
    [[nodiscard]] constexpr std::size_t size() const noexcept
    {
        return static_cast<std::size_t>(_value & size_mask);
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return size() == 0;
    }
 
    [[nodiscard]] constexpr bool full() const noexcept
    {
        return size() == capacity();
    }
 
    [[nodiscard]] constexpr std::size_t room() const noexcept
    {
        return capacity() - size();
    }
 
    [[nodiscard]] constexpr char32_t begin() const noexcept
    {
        return static_cast<char32_t>(_value >> size_bit);
    }
 
    [[nodiscard]] constexpr char32_t end() const noexcept
    {
        return begin() + static_cast<char32_t>(size());
    }
 
    constexpr unicode_mask_entry &add_back(std::size_t num_code_points) noexcept
    {
        return *this = unicode_mask_entry{begin(), static_cast<char32_t>(end() + num_code_points)};
    }
 
    constexpr unicode_mask_entry &remove_front(std::size_t num_code_points) noexcept
    {
        return *this = unicode_mask_entry{static_cast<char32_t>(begin() + num_code_points), end()};
    }
 
    [[nodiscard]] constexpr bool contains(char32_t rhs) const noexcept
    {
        return (begin() <= rhs) and (rhs < end());
    }
 
private:
    uint32_t _value;
};
 
} // namespace detail
 
class unicode_mask {
public:
    constexpr unicode_mask() noexcept {}
    constexpr unicode_mask(unicode_mask const &) noexcept = default;
    constexpr unicode_mask(unicode_mask &&) noexcept = default;
    constexpr unicode_mask &operator=(unicode_mask const &) noexcept = default;
    constexpr unicode_mask &operator=(unicode_mask &&) noexcept = default;
 
    [[nodiscard]] constexpr std::size_t size() const noexcept
    {
        return _size;
    }
 
    [[nodiscard]] bool contains(char32_t c) const noexcept;
 
    [[nodiscard]] bool contains_composed(grapheme g) const noexcept;
 
    [[nodiscard]] bool contains_decomposed(grapheme g) const noexcept;
 
    [[nodiscard]] bool contains(grapheme g) const noexcept;
 
    [[nodiscard]] bool contains(unicode_mask const &other) const noexcept;
 
    void add(char32_t first, char32_t last) noexcept;
 
    [[nodiscard]] friend unicode_mask operator|(unicode_mask const &lhs, unicode_mask const &rhs) noexcept
    {
        auto r = unicode_mask{};
        r._entries.reserve(lhs._entries.size() * 2 + rhs._entries.size() * 2);
 
        auto lhs_it = begin(lhs._entries);
        auto rhs_it = begin(rhs._entries);
        hilet lhs_end = end(lhs._entries);
        hilet rhs_end = end(rhs._entries);
 
        while (lhs_it != lhs_end or rhs_it != rhs_end) {
            // clang-format off
            auto &it = 
                (lhs_it == lhs_end) ? rhs_it :
                (rhs_it == rhs_end) ? lhs_it :
                (lhs_it->begin() < rhs_it->begin()) ? lhs_it : rhs_it;
            // clang-format on
 
            hilet new_begin = r._entries.empty() ? it->begin() : std::max(r._entries.back().end(), it->begin());
            hilet new_end = it->end();
            if (new_begin < new_end) {
                r._entries.emplace_back(new_begin, new_end);
                r._size += new_end - new_begin;
            }
            ++it;
        }
 
        // r.optimize();
        return r;
    }
 
    unicode_mask &operator|=(unicode_mask const &rhs) noexcept
    {
        return *this = *this | rhs;
    }
 
    void optimize() noexcept;
 
    void shrink_to_fit() noexcept;
 
    [[nodiscard]] bool holds_invariant() const noexcept;
 
private:
    using entry_type = detail::unicode_mask_entry;
    using entries_type = std::vector<entry_type>;
    using iterator = typename entries_type::iterator;
    using const_iterator = typename entries_type::const_iterator;
 
    std::size_t _size = 0;
    entries_type _entries = {};
};
 
} // namespace hi::inline v1