translate.hpp

// Copyright Take Vos 2020-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 "translation.hpp"
#include "../forward_value.hpp"
#include "../utility/module.hpp"
#include "../os_settings.hpp"
#include "../text/module.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() {}
    translate_args_base() = default;
    translate_args_base(translate_args_base const&) = default;
    translate_args_base(translate_args_base&&) = default;
    translate_args_base& operator=(translate_args_base const&) = default;
    translate_args_base& operator=(translate_args_base&&) = default;

    [[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 override
    {
        return std::make_unique<translate_args>(*this);
    }
 
    [[nodiscard]] bool equal_to(translate_args_base const& rhs) const noexcept override
    {
        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:
    ~translate() = default;

    constexpr translate() noexcept : _msg_id(), _args(nullptr), _has_args(false) {}
 
    constexpr translate(translate&& other) noexcept :
        _msg_id(std::move(other._msg_id)), _args(nullptr), _has_args(other._has_args)
    {
        if (_has_args) {
            _args = std::move(other._args);
        }
    }
 
    constexpr translate& operator=(translate&& other) noexcept
    {
        _msg_id = std::move(other._msg_id);
        _has_args = other._has_args;
        if (_has_args) {
            _args = std::move(other._args);
        }
        return *this;
    }
 
    constexpr translate(translate const& other) noexcept : _msg_id(other._msg_id), _args(nullptr), _has_args(other._has_args)
    {
        if (_has_args) {
            _args = other._args->unique_copy();
        }
    }
 
    constexpr translate& operator=(translate const& other) noexcept
    {
        _msg_id = other._msg_id;
        _has_args = other._has_args;
        if (_has_args) {
            _args = other._args->unique_copy();
        }
        return *this;
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return _msg_id.empty();
    }

    [[nodiscard]] constexpr explicit operator bool() const noexcept
    {
        return not empty();
    }

    constexpr translate(std::string_view msg_id) noexcept : _msg_id(msg_id), _args(nullptr), _has_args(false) {}

    template<typename FirstArg, typename... Args>
    translate(std::string_view msg_id, FirstArg const& first_arg, Args const&...args) noexcept :
        _msg_id(msg_id),
        _args(std::make_unique<detail::translate_args<forward_value_t<FirstArg>, forward_value_t<Args>...>>(first_arg, args...)),
        _has_args(true)
    {
    }

    [[nodiscard]] text operator()(std::vector<language_tag> const& languages = os_settings::language_tags()) const noexcept
    {
        if (_has_args) {
            hilet[fmt, language_tag] = ::hi::get_translation(_msg_id, _args->n(), languages);
            hilet msg = _args->format(fmt);
            hilet default_attributes = character_attributes{language_tag.expand()};
            return to_text_with_markup(msg, default_attributes);
 
        } else {
            hilet[msg, language_tag] = ::hi::get_translation(_msg_id, 0, languages);
            hilet default_attributes = character_attributes{language_tag.expand()};
            return to_text_with_markup(msg, default_attributes);
        }
    }

    [[nodiscard]] text
    operator()(std::locale const& loc, std::vector<language_tag> const& languages = os_settings::language_tags()) const noexcept
    {
        if (_has_args) {
            hilet[fmt, language_tag] = ::hi::get_translation(_msg_id, _args->n(), languages);
            hilet msg = _args->format(loc, fmt);
            hilet default_attributes = character_attributes{language_tag.expand()};
            return to_text_with_markup(msg, default_attributes);
 
        } else {
            hilet[msg, language_tag] = ::hi::get_translation(_msg_id, 0, languages);
            hilet default_attributes = character_attributes{language_tag.expand()};
            return to_text_with_markup(msg, default_attributes);
        }
    }

    [[nodiscard]] constexpr friend bool operator==(translate const& lhs, translate const& rhs) noexcept
    {
        if (lhs._has_args != rhs._has_args) {
            return false;
        }
 
        if (lhs._has_args and *lhs._args != *rhs._args) {
            return false;
        }
 
        return lhs._msg_id == rhs._msg_id;
    }
 
private:
    std::string _msg_id;
    std::unique_ptr<detail::translate_args_base> _args;
    // Technically we could check _args for nullptr. However to get this working
    // with constexpr constructor we need a way to disable the std::unique_ptr.
    bool _has_args;
};
 
using tr = translate;
 
} // namespace hi::inline v1