Line data    Source code

       1             : // Copyright (c) 2019-2022 The Bitcoin Core developers
       2             : // Distributed under the MIT software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #ifndef BITCOIN_UTIL_TRANSLATION_H
       6             : #define BITCOIN_UTIL_TRANSLATION_H
       7             : 
       8             : #include <tinyformat.h>
       9             : 
      10             : #include <functional>
      11             : #include <string>
      12             : 
      13             : /**
      14             :  * Bilingual messages:
      15             :  *   - in GUI: user's native language + untranslated (i.e. English)
      16             :  *   - in log and stderr: untranslated only
      17             :  */
      18        1466 : struct bilingual_str {
      19             :     std::string original;
      20             :     std::string translated;
      21             : 
      22           0 :     bilingual_str& operator+=(const bilingual_str& rhs)
      23             :     {
      24           0 :         original += rhs.original;
      25           0 :         translated += rhs.translated;
      26           0 :         return *this;
      27             :     }
      28             : 
      29         146 :     bool empty() const
      30             :     {
      31         146 :         return original.empty();
      32             :     }
      33             : 
      34             :     void clear()
      35             :     {
      36             :         original.clear();
      37             :         translated.clear();
      38             :     }
      39             : };
      40             : 
      41           0 : inline bilingual_str operator+(bilingual_str lhs, const bilingual_str& rhs)
      42             : {
      43           0 :     lhs += rhs;
      44           0 :     return lhs;
      45             : }
      46             : 
      47             : /** Mark a bilingual_str as untranslated */
      48        1200 : inline bilingual_str Untranslated(std::string original) { return {original, original}; }
      49             : 
      50             : // Provide an overload of tinyformat::format which can take bilingual_str arguments.
      51             : namespace tinyformat {
      52             : template <typename... Args>
      53           0 : bilingual_str format(const bilingual_str& fmt, const Args&... args)
      54             : {
      55           0 :     const auto translate_arg{[](const auto& arg, bool translated) -> const auto& {
      56             :         if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
      57           0 :             return translated ? arg.translated : arg.original;
      58             :         } else {
      59           0 :             return arg;
      60             :         }
      61             :     }};
      62           0 :     return bilingual_str{tfm::format(fmt.original, translate_arg(args, false)...),
      63           0 :                          tfm::format(fmt.translated, translate_arg(args, true)...)};
      64           0 : }
      65             : } // namespace tinyformat
      66             : 
      67             : /** Translate a message to the native language of the user. */
      68             : const extern std::function<std::string(const char*)> G_TRANSLATION_FUN;
      69             : 
      70             : /**
      71             :  * Translation function.
      72             :  * If no translation function is set, simply return the input.
      73             :  */
      74           0 : inline bilingual_str _(const char* psz)
      75             : {
      76           0 :     return bilingual_str{psz, G_TRANSLATION_FUN ? (G_TRANSLATION_FUN)(psz) : psz};
      77           0 : }
      78             : 
      79             : #endif // BITCOIN_UTIL_TRANSLATION_H