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
|
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#ifndef cmStringAlgorithms_h
#define cmStringAlgorithms_h
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmRange.h"
#include "cm_string_view.hxx"
#include <cctype>
#include <initializer_list>
#include <sstream>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
/** String range type. */
typedef cmRange<std::vector<std::string>::const_iterator> cmStringRange;
/** Callable string comparison struct. */
struct cmStrCmp
{
cmStrCmp(std::string str)
: Test_(std::move(str))
{
}
bool operator()(cm::string_view sv) const { return Test_ == sv; }
private:
std::string const Test_;
};
/** Returns true if the character @a ch is a whitespace character. **/
inline bool cmIsSpace(char ch)
{
return ((ch & 0x80) == 0) && std::isspace(ch);
}
/** Returns a string that has whitespace removed from the start and the end. */
std::string cmTrimWhitespace(cm::string_view str);
/** Escape quotes in a string. */
std::string cmEscapeQuotes(cm::string_view str);
/** Joins elements of a range with separator into a single string. */
template <typename Range>
std::string cmJoin(Range const& rng, cm::string_view separator)
{
if (rng.empty()) {
return std::string();
}
std::ostringstream os;
auto it = rng.begin();
auto const end = rng.end();
os << *it;
while (++it != end) {
os << separator << *it;
}
return os.str();
}
/** Extract tokens that are separated by any of the characters in @a sep. */
std::vector<std::string> cmTokenize(cm::string_view str, cm::string_view sep);
/** Concatenate string pieces into a single string. */
std::string cmCatViews(std::initializer_list<cm::string_view> views);
/** Utility class for cmStrCat. */
class cmAlphaNum
{
public:
cmAlphaNum(cm::string_view view)
: View_(view)
{
}
cmAlphaNum(std::string const& str)
: View_(str)
{
}
cmAlphaNum(const char* str)
: View_(str)
{
}
cmAlphaNum(char ch)
: View_(Digits_, 1)
{
Digits_[0] = ch;
}
cmAlphaNum(int val);
cmAlphaNum(unsigned int val);
cmAlphaNum(long int val);
cmAlphaNum(unsigned long int val);
cmAlphaNum(long long int val);
cmAlphaNum(unsigned long long int val);
cmAlphaNum(float val);
cmAlphaNum(double val);
cm::string_view View() const { return View_; }
private:
cm::string_view View_;
char Digits_[32];
};
/** Concatenate string pieces and numbers into a single string. */
template <typename... AV>
inline std::string cmStrCat(cmAlphaNum const& a, cmAlphaNum const& b,
AV const&... args)
{
return cmCatViews(
{ a.View(), b.View(), static_cast<cmAlphaNum const&>(args).View()... });
}
/** Joins wrapped elements of a range with separator into a single string. */
template <typename Range>
std::string cmWrap(cm::string_view prefix, Range const& rng,
cm::string_view suffix, cm::string_view sep)
{
if (rng.empty()) {
return std::string();
}
return cmCatViews(
{ prefix, cmJoin(rng, cmCatViews({ suffix, sep, prefix })), suffix });
}
/** Joins wrapped elements of a range with separator into a single string. */
template <typename Range>
std::string cmWrap(char prefix, Range const& rng, char suffix,
cm::string_view sep)
{
return cmWrap(cm::string_view(&prefix, 1), rng, cm::string_view(&suffix, 1),
sep);
}
/** Returns true if string @a str starts with the character @a prefix. */
inline bool cmHasPrefix(cm::string_view str, char prefix)
{
return !str.empty() && (str.front() == prefix);
}
/** Returns true if string @a str starts with string @a prefix. */
inline bool cmHasPrefix(cm::string_view str, cm::string_view prefix)
{
return str.compare(0, prefix.size(), prefix) == 0;
}
/** Returns true if string @a str starts with string @a prefix. */
template <size_t N>
inline bool cmHasLiteralPrefix(cm::string_view str, const char (&prefix)[N])
{
return cmHasPrefix(str, cm::string_view(prefix, N - 1));
}
/** Returns true if string @a str ends with the character @a suffix. */
inline bool cmHasSuffix(cm::string_view str, char suffix)
{
return !str.empty() && (str.back() == suffix);
}
/** Returns true if string @a str ends with string @a suffix. */
inline bool cmHasSuffix(cm::string_view str, cm::string_view suffix)
{
return str.size() >= suffix.size() &&
str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}
/** Returns true if string @a str ends with string @a suffix. */
template <size_t N>
inline bool cmHasLiteralSuffix(cm::string_view str, const char (&suffix)[N])
{
return cmHasSuffix(str, cm::string_view(suffix, N - 1));
}
/** Removes an existing suffix character of from the string @a str. */
inline void cmStripSuffixIfExists(std::string& str, char suffix)
{
if (cmHasSuffix(str, suffix)) {
str.pop_back();
}
}
/** Removes an existing suffix string of from the string @a str. */
inline void cmStripSuffixIfExists(std::string& str, cm::string_view suffix)
{
if (cmHasSuffix(str, suffix)) {
str.resize(str.size() - suffix.size());
}
}
#endif
|
