Coverage Report

Created: 2026-04-29 19:21

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/tmp/bitcoin/src/util/translation.h
Line
Count
Source
1
// Copyright (c) 2019-present 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
#include <util/check.h>
10
#include <util/string.h>
11
12
#include <functional>
13
#include <string>
14
15
/** Translate a message to the native language of the user. */
16
using TranslateFn = std::function<std::string(const char*)>;
17
const extern TranslateFn G_TRANSLATION_FUN;
18
19
/**
20
 * Bilingual messages:
21
 *   - in GUI: user's native language + untranslated (i.e. English)
22
 *   - in log and stderr: untranslated only
23
 */
24
struct bilingual_str {
25
    std::string original;
26
    std::string translated;
27
28
    bilingual_str& operator+=(const bilingual_str& rhs)
29
315
    {
30
315
        original += rhs.original;
31
315
        translated += rhs.translated;
32
315
        return *this;
33
315
    }
34
35
    bool empty() const
36
17.9k
    {
37
17.9k
        return original.empty();
38
17.9k
    }
39
40
    void clear()
41
0
    {
42
0
        original.clear();
43
0
        translated.clear();
44
0
    }
45
};
46
47
inline bilingual_str operator+(bilingual_str lhs, const bilingual_str& rhs)
48
146
{
49
146
    lhs += rhs;
50
146
    return lhs;
51
146
}
52
53
namespace util {
54
//! Compile-time literal string that can be translated with an optional translation function.
55
struct TranslatedLiteral {
56
    const char* const original;
57
    const TranslateFn* translate_fn;
58
59
0
    consteval TranslatedLiteral(const char* str, const TranslateFn* fn = &G_TRANSLATION_FUN) : original{str}, translate_fn{fn} { assert(original); }
60
19.3k
    operator std::string() const { return translate_fn && *translate_fn ? (*translate_fn)(original) : original; }
61
9.17k
    operator bilingual_str() const { return {original, std::string{*this}}; }
62
};
63
64
// TranslatedLiteral operators for formatting and adding to strings.
65
2.19k
inline std::ostream& operator<<(std::ostream& os, const TranslatedLiteral& lit) { return os << std::string{lit}; }
66
template<typename T>
67
26
T operator+(const T& lhs, const TranslatedLiteral& rhs) { return lhs + static_cast<T>(rhs); }
bilingual_str util::operator+<bilingual_str>(bilingual_str const&, util::TranslatedLiteral const&)
Line
Count
Source
67
18
T operator+(const T& lhs, const TranslatedLiteral& rhs) { return lhs + static_cast<T>(rhs); }
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::operator+<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, util::TranslatedLiteral const&)
Line
Count
Source
67
8
T operator+(const T& lhs, const TranslatedLiteral& rhs) { return lhs + static_cast<T>(rhs); }
68
template<typename T>
69
15
T operator+(const TranslatedLiteral& lhs, const T& rhs) { return static_cast<T>(lhs) + rhs; }
70
71
template <unsigned num_params>
72
struct BilingualFmt {
73
    const ConstevalFormatString<num_params> original;
74
    TranslatedLiteral lit;
75
    consteval BilingualFmt(TranslatedLiteral l) : original{l.original}, lit{l} {}
76
};
77
} // namespace util
78
79
consteval auto _(util::TranslatedLiteral str) { return str; }
80
81
/** Mark a bilingual_str as untranslated */
82
166k
inline bilingual_str Untranslated(std::string original) { return {original, original}; }
83
84
// Provide an overload of tinyformat::format for BilingualFmt format strings and bilingual_str or TranslatedLiteral args.
85
namespace tinyformat {
86
template <typename... Args>
87
bilingual_str format(util::BilingualFmt<sizeof...(Args)> fmt, const Args&... args)
88
417
{
89
590
    const auto original_arg{[](const auto& arg) -> const auto& {
90
590
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
10
            return arg.original;
92
10
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
579
        } else {
95
579
            return arg;
96
579
        }
97
590
    }};
auto const& bilingual_str tinyformat::format<bilingual_str>(util::BilingualFmt<sizeof...(bilingual_str)>, bilingual_str const&)::'lambda'(auto const&)::operator()<bilingual_str>(auto const&) const
Line
Count
Source
89
7
    const auto original_arg{[](const auto& arg) -> const auto& {
90
7
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
7
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
        } else {
95
            return arg;
96
        }
97
7
    }};
auto const& bilingual_str tinyformat::format<util::TranslatedLiteral>(util::BilingualFmt<sizeof...(util::TranslatedLiteral)>, util::TranslatedLiteral const&)::'lambda'(auto const&)::operator()<util::TranslatedLiteral>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
        } else {
95
            return arg;
96
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, char const* const&, char const (&) [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda'(auto const&)::operator()<char const*>(auto const&) const
Line
Count
Source
89
9
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
9
        } else {
95
9
            return arg;
96
9
        }
97
9
    }};
auto const& bilingual_str tinyformat::format<char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, char const* const&, char const (&) [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda'(auto const&)::operator()<char [42]>(auto const&) const
Line
Count
Source
89
9
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
9
        } else {
95
9
            return arg;
96
9
        }
97
9
    }};
auto const& bilingual_str tinyformat::format<char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, char const* const&, char const (&) [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda'(auto const&)::operator()<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(auto const&) const
Line
Count
Source
89
9
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
9
        } else {
95
9
            return arg;
96
9
        }
97
9
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13]>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13])>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [13])::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13]>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13])>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [13])::'lambda'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char const*, unsigned short>(util::BilingualFmt<sizeof...(char const*, unsigned short)>, char const* const&, unsigned short const&)::'lambda'(auto const&)::operator()<char const*>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char const*, unsigned short>(util::BilingualFmt<sizeof...(char const*, unsigned short)>, char const* const&, unsigned short const&)::'lambda'(auto const&)::operator()<unsigned short>(auto const&) const
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
80
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
80
        } else {
95
80
            return arg;
96
80
        }
97
80
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
109
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
109
        } else {
95
109
            return arg;
96
109
        }
97
109
    }};
auto const& bilingual_str tinyformat::format<int, int>(util::BilingualFmt<sizeof...(int, int)>, int const&, int const&)::'lambda'(auto const&)::operator()<int>(auto const&) const
Line
Count
Source
89
22
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
22
        } else {
95
22
            return arg;
96
22
        }
97
22
    }};
auto const& bilingual_str tinyformat::format<long, unsigned int>(util::BilingualFmt<sizeof...(long, unsigned int)>, long const&, unsigned int const&)::'lambda'(auto const&)::operator()<long>(auto const&) const
Line
Count
Source
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
auto const& bilingual_str tinyformat::format<long, unsigned int>(util::BilingualFmt<sizeof...(long, unsigned int)>, long const&, unsigned int const&)::'lambda'(auto const&)::operator()<unsigned int>(auto const&) const
Line
Count
Source
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
auto const& bilingual_str tinyformat::format<char [13]>(util::BilingualFmt<sizeof...(char [13])>, char const (&) [13])::'lambda'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
89
14
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
14
        } else {
95
14
            return arg;
96
14
        }
97
14
    }};
auto const& bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda'(auto const&)::operator()<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(auto const&) const
Line
Count
Source
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
auto const& bilingual_str tinyformat::format<unsigned long, unsigned int>(util::BilingualFmt<sizeof...(unsigned long, unsigned int)>, unsigned long const&, unsigned int const&)::'lambda'(auto const&)::operator()<unsigned long>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<unsigned long, unsigned int>(util::BilingualFmt<sizeof...(unsigned long, unsigned int)>, unsigned long const&, unsigned int const&)::'lambda'(auto const&)::operator()<unsigned int>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&, unsigned long const&)::'lambda'(auto const&)::operator()<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&, unsigned long const&)::'lambda'(auto const&)::operator()<unsigned long>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bilingual_str const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bilingual_str const&)::'lambda'(auto const&)::operator()<bilingual_str>(auto const&) const
Line
Count
Source
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
3
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
        } else {
95
            return arg;
96
        }
97
3
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<unsigned long>(util::BilingualFmt<sizeof...(unsigned long)>, unsigned long const&)::'lambda'(auto const&)::operator()<unsigned long>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<unsigned long, unsigned long>(util::BilingualFmt<sizeof...(unsigned long, unsigned long)>, unsigned long const&, unsigned long const&)::'lambda'(auto const&)::operator()<unsigned long>(auto const&) const
auto const& bilingual_str tinyformat::format<int>(util::BilingualFmt<sizeof...(int)>, int const&)::'lambda'(auto const&)::operator()<int>(auto const&) const
Line
Count
Source
89
154
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
154
        } else {
95
154
            return arg;
96
154
        }
97
154
    }};
auto const& bilingual_str tinyformat::format<long>(util::BilingualFmt<sizeof...(long)>, long const&)::'lambda'(auto const&)::operator()<long>(auto const&) const
Line
Count
Source
89
11
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
11
        } else {
95
11
            return arg;
96
11
        }
97
11
    }};
auto const& bilingual_str tinyformat::format<double>(util::BilingualFmt<sizeof...(double)>, double const&)::'lambda'(auto const&)::operator()<double>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char [13], int, int, int, char [42]>(util::BilingualFmt<sizeof...(char [13], int, int, int, char [42])>, char const (&) [13], int const&, int const&, int const&, char const (&) [42])::'lambda'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char [13], int, int, int, char [42]>(util::BilingualFmt<sizeof...(char [13], int, int, int, char [42])>, char const (&) [13], int const&, int const&, int const&, char const (&) [42])::'lambda'(auto const&)::operator()<int>(auto const&) const
Line
Count
Source
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
auto const& bilingual_str tinyformat::format<char [13], int, int, int, char [42]>(util::BilingualFmt<sizeof...(char [13], int, int, int, char [42])>, char const (&) [13], int const&, int const&, int const&, char const (&) [42])::'lambda'(auto const&)::operator()<char [42]>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char const*>(util::BilingualFmt<sizeof...(char const*)>, char const* const&)::'lambda'(auto const&)::operator()<char const*>(auto const&) const
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [10]>(auto const&) const
Line
Count
Source
89
21
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
21
        } else {
95
21
            return arg;
96
21
        }
97
21
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
42
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
42
        } else {
95
42
            return arg;
96
42
        }
97
42
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [15]>(auto const&) const
Line
Count
Source
89
21
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
21
        } else {
95
21
            return arg;
96
21
        }
97
21
    }};
auto const& bilingual_str tinyformat::format<unsigned int>(util::BilingualFmt<sizeof...(unsigned int)>, unsigned int const&)::'lambda'(auto const&)::operator()<unsigned int>(auto const&) const
Line
Count
Source
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<unsigned int, unsigned int>(util::BilingualFmt<sizeof...(unsigned int, unsigned int)>, unsigned int const&, unsigned int const&)::'lambda'(auto const&)::operator()<unsigned int>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [13]>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [12]>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [10]>(util::BilingualFmt<sizeof...(char [10])>, char const (&) [10])::'lambda'(auto const&)::operator()<char [10]>(auto const&) const
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [10]>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [10]>(auto const&) const
Line
Count
Source
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
6
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
6
        } else {
95
6
            return arg;
96
6
        }
97
6
    }};
auto const& bilingual_str tinyformat::format<char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [7]>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<char [14]>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
auto const& bilingual_str tinyformat::format<char [13], char [27]>(util::BilingualFmt<sizeof...(char [13], char [27])>, char const (&) [13], char const (&) [27])::'lambda'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
89
8
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
8
        } else {
95
8
            return arg;
96
8
        }
97
8
    }};
auto const& bilingual_str tinyformat::format<char [13], char [27]>(util::BilingualFmt<sizeof...(char [13], char [27])>, char const (&) [13], char const (&) [27])::'lambda'(auto const&)::operator()<char [27]>(auto const&) const
Line
Count
Source
89
8
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
8
        } else {
95
8
            return arg;
96
8
        }
97
8
    }};
auto const& bilingual_str tinyformat::format<char [8], char [37]>(util::BilingualFmt<sizeof...(char [8], char [37])>, char const (&) [8], char const (&) [37])::'lambda'(auto const&)::operator()<char [8]>(auto const&) const
Line
Count
Source
89
8
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
8
        } else {
95
8
            return arg;
96
8
        }
97
8
    }};
auto const& bilingual_str tinyformat::format<char [8], char [37]>(util::BilingualFmt<sizeof...(char [8], char [37])>, char const (&) [8], char const (&) [37])::'lambda'(auto const&)::operator()<char [37]>(auto const&) const
Line
Count
Source
89
8
    const auto original_arg{[](const auto& arg) -> const auto& {
90
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
            return arg.original;
92
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
            return arg.original;
94
8
        } else {
95
8
            return arg;
96
8
        }
97
8
    }};
98
590
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
590
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
10
            return arg.translated;
101
580
        } else {
102
580
            return arg;
103
580
        }
104
590
    }};
auto const& bilingual_str tinyformat::format<bilingual_str>(util::BilingualFmt<sizeof...(bilingual_str)>, bilingual_str const&)::'lambda0'(auto const&)::operator()<bilingual_str>(auto const&) const
Line
Count
Source
98
7
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
7
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
7
            return arg.translated;
101
        } else {
102
            return arg;
103
        }
104
7
    }};
auto const& bilingual_str tinyformat::format<util::TranslatedLiteral>(util::BilingualFmt<sizeof...(util::TranslatedLiteral)>, util::TranslatedLiteral const&)::'lambda0'(auto const&)::operator()<util::TranslatedLiteral>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, char const* const&, char const (&) [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda0'(auto const&)::operator()<char const*>(auto const&) const
Line
Count
Source
98
9
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
9
        } else {
102
9
            return arg;
103
9
        }
104
9
    }};
auto const& bilingual_str tinyformat::format<char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, char const* const&, char const (&) [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda0'(auto const&)::operator()<char [42]>(auto const&) const
Line
Count
Source
98
9
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
9
        } else {
102
9
            return arg;
103
9
        }
104
9
    }};
auto const& bilingual_str tinyformat::format<char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, char const* const&, char const (&) [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda0'(auto const&)::operator()<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(auto const&) const
Line
Count
Source
98
9
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
9
        } else {
102
9
            return arg;
103
9
        }
104
9
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13]>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13])>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [13])::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13]>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13])>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [13])::'lambda0'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char const*, unsigned short>(util::BilingualFmt<sizeof...(char const*, unsigned short)>, char const* const&, unsigned short const&)::'lambda0'(auto const&)::operator()<char const*>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char const*, unsigned short>(util::BilingualFmt<sizeof...(char const*, unsigned short)>, char const* const&, unsigned short const&)::'lambda0'(auto const&)::operator()<unsigned short>(auto const&) const
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
80
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
80
        } else {
102
80
            return arg;
103
80
        }
104
80
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
109
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
109
        } else {
102
109
            return arg;
103
109
        }
104
109
    }};
auto const& bilingual_str tinyformat::format<int, int>(util::BilingualFmt<sizeof...(int, int)>, int const&, int const&)::'lambda0'(auto const&)::operator()<int>(auto const&) const
Line
Count
Source
98
22
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
22
        } else {
102
22
            return arg;
103
22
        }
104
22
    }};
auto const& bilingual_str tinyformat::format<long, unsigned int>(util::BilingualFmt<sizeof...(long, unsigned int)>, long const&, unsigned int const&)::'lambda0'(auto const&)::operator()<long>(auto const&) const
Line
Count
Source
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
auto const& bilingual_str tinyformat::format<long, unsigned int>(util::BilingualFmt<sizeof...(long, unsigned int)>, long const&, unsigned int const&)::'lambda0'(auto const&)::operator()<unsigned int>(auto const&) const
Line
Count
Source
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
auto const& bilingual_str tinyformat::format<char [13]>(util::BilingualFmt<sizeof...(char [13])>, char const (&) [13])::'lambda0'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
98
14
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
14
        } else {
102
14
            return arg;
103
14
        }
104
14
    }};
auto const& bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)::'lambda0'(auto const&)::operator()<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(auto const&) const
Line
Count
Source
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
auto const& bilingual_str tinyformat::format<unsigned long, unsigned int>(util::BilingualFmt<sizeof...(unsigned long, unsigned int)>, unsigned long const&, unsigned int const&)::'lambda0'(auto const&)::operator()<unsigned long>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<unsigned long, unsigned int>(util::BilingualFmt<sizeof...(unsigned long, unsigned int)>, unsigned long const&, unsigned int const&)::'lambda0'(auto const&)::operator()<unsigned int>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&, unsigned long const&)::'lambda0'(auto const&)::operator()<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&, unsigned long const&)::'lambda0'(auto const&)::operator()<unsigned long>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bilingual_str const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
auto const& bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bilingual_str const&)::'lambda0'(auto const&)::operator()<bilingual_str>(auto const&) const
Line
Count
Source
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
3
            return arg.translated;
101
        } else {
102
            return arg;
103
        }
104
3
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<unsigned long>(util::BilingualFmt<sizeof...(unsigned long)>, unsigned long const&)::'lambda0'(auto const&)::operator()<unsigned long>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<unsigned long, unsigned long>(util::BilingualFmt<sizeof...(unsigned long, unsigned long)>, unsigned long const&, unsigned long const&)::'lambda0'(auto const&)::operator()<unsigned long>(auto const&) const
auto const& bilingual_str tinyformat::format<int>(util::BilingualFmt<sizeof...(int)>, int const&)::'lambda0'(auto const&)::operator()<int>(auto const&) const
Line
Count
Source
98
154
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
154
        } else {
102
154
            return arg;
103
154
        }
104
154
    }};
auto const& bilingual_str tinyformat::format<long>(util::BilingualFmt<sizeof...(long)>, long const&)::'lambda0'(auto const&)::operator()<long>(auto const&) const
Line
Count
Source
98
11
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
11
        } else {
102
11
            return arg;
103
11
        }
104
11
    }};
auto const& bilingual_str tinyformat::format<double>(util::BilingualFmt<sizeof...(double)>, double const&)::'lambda0'(auto const&)::operator()<double>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char [13], int, int, int, char [42]>(util::BilingualFmt<sizeof...(char [13], int, int, int, char [42])>, char const (&) [13], int const&, int const&, int const&, char const (&) [42])::'lambda0'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char [13], int, int, int, char [42]>(util::BilingualFmt<sizeof...(char [13], int, int, int, char [42])>, char const (&) [13], int const&, int const&, int const&, char const (&) [42])::'lambda0'(auto const&)::operator()<int>(auto const&) const
Line
Count
Source
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
auto const& bilingual_str tinyformat::format<char [13], int, int, int, char [42]>(util::BilingualFmt<sizeof...(char [13], int, int, int, char [42])>, char const (&) [13], int const&, int const&, int const&, char const (&) [42])::'lambda0'(auto const&)::operator()<char [42]>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char const*>(util::BilingualFmt<sizeof...(char const*)>, char const* const&)::'lambda0'(auto const&)::operator()<char const*>(auto const&) const
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [10]>(auto const&) const
Line
Count
Source
98
21
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
21
        } else {
102
21
            return arg;
103
21
        }
104
21
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
42
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
42
        } else {
102
42
            return arg;
103
42
        }
104
42
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [15]>(auto const&) const
Line
Count
Source
98
21
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
21
        } else {
102
21
            return arg;
103
21
        }
104
21
    }};
auto const& bilingual_str tinyformat::format<unsigned int>(util::BilingualFmt<sizeof...(unsigned int)>, unsigned int const&)::'lambda0'(auto const&)::operator()<unsigned int>(auto const&) const
Line
Count
Source
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<unsigned int, unsigned int>(util::BilingualFmt<sizeof...(unsigned int, unsigned int)>, unsigned int const&, unsigned int const&)::'lambda0'(auto const&)::operator()<unsigned int>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [13]>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [12]>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Unexecuted instantiation: auto const& bilingual_str tinyformat::format<char [10]>(util::BilingualFmt<sizeof...(char [10])>, char const (&) [10])::'lambda0'(auto const&)::operator()<char [10]>(auto const&) const
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [10]>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [10]>(auto const&) const
Line
Count
Source
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
auto const& bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
6
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
6
        } else {
102
6
            return arg;
103
6
        }
104
6
    }};
auto const& bilingual_str tinyformat::format<char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [7]>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<char [14]>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda0'(auto const&)::operator()<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(auto const&) const
Line
Count
Source
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
auto const& bilingual_str tinyformat::format<char [13], char [27]>(util::BilingualFmt<sizeof...(char [13], char [27])>, char const (&) [13], char const (&) [27])::'lambda0'(auto const&)::operator()<char [13]>(auto const&) const
Line
Count
Source
98
8
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
8
        } else {
102
8
            return arg;
103
8
        }
104
8
    }};
auto const& bilingual_str tinyformat::format<char [13], char [27]>(util::BilingualFmt<sizeof...(char [13], char [27])>, char const (&) [13], char const (&) [27])::'lambda0'(auto const&)::operator()<char [27]>(auto const&) const
Line
Count
Source
98
8
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
8
        } else {
102
8
            return arg;
103
8
        }
104
8
    }};
auto const& bilingual_str tinyformat::format<char [8], char [37]>(util::BilingualFmt<sizeof...(char [8], char [37])>, char const (&) [8], char const (&) [37])::'lambda0'(auto const&)::operator()<char [8]>(auto const&) const
Line
Count
Source
98
8
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
8
        } else {
102
8
            return arg;
103
8
        }
104
8
    }};
auto const& bilingual_str tinyformat::format<char [8], char [37]>(util::BilingualFmt<sizeof...(char [8], char [37])>, char const (&) [8], char const (&) [37])::'lambda0'(auto const&)::operator()<char [37]>(auto const&) const
Line
Count
Source
98
8
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
            return arg.translated;
101
8
        } else {
102
8
            return arg;
103
8
        }
104
8
    }};
105
417
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
417
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
417
}
bilingual_str tinyformat::format<bilingual_str>(util::BilingualFmt<sizeof...(bilingual_str)>, bilingual_str const&)
Line
Count
Source
88
7
{
89
7
    const auto original_arg{[](const auto& arg) -> const auto& {
90
7
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
7
            return arg.original;
92
7
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
7
            return arg.original;
94
7
        } else {
95
7
            return arg;
96
7
        }
97
7
    }};
98
7
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
7
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
7
            return arg.translated;
101
7
        } else {
102
7
            return arg;
103
7
        }
104
7
    }};
105
7
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
7
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
7
}
bilingual_str tinyformat::format<util::TranslatedLiteral>(util::BilingualFmt<sizeof...(util::TranslatedLiteral)>, util::TranslatedLiteral const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<>(util::BilingualFmt<sizeof...()>)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(char const*, char [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, char const* const&, char const (&) [42], std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)
Line
Count
Source
88
9
{
89
9
    const auto original_arg{[](const auto& arg) -> const auto& {
90
9
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
9
            return arg.original;
92
9
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
9
            return arg.original;
94
9
        } else {
95
9
            return arg;
96
9
        }
97
9
    }};
98
9
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
9
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
9
            return arg.translated;
101
9
        } else {
102
9
            return arg;
103
9
        }
104
9
    }};
105
9
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
9
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
9
}
bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13]>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [13])>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [13])
Line
Count
Source
88
2
{
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
2
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
2
            return arg.original;
92
2
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
2
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
2
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
2
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
105
2
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
2
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
2
}
Unexecuted instantiation: bilingual_str tinyformat::format<char const*, unsigned short>(util::BilingualFmt<sizeof...(char const*, unsigned short)>, char const* const&, unsigned short const&)
bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
40
{
89
40
    const auto original_arg{[](const auto& arg) -> const auto& {
90
40
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
40
            return arg.original;
92
40
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
40
            return arg.original;
94
40
        } else {
95
40
            return arg;
96
40
        }
97
40
    }};
98
40
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
40
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
40
            return arg.translated;
101
40
        } else {
102
40
            return arg;
103
40
        }
104
40
    }};
105
40
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
40
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
40
}
bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
109
{
89
109
    const auto original_arg{[](const auto& arg) -> const auto& {
90
109
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
109
            return arg.original;
92
109
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
109
            return arg.original;
94
109
        } else {
95
109
            return arg;
96
109
        }
97
109
    }};
98
109
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
109
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
109
            return arg.translated;
101
109
        } else {
102
109
            return arg;
103
109
        }
104
109
    }};
105
109
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
109
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
109
}
bilingual_str tinyformat::format<int, int>(util::BilingualFmt<sizeof...(int, int)>, int const&, int const&)
Line
Count
Source
88
11
{
89
11
    const auto original_arg{[](const auto& arg) -> const auto& {
90
11
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
11
            return arg.original;
92
11
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
11
            return arg.original;
94
11
        } else {
95
11
            return arg;
96
11
        }
97
11
    }};
98
11
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
11
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
11
            return arg.translated;
101
11
        } else {
102
11
            return arg;
103
11
        }
104
11
    }};
105
11
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
11
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
11
}
bilingual_str tinyformat::format<long, unsigned int>(util::BilingualFmt<sizeof...(long, unsigned int)>, long const&, unsigned int const&)
Line
Count
Source
88
3
{
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
3
            return arg.original;
92
3
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
3
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
3
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
105
3
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
3
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
3
}
bilingual_str tinyformat::format<char [13]>(util::BilingualFmt<sizeof...(char [13])>, char const (&) [13])
Line
Count
Source
88
14
{
89
14
    const auto original_arg{[](const auto& arg) -> const auto& {
90
14
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
14
            return arg.original;
92
14
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
14
            return arg.original;
94
14
        } else {
95
14
            return arg;
96
14
        }
97
14
    }};
98
14
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
14
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
14
            return arg.translated;
101
14
        } else {
102
14
            return arg;
103
14
        }
104
14
    }};
105
14
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
14
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
14
}
bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&)
Line
Count
Source
88
2
{
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
2
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
2
            return arg.original;
92
2
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
2
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
2
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
2
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
105
2
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
2
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
2
}
bilingual_str tinyformat::format<unsigned long, unsigned int>(util::BilingualFmt<sizeof...(unsigned long, unsigned int)>, unsigned long const&, unsigned int const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long>(util::BilingualFmt<sizeof...(std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char>, unsigned long)>, std::__detail::_Quoted_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char> const&, unsigned long const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str>(util::BilingualFmt<sizeof...(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bilingual_str)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bilingual_str const&)
Line
Count
Source
88
3
{
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
3
            return arg.original;
92
3
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
3
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
3
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
105
3
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
3
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
3
}
Unexecuted instantiation: bilingual_str tinyformat::format<unsigned long>(util::BilingualFmt<sizeof...(unsigned long)>, unsigned long const&)
Unexecuted instantiation: bilingual_str tinyformat::format<unsigned long, unsigned long>(util::BilingualFmt<sizeof...(unsigned long, unsigned long)>, unsigned long const&, unsigned long const&)
bilingual_str tinyformat::format<int>(util::BilingualFmt<sizeof...(int)>, int const&)
Line
Count
Source
88
154
{
89
154
    const auto original_arg{[](const auto& arg) -> const auto& {
90
154
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
154
            return arg.original;
92
154
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
154
            return arg.original;
94
154
        } else {
95
154
            return arg;
96
154
        }
97
154
    }};
98
154
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
154
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
154
            return arg.translated;
101
154
        } else {
102
154
            return arg;
103
154
        }
104
154
    }};
105
154
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
154
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
154
}
bilingual_str tinyformat::format<long>(util::BilingualFmt<sizeof...(long)>, long const&)
Line
Count
Source
88
11
{
89
11
    const auto original_arg{[](const auto& arg) -> const auto& {
90
11
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
11
            return arg.original;
92
11
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
11
            return arg.original;
94
11
        } else {
95
11
            return arg;
96
11
        }
97
11
    }};
98
11
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
11
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
11
            return arg.translated;
101
11
        } else {
102
11
            return arg;
103
11
        }
104
11
    }};
105
11
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
11
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
11
}
bilingual_str tinyformat::format<double>(util::BilingualFmt<sizeof...(double)>, double const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<char [13], int, int, int, char [42]>(util::BilingualFmt<sizeof...(char [13], int, int, int, char [42])>, char const (&) [13], int const&, int const&, int const&, char const (&) [42])
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
Unexecuted instantiation: bilingual_str tinyformat::format<char const*>(util::BilingualFmt<sizeof...(char const*)>, char const* const&)
bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [15], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
21
{
89
21
    const auto original_arg{[](const auto& arg) -> const auto& {
90
21
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
21
            return arg.original;
92
21
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
21
            return arg.original;
94
21
        } else {
95
21
            return arg;
96
21
        }
97
21
    }};
98
21
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
21
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
21
            return arg.translated;
101
21
        } else {
102
21
            return arg;
103
21
        }
104
21
    }};
105
21
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
21
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
21
}
bilingual_str tinyformat::format<unsigned int>(util::BilingualFmt<sizeof...(unsigned int)>, unsigned int const&)
Line
Count
Source
88
3
{
89
3
    const auto original_arg{[](const auto& arg) -> const auto& {
90
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
3
            return arg.original;
92
3
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
3
            return arg.original;
94
3
        } else {
95
3
            return arg;
96
3
        }
97
3
    }};
98
3
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
3
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
3
            return arg.translated;
101
3
        } else {
102
3
            return arg;
103
3
        }
104
3
    }};
105
3
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
3
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
3
}
Unexecuted instantiation: bilingual_str tinyformat::format<unsigned int, unsigned int>(util::BilingualFmt<sizeof...(unsigned int, unsigned int)>, unsigned int const&, unsigned int const&)
Unexecuted instantiation: bilingual_str tinyformat::format<char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [13], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Unexecuted instantiation: bilingual_str tinyformat::format<char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [12], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Unexecuted instantiation: bilingual_str tinyformat::format<char [10]>(util::BilingualFmt<sizeof...(char [10])>, char const (&) [10])
bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
2
{
89
2
    const auto original_arg{[](const auto& arg) -> const auto& {
90
2
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
2
            return arg.original;
92
2
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
2
            return arg.original;
94
2
        } else {
95
2
            return arg;
96
2
        }
97
2
    }};
98
2
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
2
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
2
            return arg.translated;
101
2
        } else {
102
2
            return arg;
103
2
        }
104
2
    }};
105
2
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
2
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
2
}
bilingual_str tinyformat::format<char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [7], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(util::BilingualFmt<sizeof...(char [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>, char const (&) [14], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
88
1
{
89
1
    const auto original_arg{[](const auto& arg) -> const auto& {
90
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
1
            return arg.original;
92
1
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
1
            return arg.original;
94
1
        } else {
95
1
            return arg;
96
1
        }
97
1
    }};
98
1
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
1
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
1
            return arg.translated;
101
1
        } else {
102
1
            return arg;
103
1
        }
104
1
    }};
105
1
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
1
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
1
}
bilingual_str tinyformat::format<char [13], char [27]>(util::BilingualFmt<sizeof...(char [13], char [27])>, char const (&) [13], char const (&) [27])
Line
Count
Source
88
8
{
89
8
    const auto original_arg{[](const auto& arg) -> const auto& {
90
8
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
8
            return arg.original;
92
8
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
8
            return arg.original;
94
8
        } else {
95
8
            return arg;
96
8
        }
97
8
    }};
98
8
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
8
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
8
            return arg.translated;
101
8
        } else {
102
8
            return arg;
103
8
        }
104
8
    }};
105
8
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
8
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
8
}
bilingual_str tinyformat::format<char [8], char [37]>(util::BilingualFmt<sizeof...(char [8], char [37])>, char const (&) [8], char const (&) [37])
Line
Count
Source
88
8
{
89
8
    const auto original_arg{[](const auto& arg) -> const auto& {
90
8
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
91
8
            return arg.original;
92
8
        } else if constexpr (std::is_same_v<decltype(arg), const util::TranslatedLiteral&>) {
93
8
            return arg.original;
94
8
        } else {
95
8
            return arg;
96
8
        }
97
8
    }};
98
8
    const auto translated_arg{[](const auto& arg) -> const auto& {
99
8
        if constexpr (std::is_same_v<decltype(arg), const bilingual_str&>) {
100
8
            return arg.translated;
101
8
        } else {
102
8
            return arg;
103
8
        }
104
8
    }};
105
8
    return bilingual_str{tfm::format(fmt.original, original_arg(args)...),
106
8
                         tfm::format(RuntimeFormat{std::string{fmt.lit}}, translated_arg(args)...)};
107
8
}
108
} // namespace tinyformat
109
110
#endif // BITCOIN_UTIL_TRANSLATION_H