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>
 
hi_export_module(hikogui.i18n.iso_639);
 
namespace hi::inline v1 {

hi_export class iso_639 {
public:
    template<std::size_t I>
    constexpr friend iso_639& set(iso_639& rhs, char c)
    {
        hi_check(
            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");
 
        // 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_assert(x <= 0x1f);
        constexpr auto shift = I * 5;
        rhs._v &= ~(0x1f << shift);
        rhs._v |= x << shift;
        return rhs;
    }

    template<std::size_t I>
    [[nodiscard]] constexpr friend char get(iso_639 const& rhs) noexcept
    {
        constexpr auto shift = I * 5;
        hilet 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)
    {
        try {
            hi_check(str.size() == 2 or str.size() == 3, "ISO-639 incorrect length.");
 
            set<0>(*this, str[0]);
            set<1>(*this, str[1]);
            if (str.size() == 3) {
                set<2>(*this, str[2]);
            }
        } catch (...) {
            throw parse_error(std::format("A ISO-639 language code must be 2 or 3 letters in length, got '{}'", str));
        }
    }
 
    constexpr iso_639(intrinsic_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
    {
        hilet 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();
    }
};