1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/i18n/message_formatter.h"
#include "base/check.h"
#include "base/i18n/unicodestring.h"
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
#include "base/time/time.h"
#include "third_party/icu/source/common/unicode/unistr.h"
#include "third_party/icu/source/common/unicode/utypes.h"
#include "third_party/icu/source/i18n/unicode/fmtable.h"
#include "third_party/icu/source/i18n/unicode/msgfmt.h"
using icu::UnicodeString;
namespace base {
namespace i18n {
namespace {
UnicodeString UnicodeStringFromStringPiece(StringPiece str) {
return UnicodeString::fromUTF8(
icu::StringPiece(str.data(), base::checked_cast<int32_t>(str.size())));
}
} // anonymous namespace
namespace internal {
MessageArg::MessageArg() : formattable(nullptr) {}
MessageArg::MessageArg(const char* s)
: formattable(new icu::Formattable(UnicodeStringFromStringPiece(s))) {}
MessageArg::MessageArg(StringPiece s)
: formattable(new icu::Formattable(UnicodeStringFromStringPiece(s))) {}
MessageArg::MessageArg(const std::string& s)
: formattable(new icu::Formattable(UnicodeString::fromUTF8(s))) {}
MessageArg::MessageArg(const std::u16string& s)
: formattable(new icu::Formattable(UnicodeString(s.data(), s.size()))) {}
MessageArg::MessageArg(int i) : formattable(new icu::Formattable(i)) {}
MessageArg::MessageArg(int64_t i) : formattable(new icu::Formattable(i)) {}
MessageArg::MessageArg(double d) : formattable(new icu::Formattable(d)) {}
MessageArg::MessageArg(const Time& t)
: formattable(new icu::Formattable(
static_cast<UDate>(t.InMillisecondsFSinceUnixEpoch()))) {}
MessageArg::~MessageArg() = default;
// Tests if this argument has a value, and if so increments *count.
bool MessageArg::has_value(int *count) const {
if (formattable == nullptr)
return false;
++*count;
return true;
}
} // namespace internal
std::u16string MessageFormatter::FormatWithNumberedArgs(
StringPiece16 msg,
const internal::MessageArg& arg0,
const internal::MessageArg& arg1,
const internal::MessageArg& arg2,
const internal::MessageArg& arg3,
const internal::MessageArg& arg4,
const internal::MessageArg& arg5,
const internal::MessageArg& arg6) {
int32_t args_count = 0;
icu::Formattable args[] = {
arg0.has_value(&args_count) ? *arg0.formattable : icu::Formattable(),
arg1.has_value(&args_count) ? *arg1.formattable : icu::Formattable(),
arg2.has_value(&args_count) ? *arg2.formattable : icu::Formattable(),
arg3.has_value(&args_count) ? *arg3.formattable : icu::Formattable(),
arg4.has_value(&args_count) ? *arg4.formattable : icu::Formattable(),
arg5.has_value(&args_count) ? *arg5.formattable : icu::Formattable(),
arg6.has_value(&args_count) ? *arg6.formattable : icu::Formattable(),
};
UnicodeString msg_string(msg.data(), msg.size());
UErrorCode error = U_ZERO_ERROR;
icu::MessageFormat format(msg_string, error);
icu::UnicodeString formatted;
icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
format.format(args, args_count, formatted, ignore, error);
if (U_FAILURE(error)) {
LOG(ERROR) << "MessageFormat(" << msg << ") failed with "
<< u_errorName(error);
return std::u16string();
}
return i18n::UnicodeStringToString16(formatted);
}
std::u16string MessageFormatter::FormatWithNamedArgs(
StringPiece16 msg,
StringPiece name0,
const internal::MessageArg& arg0,
StringPiece name1,
const internal::MessageArg& arg1,
StringPiece name2,
const internal::MessageArg& arg2,
StringPiece name3,
const internal::MessageArg& arg3,
StringPiece name4,
const internal::MessageArg& arg4,
StringPiece name5,
const internal::MessageArg& arg5,
StringPiece name6,
const internal::MessageArg& arg6) {
icu::UnicodeString names[] = {
UnicodeStringFromStringPiece(name0),
UnicodeStringFromStringPiece(name1),
UnicodeStringFromStringPiece(name2),
UnicodeStringFromStringPiece(name3),
UnicodeStringFromStringPiece(name4),
UnicodeStringFromStringPiece(name5),
UnicodeStringFromStringPiece(name6),
};
int32_t args_count = 0;
icu::Formattable args[] = {
arg0.has_value(&args_count) ? *arg0.formattable : icu::Formattable(),
arg1.has_value(&args_count) ? *arg1.formattable : icu::Formattable(),
arg2.has_value(&args_count) ? *arg2.formattable : icu::Formattable(),
arg3.has_value(&args_count) ? *arg3.formattable : icu::Formattable(),
arg4.has_value(&args_count) ? *arg4.formattable : icu::Formattable(),
arg5.has_value(&args_count) ? *arg5.formattable : icu::Formattable(),
arg6.has_value(&args_count) ? *arg6.formattable : icu::Formattable(),
};
UnicodeString msg_string(msg.data(), msg.size());
UErrorCode error = U_ZERO_ERROR;
icu::MessageFormat format(msg_string, error);
icu::UnicodeString formatted;
format.format(names, args, args_count, formatted, error);
if (U_FAILURE(error)) {
LOG(ERROR) << "MessageFormat(" << msg << ") failed with "
<< u_errorName(error);
return std::u16string();
}
return i18n::UnicodeStringToString16(formatted);
}
} // namespace i18n
} // namespace base
|
