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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
#include "jinja/string.h"
#include "jinja/value.h"
#include <algorithm>
#include <functional>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
namespace jinja {
//
// string_part
//
bool string_part::is_uppercase() const {
for (char c : val) {
if (std::islower(static_cast<unsigned char>(c))) {
return false;
}
}
return true;
}
bool string_part::is_lowercase() const {
for (char c : val) {
if (std::isupper(static_cast<unsigned char>(c))) {
return false;
}
}
return true;
}
//
// string
//
void string::mark_input() {
for (auto & part : parts) {
part.is_input = true;
}
}
std::string string::str() const {
if (parts.size() == 1) {
return parts[0].val;
}
std::ostringstream oss;
for (const auto & part : parts) {
oss << part.val;
}
return oss.str();
}
size_t string::length() const {
size_t len = 0;
for (const auto & part : parts) {
len += part.val.length();
}
return len;
}
void string::hash_update(hasher & hash) const noexcept {
for (const auto & part : parts) {
hash.update(part.val.data(), part.val.length());
}
}
bool string::all_parts_are_input() const {
for (const auto & part : parts) {
if (!part.is_input) {
return false;
}
}
return true;
}
bool string::is_uppercase() const {
for (const auto & part : parts) {
if (!part.is_uppercase()) {
return false;
}
}
return true;
}
bool string::is_lowercase() const {
for (const auto & part : parts) {
if (!part.is_lowercase()) {
return false;
}
}
return true;
}
// mark this string as input if other has ALL parts as input
void string::mark_input_based_on(const string & other) {
if (other.all_parts_are_input()) {
for (auto & part : parts) {
part.is_input = true;
}
}
}
string string::append(const string & other) {
for (const auto & part : other.parts) {
parts.push_back(part);
}
return *this;
}
// in-place transformation
using transform_fn = std::function<std::string(const std::string&)>;
static string apply_transform(string & self, const transform_fn & fn) {
for (auto & part : self.parts) {
part.val = fn(part.val);
}
return self;
}
string string::uppercase() {
return apply_transform(*this, [](const std::string & s) {
std::string res = s;
std::transform(res.begin(), res.end(), res.begin(), ::toupper);
return res;
});
}
string string::lowercase() {
return apply_transform(*this, [](const std::string & s) {
std::string res = s;
std::transform(res.begin(), res.end(), res.begin(), ::tolower);
return res;
});
}
string string::capitalize() {
return apply_transform(*this, [](const std::string & s) {
if (s.empty()) return s;
std::string res = s;
res[0] = ::toupper(static_cast<unsigned char>(res[0]));
std::transform(res.begin() + 1, res.end(), res.begin() + 1, ::tolower);
return res;
});
}
string string::titlecase() {
return apply_transform(*this, [](const std::string & s) {
std::string res = s;
bool capitalize_next = true;
for (char &c : res) {
if (isspace(static_cast<unsigned char>(c))) {
capitalize_next = true;
} else if (capitalize_next) {
c = ::toupper(static_cast<unsigned char>(c));
capitalize_next = false;
} else {
c = ::tolower(static_cast<unsigned char>(c));
}
}
return res;
});
}
string string::strip(bool left, bool right, std::optional<const std::string_view> chars) {
static auto strip_part = [](const std::string & s, bool left, bool right, std::optional<const std::string_view> chars) -> std::string {
size_t start = 0;
size_t end = s.length();
auto match_char = [&chars](unsigned char c) -> bool {
return chars ? (*chars).find(c) != std::string::npos : isspace(c);
};
if (left) {
while (start < end && match_char(static_cast<unsigned char>(s[start]))) {
++start;
}
}
if (right) {
while (end > start && match_char(static_cast<unsigned char>(s[end - 1]))) {
--end;
}
}
return s.substr(start, end - start);
};
if (parts.empty()) {
return *this;
}
if (left) {
for (size_t i = 0; i < parts.size(); ++i) {
parts[i].val = strip_part(parts[i].val, true, false, chars);
if (parts[i].val.empty()) {
// remove empty part
parts.erase(parts.begin() + i);
--i;
continue;
} else {
break;
}
}
}
if (right) {
for (size_t i = parts.size(); i-- > 0;) {
parts[i].val = strip_part(parts[i].val, false, true, chars);
if (parts[i].val.empty()) {
// remove empty part
parts.erase(parts.begin() + i);
continue;
} else {
break;
}
}
}
return *this;
}
} // namespace jinja
|
