translate.hpp

// Copyright Take Vos 2020.
// 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 "language.hpp"
#include "translation.hpp"
#include "../forward_value.hpp"
#include "../cast.hpp"
#include "../os_settings.hpp"
#include <memory>
#include <string>
#include <string_view>
#include <tuple>
 
namespace hi::inline v1 {
namespace detail {
class translate_args_base {
public:
    virtual ~translate_args_base() {}
 
    [[nodiscard]] virtual std::string format(std::string_view fmt) const noexcept = 0;
 
    [[nodiscard]] virtual std::string format(std::locale const &loc, std::string_view fmt) const noexcept = 0;
 
    [[nodiscard]] virtual long long n() const noexcept = 0;
 
    [[nodiscard]] virtual std::unique_ptr<translate_args_base> unique_copy() const noexcept = 0;
 
    [[nodiscard]] virtual bool equal_to(translate_args_base const &rhs) const noexcept = 0;
 
    [[nodiscard]] bool friend operator==(translate_args_base const &lhs, translate_args_base const &rhs) noexcept
    {
        return lhs.equal_to(rhs);
    }
};
 
template<typename... Values>
class translate_args : public translate_args_base {
public:
    translate_args(translate_args &&) noexcept = default;
    translate_args(translate_args const &) noexcept = default;
    translate_args &operator=(translate_args &&) noexcept = default;
    translate_args &operator=(translate_args const &) noexcept = default;
 
    template<typename... Args>
    translate_args(Args const &...args) noexcept : _values(args...)
    {
    }
 
    [[nodiscard]] std::unique_ptr<translate_args_base> unique_copy() const noexcept
    {
        return std::make_unique<translate_args>(*this);
    }
 
    [[nodiscard]] virtual bool equal_to(translate_args_base const &rhs) const noexcept
    {
        if (auto *rhs_ = dynamic_cast<translate_args const *>(&rhs)) {
            return _values == rhs_->_values;
        } else {
            return false;
        }
    }
 
    [[nodiscard]] std::string format(std::string_view fmt) const noexcept override
    {
        return std::apply(format_wrapper<Values const &...>, std::tuple_cat(std::tuple{fmt}, _values));
    }
 
    [[nodiscard]] std::string format(std::locale const &loc, std::string_view fmt) const noexcept override
    {
        return std::apply(format_locale_wrapper<Values const &...>, std::tuple_cat(std::tuple{loc, fmt}, _values));
    }
 
    template<std::size_t I>
    [[nodiscard]] long long n_recurse() const noexcept
    {
        if constexpr (I < sizeof...(Values)) {
            if constexpr (std::is_integral_v<decltype(std::get<I>(_values))>) {
                return narrow_cast<long long>(std::get<I>(_values));
            } else {
                return n_recurse<I + 1>();
            }
        } else {
            return 0;
        }
    }
 
    [[nodiscard]] long long n() const noexcept override
    {
        return n_recurse<0>();
    }
 
private:
    std::tuple<Values...> _values;
 
    template<typename... Args>
    static std::string format_wrapper(std::string_view fmt, Args const &...args)
    {
        return std::vformat(fmt, std::make_format_args(args...));
    }
 
    template<typename... Args>
    static std::string format_locale_wrapper(std::locale const &loc, std::string_view fmt, Args const &...args)
    {
        return std::vformat(loc, fmt, std::make_format_args(args...));
    }
};
 
template<typename... Args>
translate_args(Args &&...) -> translate_args<forward_value_t<Args>...>;
 
} // namespace detail
 
class translate {
public:
    constexpr translate() noexcept : _msg_id(), _args(nullptr) {}
 
    translate(translate &&) noexcept = default;
    translate &operator=(translate &&) noexcept = default;
 
    translate(translate const &other) noexcept : _msg_id(other._msg_id), _args(other._args ? other._args->unique_copy() : nullptr) {}
 
    translate &operator=(translate const &other) noexcept
    {
        _msg_id = other._msg_id;
        _args = other._args ? other._args->unique_copy() : nullptr;
        return *this;
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return _msg_id.empty();
    }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept
    {
        return not empty();
    }
 
    template<typename... Args>
    translate(std::string_view msg_id, Args const &...args) noexcept :
        _msg_id(msg_id), _args(sizeof...(Args) ? std::make_unique<detail::translate_args<forward_value_t<Args>...>>(args...) : nullptr)
    {
    }
 
    [[nodiscard]] std::string operator()(std::vector<language *> const &languages = os_settings::languages()) const noexcept
    {
        if (_args) {
            auto fmt = ::hi::get_translation(_msg_id, _args->n(), languages);
            return _args->format(fmt);
        } else {
            return std::string{::hi::get_translation(_msg_id, 0, languages)};
        }
    }
 
    [[nodiscard]] std::string
    operator()(std::locale const &loc, std::vector<language *> const &languages = os_settings::languages()) const noexcept
    {
        if (_args) {
            auto fmt = ::hi::get_translation(_msg_id, _args->n(), languages);
            return _args->format(loc, fmt);
        } else {
            return std::string{::hi::get_translation(_msg_id, 0, languages)};
        }
    }
 
    [[nodiscard]] friend bool operator==(translate const &lhs, translate const &rhs) noexcept
    {
        if (lhs._args == rhs._args) {
            return lhs._msg_id == rhs._msg_id;
        } else if (lhs._args and rhs._args) {
            return lhs._msg_id == rhs._msg_id and *lhs._args == *rhs._args;
        } else {
            return false;
        }
    }
 
private:
    std::string _msg_id;
    std::unique_ptr<detail::translate_args_base> _args;
};
 
using tr = translate;
 
} // namespace hi::inline v1