iso_639.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/utility.hpp"
#include "../macros.hpp"
#include <cctype>
#include <compare>
#include <string_view>
#include <string>
#include <format>
 
hi_export_module(hikogui.i18n.iso_639);
 
hi_export namespace hi::inline v1 {
 
hi_export class iso_639 {
public:
    template<std::size_t I>
    constexpr friend bool set(iso_639& rhs, char c) noexcept
    {
        if (not (c == 0 or (c >= 'a' and c <= 'z') or (c >= 'A' and c <= 'Z') or (c >= '1' and c <= '5'))) {
            // Must be letters or the digits between '1' and '5', or nul.
            return false;
        }
 
        // clang-format off
        uint16_t const x =
            (c >= 'a' and c <= 'z') ? c - 'a' + 1 :
            (c >= 'A' and c <= 'Z') ? c - 'A' + 1 :
            (c >= '1' and c <= '5') ? c - '1' + 27 :
            0;
        // clang-format on
 
        hi_axiom(x <= 0x1f);
        constexpr auto shift = I * 5;
        rhs._v &= ~(0x1f << shift);
        rhs._v |= x << shift;
        return true;
    }
 
    template<std::size_t I>
    [[nodiscard]] constexpr friend char get(iso_639 const& rhs) noexcept
    {
        constexpr auto shift = I * 5;
        auto const x = (rhs._v >> shift) & 0x1f;
        if (x == 0) {
            return 0;
        } else if (x <= 26) {
            return 'a' + narrow_cast<char>(x - 1);
        } else {
            return '1' + narrow_cast<char>(x - 27);
        }
    }
 
    constexpr iso_639(iso_639 const&) noexcept = default;
    constexpr iso_639(iso_639&&) noexcept = default;
    constexpr iso_639& operator=(iso_639 const&) noexcept = default;
    constexpr iso_639& operator=(iso_639&&) noexcept = default;
 
    constexpr iso_639() noexcept : _v(0) {}
 
    constexpr iso_639(std::string_view str) : _v(0)
    {
        if (str.size() != 2 and str.size() != 3) {
            throw parse_error("ISO-639 incorrect length.");
        }
 
        if (not set<0>(*this, str[0])) {
            throw parse_error("Must be letters or the digits between '1' and '5', or nul.");
        }
 
        if (not set<1>(*this, str[1])) {
            throw parse_error("Must be letters or the digits between '1' and '5', or nul.");
        }
 
        if (str.size() == 3) {
            if (not set<2>(*this, str[2]))  {
                throw parse_error("Must be letters or the digits between '1' and '5', or nul.");
            }
        }
    }
 
    constexpr iso_639(std::in_place_t, uint16_t v) noexcept : _v(v) {}
 
    [[nodiscard]] constexpr uint16_t const& intrinsic() const noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr uint16_t& intrinsic() noexcept
    {
        return _v;
    }
 
    [[nodiscard]] constexpr std::size_t size() const noexcept
    {
        auto const tmp = _v & 0x7fff;
        // clang-format off
        return
            tmp == 0 ? 0 :
            tmp <= 0x1f ? 1 :
            tmp <= 0x3ff ? 2 :
            3;
        // clang-format on
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return _v == 0;
    }
 
    constexpr explicit operator bool() const noexcept
    {
        return not empty();
    }
 
    [[nodiscard]] size_t hash() const noexcept
    {
        return std::hash<uint16_t>{}(_v);
    }
 
    [[nodiscard]] constexpr std::string code() const noexcept
    {
        auto r = std::string{};
        if (size() >= 2) {
            r += get<0>(*this);
            r += get<1>(*this);
        }
        if (size() == 3) {
            r += get<2>(*this);
        }
        return r;
    }
 
    [[nodiscard]] constexpr friend std::string to_string(iso_639 const &rhs) noexcept
    {
        return rhs.code();
    }
 
    [[nodiscard]] constexpr friend bool operator==(iso_639 const& lhs, iso_639 const& rhs) noexcept = default;
 
    [[nodiscard]] constexpr friend auto operator<=>(iso_639 const& lhs, iso_639 const& rhs) noexcept = default;
 
    [[nodiscard]] constexpr friend bool matches(iso_639 const& lhs, iso_639 const& rhs) noexcept
    {
        return lhs.empty() or lhs == rhs;
    }
 
private:
    uint16_t _v;
};
 
} // namespace hi::inline v1
 
hi_export template<>
struct std::hash<hi::iso_639> {
    [[nodiscard]] size_t operator()(hi::iso_639 const& rhs) const noexcept
    {
        return rhs.hash();
    }
};