SmallString.h revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338 
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  // Note that in order to add new overloads for append & assign, we have to
38  // duplicate the inherited versions so as not to inadvertently hide them.
39
40  /// @}
41  /// @name String Assignment
42  /// @{
43
44  /// Assign from a repeated element.
45  void assign(size_t NumElts, char Elt) {
46    this->SmallVectorImpl<char>::assign(NumElts, Elt);
47  }
48
49  /// Assign from an iterator pair.
50  template<typename in_iter>
51  void assign(in_iter S, in_iter E) {
52    this->clear();
53    SmallVectorImpl<char>::append(S, E);
54  }
55
56  /// Assign from a StringRef.
57  void assign(StringRef RHS) {
58    this->clear();
59    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
60  }
61
62  /// Assign from a SmallVector.
63  void assign(const SmallVectorImpl<char> &RHS) {
64    this->clear();
65    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
66  }
67
68  /// @}
69  /// @name String Concatenation
70  /// @{
71
72  /// Append from an iterator pair.
73  template<typename in_iter>
74  void append(in_iter S, in_iter E) {
75    SmallVectorImpl<char>::append(S, E);
76  }
77
78  void append(size_t NumInputs, char Elt) {
79    SmallVectorImpl<char>::append(NumInputs, Elt);
80  }
81
82
83  /// Append from a StringRef.
84  void append(StringRef RHS) {
85    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
86  }
87
88  /// Append from a SmallVector.
89  void append(const SmallVectorImpl<char> &RHS) {
90    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
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.
130  bool startswith(StringRef Prefix) const {
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.
280  const SmallString &operator=(StringRef RHS) {
281    this->clear();
282    return *this += RHS;
283  }
284
285  SmallString &operator+=(StringRef RHS) {
286    this->append(RHS.begin(), RHS.end());
287    return *this;
288  }
289  SmallString &operator+=(char C) {
290    this->push_back(C);
291    return *this;
292  }
293};
294
295}
296
297#endif
298