1//===- llvm/ADT/SmallString.h - 'Normally small' strings --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file defines the SmallString class.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ADT_SMALLSTRING_H
15#define LLVM_ADT_SMALLSTRING_H
16
17#include "llvm/ADT/SmallVector.h"
18#include "llvm/ADT/StringRef.h"
19#include <cstddef>
20
21namespace llvm {
22
23/// SmallString - A SmallString is just a SmallVector with methods and accessors
24/// that make it work better as a string (e.g. operator+ etc).
25template<unsigned InternalLen>
26class SmallString : public SmallVector<char, InternalLen> {
27public:
28 /// Default ctor - Initialize to empty.
29 SmallString() = default;
30
31 /// Initialize from a StringRef.
32 SmallString(StringRef S) : SmallVector<char, InternalLen>(S.begin(), S.end()) {}
33
34 /// Initialize by concatenating a list of StringRefs.
35 SmallString(std::initializer_list<StringRef> Refs)
36 : SmallVector<char, InternalLen>() {
37 this->append(Refs);
38 }
39
40 /// Initialize with a range.
41 template<typename ItTy>
42 SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}
43
44 /// @}
45 /// @name String Assignment
46 /// @{
47
48 using SmallVector<char, InternalLen>::assign;
49
50 /// Assign from a StringRef.
51 void assign(StringRef RHS) {
52 SmallVectorImpl<char>::assign(RHS.begin(), RHS.end());
53 }
54
55 /// Assign from a list of StringRefs.
56 void assign(std::initializer_list<StringRef> Refs) {
57 this->clear();
58 append(Refs);
59 }
60
61 /// @}
62 /// @name String Concatenation
63 /// @{
64
65 using SmallVector<char, InternalLen>::append;
66
67 /// Append from a StringRef.
68 void append(StringRef RHS) {
69 SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
70 }
71
72 /// Append from a list of StringRefs.
73 void append(std::initializer_list<StringRef> Refs) {
74 size_t CurrentSize = this->size();
75 size_t SizeNeeded = CurrentSize;
76 for (const StringRef &Ref : Refs)
77 SizeNeeded += Ref.size();
78 this->resize_for_overwrite(SizeNeeded);
79 for (const StringRef &Ref : Refs) {
80 std::copy(Ref.begin(), Ref.end(), this->begin() + CurrentSize);
81 CurrentSize += Ref.size();
82 }
83 assert(CurrentSize == this->size());
84 }
85
86 /// @}
87 /// @name String Comparison
88 /// @{
89
90 /// Check for string equality. This is more efficient than compare() when
91 /// the relative ordering of inequal strings isn't needed.
92 bool equals(StringRef RHS) const {
93 return str().equals(RHS);
94 }
95
96 /// Check for string equality, ignoring case.
97 bool equals_insensitive(StringRef RHS) const {
98 return str().equals_insensitive(RHS);
99 }
100
101 /// Compare two strings; the result is -1, 0, or 1 if this string is
102 /// lexicographically less than, equal to, or greater than the \p RHS.
103 int compare(StringRef RHS) const {
104 return str().compare(RHS);
105 }
106
107 /// compare_insensitive - Compare two strings, ignoring case.
108 int compare_insensitive(StringRef RHS) const {
109 return str().compare_insensitive(RHS);
110 }
111
112 /// compare_numeric - Compare two strings, treating sequences of digits as
113 /// numbers.
114 int compare_numeric(StringRef RHS) const {
115 return str().compare_numeric(RHS);
116 }
117
118 /// @}
119 /// @name String Predicates
120 /// @{
121
122 /// startswith - Check if this string starts with the given \p Prefix.
123 bool startswith(StringRef Prefix) const {
124 return str().startswith(Prefix);
125 }
126
127 /// endswith - Check if this string ends with the given \p Suffix.
128 bool endswith(StringRef Suffix) const {
129 return str().endswith(Suffix);
130 }
131
132 /// @}
133 /// @name String Searching
134 /// @{
135
136 /// find - Search for the first character \p C in the string.
137 ///
138 /// \return - The index of the first occurrence of \p C, or npos if not
139 /// found.
140 size_t find(char C, size_t From = 0) const {
141 return str().find(C, From);
142 }
143
144 /// Search for the first string \p Str in the string.
145 ///
146 /// \returns The index of the first occurrence of \p Str, or npos if not
147 /// found.
148 size_t find(StringRef Str, size_t From = 0) const {
149 return str().find(Str, From);
150 }
151
152 /// Search for the last character \p C in the string.
153 ///
154 /// \returns The index of the last occurrence of \p C, or npos if not
155 /// found.
156 size_t rfind(char C, size_t From = StringRef::npos) const {
157 return str().rfind(C, From);
158 }
159
160 /// Search for the last string \p Str in the string.
161 ///
162 /// \returns The index of the last occurrence of \p Str, or npos if not
163 /// found.
164 size_t rfind(StringRef Str) const {
165 return str().rfind(Str);
166 }
167
168 /// Find the first character in the string that is \p C, or npos if not
169 /// found. Same as find.
170 size_t find_first_of(char C, size_t From = 0) const {
171 return str().find_first_of(C, From);
172 }
173
174 /// Find the first character in the string that is in \p Chars, or npos if
175 /// not found.
176 ///
177 /// Complexity: O(size() + Chars.size())
178 size_t find_first_of(StringRef Chars, size_t From = 0) const {
179 return str().find_first_of(Chars, From);
180 }
181
182 /// Find the first character in the string that is not \p C or npos if not
183 /// found.
184 size_t find_first_not_of(char C, size_t From = 0) const {
185 return str().find_first_not_of(C, From);
186 }
187
188 /// Find the first character in the string that is not in the string
189 /// \p Chars, or npos if not found.
190 ///
191 /// Complexity: O(size() + Chars.size())
192 size_t find_first_not_of(StringRef Chars, size_t From = 0) const {
193 return str().find_first_not_of(Chars, From);
194 }
195
196 /// Find the last character in the string that is \p C, or npos if not
197 /// found.
198 size_t find_last_of(char C, size_t From = StringRef::npos) const {
199 return str().find_last_of(C, From);
200 }
201
202 /// Find the last character in the string that is in \p C, or npos if not
203 /// found.
204 ///
205 /// Complexity: O(size() + Chars.size())
206 size_t find_last_of(
207 StringRef Chars, size_t From = StringRef::npos) const {
208 return str().find_last_of(Chars, From);
209 }
210
211 /// @}
212 /// @name Helpful Algorithms
213 /// @{
214
215 /// Return the number of occurrences of \p C in the string.
216 size_t count(char C) const {
217 return str().count(C);
218 }
219
220 /// Return the number of non-overlapped occurrences of \p Str in the
221 /// string.
222 size_t count(StringRef Str) const {
223 return str().count(Str);
224 }
225
226 /// @}
227 /// @name Substring Operations
228 /// @{
229
230 /// Return a reference to the substring from [Start, Start + N).
231 ///
232 /// \param Start The index of the starting character in the substring; if
233 /// the index is npos or greater than the length of the string then the
234 /// empty substring will be returned.
235 ///
236 /// \param N The number of characters to included in the substring. If \p N
237 /// exceeds the number of characters remaining in the string, the string
238 /// suffix (starting with \p Start) will be returned.
239 StringRef substr(size_t Start, size_t N = StringRef::npos) const {
240 return str().substr(Start, N);
241 }
242
243 /// Return a reference to the substring from [Start, End).
244 ///
245 /// \param Start The index of the starting character in the substring; if
246 /// the index is npos or greater than the length of the string then the
247 /// empty substring will be returned.
248 ///
249 /// \param End The index following the last character to include in the
250 /// substring. If this is npos, or less than \p Start, or exceeds the
251 /// number of characters remaining in the string, the string suffix
252 /// (starting with \p Start) will be returned.
253 StringRef slice(size_t Start, size_t End) const {
254 return str().slice(Start, End);
255 }
256
257 // Extra methods.
258
259 /// Explicit conversion to StringRef.
260 StringRef str() const { return StringRef(this->data(), this->size()); }
261
262 // TODO: Make this const, if it's safe...
263 const char* c_str() {
264 this->push_back(0);
265 this->pop_back();
266 return this->data();
267 }
268
269 /// Implicit conversion to StringRef.
270 operator StringRef() const { return str(); }
271
272 explicit operator std::string() const {
273 return std::string(this->data(), this->size());
274 }
275
276 // Extra operators.
277 SmallString &operator=(StringRef RHS) {
278 this->assign(RHS);
279 return *this;
280 }
281
282 SmallString &operator+=(StringRef RHS) {
283 this->append(RHS.begin(), RHS.end());
284 return *this;
285 }
286 SmallString &operator+=(char C) {
287 this->push_back(C);
288 return *this;
289 }
290};
291
292} // end namespace llvm
293
294#endif // LLVM_ADT_SMALLSTRING_H
295