language_tag.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 "iso_15924.hpp"
#include "iso_3166.hpp"
#include "iso_639.hpp"
#include "../utility/module.hpp"
#include "../generator.hpp"
#include "../ranges.hpp"
#include <vector>
#include <string_view>
 
namespace hi::inline v1 {
 
class language_tag {
public:
    iso_639 language;
    iso_15924 script;
    iso_3166 region;
    uint16_t _reserved = 0;
 
    constexpr language_tag() noexcept {}
    constexpr language_tag(language_tag const&) noexcept = default;
    constexpr language_tag(language_tag&&) noexcept = default;
    constexpr language_tag& operator=(language_tag const&) noexcept = default;
    constexpr language_tag& operator=(language_tag&&) noexcept = default;
 
    constexpr language_tag(iso_639 const& language, iso_15924 const& script = {}, iso_3166 const& region = {}) noexcept :
        language(language), script(script), region(region)
    {
    }
 
    constexpr language_tag(iso_639 const& language, iso_3166 const& region) noexcept : language_tag(language, {}, region) {}
 
    language_tag(std::string_view str);
 
    [[nodiscard]] static language_tag parse(std::string_view str);
 
    [[nodiscard]] bool empty() const noexcept
    {
        return language.empty() and script.empty() and region.empty();
    }
 
    explicit operator bool() const noexcept
    {
        return not empty();
    }
 
    [[nodiscard]] generator<language_tag> variants() const noexcept
    {
        co_yield *this;
        if (script and region) {
            co_yield language_tag{language, region};
            co_yield language_tag{language, script};
        }
        if (script or region) {
            co_yield language_tag{language};
        }
    }
 
    [[nodiscard]] generator<language_tag> canonical_variants() const noexcept
    {
        hilet check = expand();
        for (hilet& tag : variants()) {
            if (tag.expand() == check) {
                co_yield tag;
            }
        }
    }
 
    [[nodiscard]] std::vector<language_tag> all_variants() const noexcept
    {
        auto r = make_vector(variants());
 
        // And languages variants from expanded variants.
        for (hilet variant : variants()) {
            for (hilet expanded_variant : variant.expand().variants()) {
                if (std::find(r.begin(), r.end(), expanded_variant) == r.end()) {
                    r.push_back(expanded_variant);
                }
            }
        }
        return r;
    }
 
    [[nodiscard]] language_tag expand() const noexcept;
 
    [[nodiscard]] language_tag shrink() const noexcept
    {
        auto last_variant = *this;
        for (hilet& variant : canonical_variants()) {
            last_variant = variant;
        }
        return last_variant;
    }
 
    [[nodiscard]] iso_15924 default_script() const noexcept
    {
        return expand().script;
    }
 
    [[nodiscard]] bool left_to_right() const noexcept
    {
        return default_script().left_to_right();
    }
 
    [[nodiscard]] std::string to_string() const noexcept
    {
        auto r = std::string{};
        r += language.code();
        if (script) {
            r += '-';
            r += script.code4();
        }
        if (region) {
            r += "-";
            r += region.code2();
        }
        return r;
    }
 
    [[nodiscard]] constexpr friend bool matches(language_tag const& lhs, language_tag const& rhs) noexcept
    {
        if (lhs.language and rhs.language and lhs.language != rhs.language) {
            return false;
        }
        if (lhs.script and rhs.script and lhs.script != rhs.script) {
            return false;
        }
        if (lhs.region and rhs.region and lhs.region != rhs.region) {
            return false;
        }
        return true;
    }
 
    [[nodiscard]] constexpr friend bool operator==(language_tag const&, language_tag const&) noexcept = default;
};
 
[[nodiscard]] std::vector<language_tag> variants(std::vector<language_tag> languages);
 
} // namespace hi::inline v1
 
template<>
struct std::hash<hi::language_tag> {
    [[nodiscard]] size_t operator()(hi::language_tag const& rhs) const noexcept
    {
        return hi::hash_mix(
            std::hash<hi::iso_639>{}(rhs.language),
            std::hash<hi::iso_15924>{}(rhs.script),
            std::hash<hi::iso_3166>{}(rhs.region));
    }
};
 
template<typename CharT>
struct std::formatter<hi::language_tag, CharT> : std::formatter<std::string_view, CharT> {
    auto format(hi::language_tag const& t, auto& fc)
    {
        return std::formatter<std::string_view, CharT>::format(t.to_string(), fc);
    }
};
 
// XXX C++23 should have this fixed?
template<typename CharT>
struct std::formatter<std::vector<hi::language_tag>, CharT> : std::formatter<std::string_view, CharT> {
    auto format(std::vector<hi::language_tag> const& t, auto& fc)
    {
        auto r = std::string{};
        for (hilet language : t) {
            if (not r.empty()) {
                r += ", ";
            }
            r += std::format("{}", language);
        }
        return std::formatter<std::string_view, CharT>::format(r, fc);
    }
};