LLVM  6.0.0svn
SmallString.h
Go to the documentation of this file.
1 //===- llvm/ADT/SmallString.h - 'Normally small' strings --------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
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 
21 namespace 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).
25 template<unsigned InternalLen>
26 class SmallString : public SmallVector<char, InternalLen> {
27 public:
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 with a range.
35  template<typename ItTy>
36  SmallString(ItTy S, ItTy E) : SmallVector<char, InternalLen>(S, E) {}
37 
38  // Note that in order to add new overloads for append & assign, we have to
39  // duplicate the inherited versions so as not to inadvertently hide them.
40 
41  /// @}
42  /// @name String Assignment
43  /// @{
44 
45  /// Assign from a repeated element.
46  void assign(size_t NumElts, char Elt) {
47  this->SmallVectorImpl<char>::assign(NumElts, Elt);
48  }
49 
50  /// Assign from an iterator pair.
51  template<typename in_iter>
52  void assign(in_iter S, in_iter E) {
53  this->clear();
55  }
56 
57  /// Assign from a StringRef.
58  void assign(StringRef RHS) {
59  this->clear();
61  }
62 
63  /// Assign from a SmallVector.
64  void assign(const SmallVectorImpl<char> &RHS) {
65  this->clear();
67  }
68 
69  /// @}
70  /// @name String Concatenation
71  /// @{
72 
73  /// Append from an iterator pair.
74  template<typename in_iter>
75  void append(in_iter S, in_iter E) {
77  }
78 
79  void append(size_t NumInputs, char Elt) {
80  SmallVectorImpl<char>::append(NumInputs, Elt);
81  }
82 
83  /// Append from a StringRef.
84  void append(StringRef RHS) {
86  }
87 
88  /// Append from a SmallVector.
89  void append(const SmallVectorImpl<char> &RHS) {
91  }
92 
93  /// @}
94  /// @name String Comparison
95  /// @{
96 
97  /// Check for string equality. This is more efficient than compare() when
98  /// the relative ordering of inequal strings isn't needed.
99  bool equals(StringRef RHS) const {
100  return str().equals(RHS);
101  }
102 
103  /// Check for string equality, ignoring case.
104  bool equals_lower(StringRef RHS) const {
105  return str().equals_lower(RHS);
106  }
107 
108  /// Compare two strings; the result is -1, 0, or 1 if this string is
109  /// lexicographically less than, equal to, or greater than the \p RHS.
110  int compare(StringRef RHS) const {
111  return str().compare(RHS);
112  }
113 
114  /// compare_lower - Compare two strings, ignoring case.
115  int compare_lower(StringRef RHS) const {
116  return str().compare_lower(RHS);
117  }
118 
119  /// compare_numeric - Compare two strings, treating sequences of digits as
120  /// numbers.
121  int compare_numeric(StringRef RHS) const {
122  return str().compare_numeric(RHS);
123  }
124 
125  /// @}
126  /// @name String Predicates
127  /// @{
128 
129  /// startswith - Check if this string starts with the given \p Prefix.
131  return str().startswith(Prefix);
132  }
133 
134  /// endswith - Check if this string ends with the given \p Suffix.
135  bool endswith(StringRef Suffix) const {
136  return str().endswith(Suffix);
137  }
138 
139  /// @}
140  /// @name String Searching
141  /// @{
142 
143  /// find - Search for the first character \p C in the string.
144  ///
145  /// \return - The index of the first occurrence of \p C, or npos if not
146  /// found.
147  size_t find(char C, size_t From = 0) const {
148  return str().find(C, From);
149  }
150 
151  /// Search for the first string \p Str in the string.
152  ///
153  /// \returns The index of the first occurrence of \p Str, or npos if not
154  /// found.
155  size_t find(StringRef Str, size_t From = 0) const {
156  return str().find(Str, From);
157  }
158 
159  /// Search for the last character \p C in the string.
160  ///
161  /// \returns The index of the last occurrence of \p C, or npos if not
162  /// found.
163  size_t rfind(char C, size_t From = StringRef::npos) const {
164  return str().rfind(C, From);
165  }
166 
167  /// Search for the last string \p Str in the string.
168  ///
169  /// \returns The index of the last occurrence of \p Str, or npos if not
170  /// found.
171  size_t rfind(StringRef Str) const {
172  return str().rfind(Str);
173  }
174 
175  /// Find the first character in the string that is \p C, or npos if not
176  /// found. Same as find.
177  size_t find_first_of(char C, size_t From = 0) const {
178  return str().find_first_of(C, From);
179  }
180 
181  /// Find the first character in the string that is in \p Chars, or npos if
182  /// not found.
183  ///
184  /// Complexity: O(size() + Chars.size())
185  size_t find_first_of(StringRef Chars, size_t From = 0) const {
186  return str().find_first_of(Chars, From);
187  }
188 
189  /// Find the first character in the string that is not \p C or npos if not
190  /// found.
191  size_t find_first_not_of(char C, size_t From = 0) const {
192  return str().find_first_not_of(C, From);
193  }
194 
195  /// Find the first character in the string that is not in the string
196  /// \p Chars, or npos if not found.
197  ///
198  /// Complexity: O(size() + Chars.size())
199  size_t find_first_not_of(StringRef Chars, size_t From = 0) const {
200  return str().find_first_not_of(Chars, From);
201  }
202 
203  /// Find the last character in the string that is \p C, or npos if not
204  /// found.
205  size_t find_last_of(char C, size_t From = StringRef::npos) const {
206  return str().find_last_of(C, From);
207  }
208 
209  /// Find the last character in the string that is in \p C, or npos if not
210  /// found.
211  ///
212  /// Complexity: O(size() + Chars.size())
213  size_t find_last_of(
214  StringRef Chars, size_t From = StringRef::npos) const {
215  return str().find_last_of(Chars, From);
216  }
217 
218  /// @}
219  /// @name Helpful Algorithms
220  /// @{
221 
222  /// Return the number of occurrences of \p C in the string.
223  size_t count(char C) const {
224  return str().count(C);
225  }
226 
227  /// Return the number of non-overlapped occurrences of \p Str in the
228  /// string.
229  size_t count(StringRef Str) const {
230  return str().count(Str);
231  }
232 
233  /// @}
234  /// @name Substring Operations
235  /// @{
236 
237  /// Return a reference to the substring from [Start, Start + N).
238  ///
239  /// \param Start The index of the starting character in the substring; if
240  /// the index is npos or greater than the length of the string then the
241  /// empty substring will be returned.
242  ///
243  /// \param N The number of characters to included in the substring. If \p N
244  /// exceeds the number of characters remaining in the string, the string
245  /// suffix (starting with \p Start) will be returned.
246  StringRef substr(size_t Start, size_t N = StringRef::npos) const {
247  return str().substr(Start, N);
248  }
249 
250  /// Return a reference to the substring from [Start, End).
251  ///
252  /// \param Start The index of the starting character in the substring; if
253  /// the index is npos or greater than the length of the string then the
254  /// empty substring will be returned.
255  ///
256  /// \param End The index following the last character to include in the
257  /// substring. If this is npos, or less than \p Start, or exceeds the
258  /// number of characters remaining in the string, the string suffix
259  /// (starting with \p Start) will be returned.
260  StringRef slice(size_t Start, size_t End) const {
261  return str().slice(Start, End);
262  }
263 
264  // Extra methods.
265 
266  /// Explicit conversion to StringRef.
267  StringRef str() const { return StringRef(this->begin(), this->size()); }
268 
269  // TODO: Make this const, if it's safe...
270  const char* c_str() {
271  this->push_back(0);
272  this->pop_back();
273  return this->data();
274  }
275 
276  /// Implicit conversion to StringRef.
277  operator StringRef() const { return str(); }
278 
279  // Extra operators.
281  this->clear();
282  return *this += RHS;
283  }
284 
286  this->append(RHS.begin(), RHS.end());
287  return *this;
288  }
290  this->push_back(C);
291  return *this;
292  }
293 };
294 
295 } // end namespace llvm
296 
297 #endif // LLVM_ADT_SMALLSTRING_H
uint64_t CallInst * C
void push_back(const T &Elt)
Definition: SmallVector.h:212
size_t count(char C) const
Return the number of occurrences of C in the string.
Definition: SmallString.h:223
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void assign(StringRef RHS)
Assign from a StringRef.
Definition: SmallString.h:58
LLVM_NODISCARD bool equals_lower(StringRef RHS) const
equals_lower - Check for string equality, ignoring case.
Definition: StringRef.h:176
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
int compare_lower(StringRef RHS) const
compare_lower - Compare two strings, ignoring case.
Definition: SmallString.h:115
SmallString(ItTy S, ItTy E)
Initialize with a range.
Definition: SmallString.h:36
LLVM_NODISCARD size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
Definition: StringRef.h:360
size_t find(char C, size_t From=0) const
find - Search for the first character C in the string.
Definition: SmallString.h:147
void append(const SmallVectorImpl< char > &RHS)
Append from a SmallVector.
Definition: SmallString.h:89
LLVM_NODISCARD size_t find_last_of(char C, size_t From=npos) const
Find the last character in the string that is C, or npos if not found.
Definition: StringRef.h:421
int compare_numeric(StringRef RHS) const
compare_numeric - Compare two strings, treating sequences of digits as numbers.
Definition: SmallString.h:121
SmallString & operator+=(char C)
Definition: SmallString.h:289
size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
Definition: SmallString.h:191
void append(size_t NumInputs, char Elt)
Definition: SmallString.h:79
size_t rfind(char C, size_t From=StringRef::npos) const
Search for the last character C in the string.
Definition: SmallString.h:163
size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: SmallString.h:177
SmallString & operator+=(StringRef RHS)
Definition: SmallString.h:285
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool endswith(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition: StringRef.h:279
int compare(StringRef RHS) const
Compare two strings; the result is -1, 0, or 1 if this string is lexicographically less than...
Definition: SmallString.h:110
LLVM_NODISCARD size_t count(char C) const
Return the number of occurrences of C in the string.
Definition: StringRef.h:476
void assign(const SmallVectorImpl< char > &RHS)
Assign from a SmallVector.
Definition: SmallString.h:64
bool equals_lower(StringRef RHS) const
Check for string equality, ignoring case.
Definition: SmallString.h:104
bool endswith(StringRef Suffix) const
endswith - Check if this string ends with the given Suffix.
Definition: SmallString.h:135
void assign(size_type NumElts, const T &Elt)
Definition: SmallVector.h:427
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:267
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: SmallString.h:260
SmallString(StringRef S)
Initialize from a StringRef.
Definition: SmallString.h:32
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:598
size_t find_last_of(char C, size_t From=StringRef::npos) const
Find the last character in the string that is C, or npos if not found.
Definition: SmallString.h:205
size_t find(StringRef Str, size_t From=0) const
Search for the first string Str in the string.
Definition: SmallString.h:155
void append(in_iter S, in_iter E)
Append from an iterator pair.
Definition: SmallString.h:75
void append(StringRef RHS)
Append from a StringRef.
Definition: SmallString.h:84
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
LLVM_NODISCARD size_t find_first_not_of(char C, size_t From=0) const
Find the first character in the string that is not C or npos if not found.
Definition: StringRef.cpp:265
static const unsigned End
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE int compare(StringRef RHS) const
compare - Compare two strings; the result is -1, 0, or 1 if this string is lexicographically less tha...
Definition: StringRef.h:184
void assign(size_t NumElts, char Elt)
Assign from a repeated element.
Definition: SmallString.h:46
size_t find_first_not_of(StringRef Chars, size_t From=0) const
Find the first character in the string that is not in the string Chars, or npos if not found...
Definition: SmallString.h:199
bool equals(StringRef RHS) const
Check for string equality.
Definition: SmallString.h:99
LLVM_NODISCARD int compare_lower(StringRef RHS) const
compare_lower - Compare two strings, ignoring case.
Definition: StringRef.cpp:53
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
SmallString()=default
Default ctor - Initialize to empty.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef slice(size_t Start, size_t End) const
Return a reference to the substring from [Start, End).
Definition: StringRef.h:710
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:169
iterator begin() const
Definition: StringRef.h:106
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:398
LLVM_NODISCARD int compare_numeric(StringRef RHS) const
compare_numeric - Compare two strings, treating sequences of digits as numbers.
Definition: StringRef.cpp:79
bool startswith(StringRef Prefix) const
startswith - Check if this string starts with the given Prefix.
Definition: SmallString.h:130
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
pointer data()
Return a pointer to the vector&#39;s buffer, even if empty().
Definition: SmallVector.h:143
static const size_t npos
Definition: StringRef.h:51
const char * c_str()
Definition: SmallString.h:270
LLVM_NODISCARD size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: StringRef.h:395
#define N
StringRef substr(size_t Start, size_t N=StringRef::npos) const
Return a reference to the substring from [Start, Start + N).
Definition: SmallString.h:246
size_t find_last_of(StringRef Chars, size_t From=StringRef::npos) const
Find the last character in the string that is in C, or npos if not found.
Definition: SmallString.h:213
size_t count(StringRef Str) const
Return the number of non-overlapped occurrences of Str in the string.
Definition: SmallString.h:229
size_t find_first_of(StringRef Chars, size_t From=0) const
Find the first character in the string that is in Chars, or npos if not found.
Definition: SmallString.h:185
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:298
const SmallString & operator=(StringRef RHS)
Definition: SmallString.h:280
iterator end() const
Definition: StringRef.h:108
void assign(in_iter S, in_iter E)
Assign from an iterator pair.
Definition: SmallString.h:52
size_t rfind(StringRef Str) const
Search for the last string Str in the string.
Definition: SmallString.h:171