gui_localizer.hpp

#ifndef LXGUI_GUI_LOCALIZER_HPP
#define LXGUI_GUI_LOCALIZER_HPP
 
#include "lxgui/gui_code_point_range.hpp"
#include "lxgui/lxgui.hpp"
 
#include <locale>
#include <lxgui/extern_fmt.hpp>
#include <lxgui/extern_sol2_state.hpp>
#include <lxgui/extern_sol2_variadic_args.hpp>
#include <string>
#include <string_view>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace lxgui::gui {
 
class localizer {
public:
    localizer();
 
    // Non-copiable, non-movable
    localizer(const localizer&)            = delete;
    localizer(localizer&&)                 = delete;
    localizer& operator=(const localizer&) = delete;
    localizer& operator=(localizer&&)      = delete;
 
    void set_locale(const std::locale& locale);
 
    void set_preferred_languages(const std::vector<std::string>& languages);
 
 
    void auto_detect_preferred_languages();
 
    const std::locale& get_locale() const;
 
 
    const std::vector<std::string>& get_preferred_languages() const;
 
    void clear_allowed_code_points();
 
    void add_allowed_code_points(const code_point_range& range);
 
    void add_allowed_code_points_for_group(const std::string& unicode_group);
 
    void add_allowed_code_points_for_language(const std::string& language_code);
 
 
    void auto_detect_allowed_code_points();
 
    const std::vector<code_point_range>& get_allowed_code_points() const;
 
    void set_fallback_code_point(char32_t code_point);
 
    char32_t get_fallback_code_point() const;
 
    void load_translations(const std::string& folder_path);
 
    void load_translation_file(const std::string& file_name);
 
    void clear_translations();
 
    std::string format_string(std::string_view message, sol::variadic_args args) const;
 
    template<typename... Args>
    std::string format_string(std::string_view message, Args&&... args) const {
        return fmt::format(locale_, message, std::forward<Args>(args)...);
    }
 
    std::string localize(std::string_view key, sol::variadic_args args) const;
 
    template<typename... Args>
    std::string localize(std::string_view key, Args&&... args) const {
        if (!is_key_valid_(key))
            return std::string{key};
 
        auto iter = find_key_(key);
        if (iter == map_.end())
            return std::string{key};
 
        return std::visit(
            [&](const auto& item) {
                constexpr bool is_string =
                    std::is_same_v<std::decay_t<decltype(item)>, std::string>;
                if constexpr (is_string) {
                    if constexpr (sizeof...(Args) == 0) {
                        return item;
                    } else {
                        return fmt::format(
                            locale_, fmt::runtime(item), std::forward<Args>(args)...);
                    }
                } else {
                    auto result = item(std::forward<Args>(args)...);
                    if (result.valid() && result.begin() != result.end()) {
                        auto&& first = *result.begin();
                        if (first.template is<std::string>())
                            return first.template as<std::string>();
                        else
                            return std::string{key};
                    } else
                        return std::string{key};
                }
            },
            iter->second);
    }
 
    void register_on_lua(sol::state& lua);
 
private:
    using hash_type   = std::size_t;
    using mapped_item = std::variant<std::string, sol::protected_function>;
    using map_type    = std::unordered_map<hash_type, mapped_item>;
 
    std::locale                   locale_;
    std::vector<std::string>      languages_;
    std::vector<code_point_range> code_points_;
    char32_t                      default_code_point_ = U'\u25a1'; // '□'
    sol::state                    lua_;
    map_type                      map_;
 
    bool                     is_key_valid_(std::string_view key) const;
    map_type::const_iterator find_key_(std::string_view key) const;
    void                     reset_language_fallback_();
};
 
} // namespace lxgui::gui
 
#endif