code_point.hpp

// Copyright (C) 2022 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include <array>
#include <cstdint>
#include <optional>
#include <string_view>
 
namespace arg_router::utility::utf8::code_point
{
using type = std::uint32_t;
 
class range
{
public:
    constexpr range(type first, type last, std::uint8_t meta = 0) noexcept : data_{}
    {
        // array::fill is not constexpr until C++20...
        for (auto& b : data_) {
            b = 0;
        }
 
        // Can't use reinterpret_cast in constexpr function, so we have to do it the old fashioned
        // way!
        // [0-20]  Start code point
        // [21-41] End code point
        // [42-47] Metadata
        // NOLINTBEGIN(readability-magic-numbers)
        data_[0] = first & 0xFF;
        data_[1] = (first >> 8) & 0xFF;
        data_[2] = (first >> 16) & 0x1F;
 
        data_[2] |= (last & 0x7) << 5;
        data_[3] = (last >> 3) & 0xFF;
        data_[4] = (last >> 11) & 0xFF;
        data_[5] = (last >> 19) & 0x3;
 
        data_[5] |= (meta & 0x3F) << 2;
        // NOLINTEND(readability-magic-numbers)
    }
 
    [[nodiscard]] constexpr type first() const noexcept
    {
        // NOLINTBEGIN(readability-magic-numbers)
        auto value = type{data_[0]};
        value |= data_[1] << 8;
        value |= (data_[2] & 0x1F) << 16;
        // NOLINTEND(readability-magic-numbers)
 
        return value;
    }
 
    [[nodiscard]] constexpr type last() const noexcept
    {
        // NOLINTBEGIN(readability-magic-numbers)
        type value = (data_[2] >> 5) & 0x7;
        value |= data_[3] << 3;
        value |= data_[4] << 11;
        value |= (data_[5] & 0x3) << 19;
        // NOLINTEND(readability-magic-numbers)
 
        return value;
    }
 
    [[nodiscard]] constexpr std::uint8_t meta() const noexcept
    {
        // NOLINTNEXTLINE
        return (data_[5] >> 2) & 0x3F;
    }
 
    constexpr bool operator<(range other) const noexcept
    {
        if (first() == other.first()) {
            return last() < other.last();
        }
        return first() < other.first();
    }
 
    constexpr bool operator<(type cp) const noexcept { return first() < cp; }
 
private:
    constexpr static auto bytes_per_cp = std::size_t{6};
    std::array<std::uint8_t, bytes_per_cp> data_;
};
 
[[nodiscard]] inline constexpr std::size_t count(std::string_view str) noexcept
{
    // Only the leading code point byte (applies to ASCII too) will not lead with 0x80
    constexpr auto high_2_bit_mask = std::uint8_t{0xC0};
    constexpr auto high_bit = std::uint8_t{0x80};
 
    auto result = std::size_t{0};
    for (auto c : str) {
        result += (c & high_2_bit_mask) != high_bit;
    }
 
    return result;
}
 
[[nodiscard]] inline constexpr std::size_t size(std::string_view str) noexcept
{
    if (str.empty()) {
        return 0;
    }
 
    const auto first_byte = static_cast<std::uint8_t>(str[0]);
 
    // The MSB determines if it's ASCII or UTF-8
    constexpr auto is_ascii_mask = std::uint8_t{0b1000'0000};
    if ((first_byte & is_ascii_mask) == 0) {
        // ASCII
        return 1;
    }
 
    // Can't think of a way to do this without branches
    constexpr auto max_2_byte_header = std::uint8_t{0b1101'1111};
    if (first_byte < max_2_byte_header) {
        return 2;
    }
 
    constexpr auto max_3_byte_header = std::uint8_t{0b1110'1111};
    if (first_byte < max_3_byte_header) {
        return 3;
    }
 
    return 4;
}
 
[[nodiscard]] inline constexpr std::optional<type> decode(std::string_view str) noexcept
{
    const auto bytes_to_read = size(str);
    if (bytes_to_read == 0) {
        return {};
    }
 
    if (bytes_to_read == 1) {
        // ASCII
        return str[0];
    }
 
    if (str.size() < bytes_to_read) {
        return {};
    }
 
    constexpr auto subsequent_byte_data_bits = 6;
    constexpr auto subsequent_byte_mask = type{(1 << subsequent_byte_data_bits) - 1};
    constexpr auto maximum_first_byte_data_mask = type{0b0001'1111};
 
    const auto first_byte = static_cast<std::uint8_t>(str[0]);
 
    auto result = first_byte & (maximum_first_byte_data_mask >> (bytes_to_read - 2));
    for (auto i = 1u; i < bytes_to_read; ++i) {
        const auto subsequent_byte = static_cast<type>(str[i]);
 
        // Move the previous reads up to make space for the subsequent byte's data
        result <<= subsequent_byte_data_bits;
        result |= subsequent_byte & subsequent_byte_mask;
    }
 
    return result;
}
 
class iterator
{
public:
    using difference_type = std::string_view::difference_type;
    using value_type = std::string_view;
    using pointer = const value_type*;
    using reference = const value_type&;
    using iterator_category = std::forward_iterator_tag;
 
    class range_t
    {
    public:
        friend class iterator;
 
        [[nodiscard]] constexpr iterator begin() noexcept { return iterator{str_}; }
 
        [[nodiscard]] constexpr static iterator end() noexcept { return iterator{}; }
 
    private:
        constexpr explicit range_t(std::string_view str) noexcept : str_{str} {}
 
        std::string_view str_;
    };
 
    [[nodiscard]] constexpr static range_t range(std::string_view str) noexcept
    {
        return range_t{str};
    }
 
    constexpr iterator() noexcept = default;
 
    constexpr explicit iterator(std::string_view str) noexcept : str_{str} {}
 
    [[nodiscard]] constexpr bool operator==(iterator other) const noexcept
    {
        // If they are both empty, then they are considered both end iterators and therefore equal
        if (str_.empty() && other.str_.empty()) {
            return true;
        }
        return (str_.data() == other.str_.data()) && (str_.size() == other.str_.size());
    }
 
    [[nodiscard]] constexpr bool operator!=(iterator other) const noexcept
    {
        return !(*this == other);
    }
 
    [[nodiscard]] constexpr value_type operator*() const noexcept
    {
        const auto num_bytes = code_point::size(str_);
        return str_.substr(0, num_bytes);
    }
 
    constexpr iterator& operator++() noexcept
    {
        const auto num_bytes = code_point::size(str_);
        str_.remove_prefix(num_bytes);
        return *this;
    }
 
    constexpr iterator operator++(int) noexcept
    {
        auto result = *this;
 
        ++(*this);
        return result;
    }
 
private:
    std::string_view str_;
};
}  // namespace arg_router::utility::utf8::code_point