/3rd_party/llvm/include/llvm/ADT/SmallString.h

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