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
214
215
216
217
218
219
220
221
|
#pragma once
#include "string_builder.h"
#include <library/cpp/yt/exception/exception.h>
#include <util/datetime/base.h>
#include <util/generic/string.h>
#include <util/string/strip.h>
#include <vector>
#include <set>
#include <map>
namespace NYT {
////////////////////////////////////////////////////////////////////////////////
//! Formatters enable customizable way to turn an object into a string.
//! This default implementation uses |FormatValue|.
struct TDefaultFormatter
{
template <class T>
void operator()(TStringBuilderBase* builder, const T& obj) const
{
FormatValue(builder, obj, TStringBuf("v"));
}
};
static constexpr TStringBuf DefaultJoinToStringDelimiter = ", ";
static constexpr TStringBuf DefaultKeyValueDelimiter = ": ";
static constexpr TStringBuf DefaultRangeEllipsisFormat = "...";
// ASCII characters from 0x20 = ' ' to 0x7e = '~' are printable.
static constexpr char PrintableASCIILow = 0x20;
static constexpr char PrintableASCIIHigh = 0x7e;
static constexpr TStringBuf Int2Hex = "0123456789abcdef";
//! Joins a range of items into a string intermixing them with the delimiter.
/*!
* \param builder String builder where the output goes.
* \param begin Iterator pointing to the first item (inclusive).
* \param end Iterator pointing to the last item (not inclusive).
* \param formatter Formatter to apply to the items.
* \param delimiter A delimiter to be inserted between items: ", " by default.
* \return The resulting combined string.
*/
template <class TIterator, class TFormatter>
void JoinToString(
TStringBuilderBase* builder,
const TIterator& begin,
const TIterator& end,
const TFormatter& formatter,
TStringBuf delimiter = DefaultJoinToStringDelimiter)
{
for (auto current = begin; current != end; ++current) {
if (current != begin) {
builder->AppendString(delimiter);
}
formatter(builder, *current);
}
}
template <class TIterator, class TFormatter>
TString JoinToString(
const TIterator& begin,
const TIterator& end,
const TFormatter& formatter,
TStringBuf delimiter = DefaultJoinToStringDelimiter)
{
TStringBuilder builder;
JoinToString(&builder, begin, end, formatter, delimiter);
return builder.Flush();
}
//! A handy shortcut with default formatter.
template <class TIterator>
TString JoinToString(
const TIterator& begin,
const TIterator& end,
TStringBuf delimiter = DefaultJoinToStringDelimiter)
{
return JoinToString(begin, end, TDefaultFormatter(), delimiter);
}
//! Joins a collection of given items into a string intermixing them with the delimiter.
/*!
* \param collection A collection containing the items to be joined.
* \param formatter Formatter to apply to the items.
* \param delimiter A delimiter to be inserted between items; ", " by default.
*/
template <class TCollection, class TFormatter>
TString JoinToString(
const TCollection& collection,
const TFormatter& formatter,
TStringBuf delimiter = DefaultJoinToStringDelimiter)
{
using std::begin;
using std::end;
return JoinToString(begin(collection), end(collection), formatter, delimiter);
}
//! A handy shortcut with the default formatter.
template <class TCollection>
TString JoinToString(
const TCollection& collection,
TStringBuf delimiter = DefaultJoinToStringDelimiter)
{
return JoinToString(collection, TDefaultFormatter(), delimiter);
}
//! Concatenates a bunch of TStringBuf-like instances into TString.
template <class... Ts>
TString ConcatToString(Ts... args)
{
size_t length = 0;
((length += args.length()), ...);
TString result;
result.reserve(length);
(result.append(args), ...);
return result;
}
//! Converts a range of items into strings.
template <class TIter, class TFormatter>
std::vector<TString> ConvertToStrings(
const TIter& begin,
const TIter& end,
const TFormatter& formatter,
size_t maxSize = std::numeric_limits<size_t>::max())
{
std::vector<TString> result;
for (auto it = begin; it != end; ++it) {
TStringBuilder builder;
formatter(&builder, *it);
result.push_back(builder.Flush());
if (result.size() == maxSize) {
break;
}
}
return result;
}
//! A handy shortcut with the default formatter.
template <class TIter>
std::vector<TString> ConvertToStrings(
const TIter& begin,
const TIter& end,
size_t maxSize = std::numeric_limits<size_t>::max())
{
return ConvertToStrings(begin, end, TDefaultFormatter(), maxSize);
}
//! Converts a given collection of items into strings.
/*!
* \param collection A collection containing the items to be converted.
* \param formatter Formatter to apply to the items.
* \param maxSize Size limit for the resulting vector.
*/
template <class TCollection, class TFormatter>
std::vector<TString> ConvertToStrings(
const TCollection& collection,
const TFormatter& formatter,
size_t maxSize = std::numeric_limits<size_t>::max())
{
using std::begin;
using std::end;
return ConvertToStrings(begin(collection), end(collection), formatter, maxSize);
}
//! A handy shortcut with default formatter.
template <class TCollection>
std::vector<TString> ConvertToStrings(
const TCollection& collection,
size_t maxSize = std::numeric_limits<size_t>::max())
{
return ConvertToStrings(collection, TDefaultFormatter(), maxSize);
}
////////////////////////////////////////////////////////////////////////////////
void UnderscoreCaseToCamelCase(TStringBuilderBase* builder, TStringBuf str);
TString UnderscoreCaseToCamelCase(TStringBuf str);
void CamelCaseToUnderscoreCase(TStringBuilderBase* builder, TStringBuf str);
TString CamelCaseToUnderscoreCase(TStringBuf str);
TString TrimLeadingWhitespaces(const TString& str);
TString Trim(const TString& str, const TString& whitespaces);
////////////////////////////////////////////////////////////////////////////////
//! Implemented for |[u]i(32|64)|.
template <class T>
char* WriteIntToBufferBackwards(char* ptr, T value);
////////////////////////////////////////////////////////////////////////////////
struct TCaseInsensitiveStringHasher
{
size_t operator()(TStringBuf arg) const;
};
struct TCaseInsensitiveStringEqualityComparer
{
bool operator()(TStringBuf lhs, TStringBuf rhs) const;
};
////////////////////////////////////////////////////////////////////////////////
bool TryParseBool(TStringBuf value, bool* result);
bool ParseBool(TStringBuf value);
TStringBuf FormatBool(bool value);
////////////////////////////////////////////////////////////////////////////////
} // namespace NYT
|
