Optimizations to Element::getAttribute
[WebKit-https.git] / WebCore / platform / text / PlatformString.h
1 /*
2  * (C) 1999 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #ifndef PlatformString_h
23 #define PlatformString_h
24
25 // This file would be called String.h, but that conflicts with <string.h>
26 // on systems without case-sensitive file systems.
27
28 #include "StringImpl.h"
29
30 #ifdef __OBJC__
31 #include <objc/objc.h>
32 #endif
33
34 #if USE(JSC)
35 #include <runtime/Identifier.h>
36 #else
37 // runtime/Identifier.h brings in a variety of wtf headers.  We explicitly
38 // include them in the case of non-JSC builds to keep things consistent.
39 #include <wtf/HashMap.h>
40 #include <wtf/HashSet.h>
41 #include <wtf/OwnPtr.h>
42 #endif
43
44 #if PLATFORM(CF)
45 typedef const struct __CFString * CFStringRef;
46 #endif
47
48 #if PLATFORM(QT)
49 QT_BEGIN_NAMESPACE
50 class QString;
51 QT_END_NAMESPACE
52 #include <QDataStream>
53 #endif
54
55 #if PLATFORM(WX)
56 class wxString;
57 #endif
58
59 #if PLATFORM(HAIKU)
60 class BString;
61 #endif
62
63 namespace WebCore {
64
65 class CString;
66 class SharedBuffer;
67 struct StringHash;
68
69 class String {
70 public:
71     String() { } // gives null string, distinguishable from an empty string
72     String(const UChar*, unsigned length);
73     String(const UChar*); // Specifically for null terminated UTF-16
74 #if USE(JSC)
75     String(const JSC::Identifier&);
76     String(const JSC::UString&);
77 #endif
78     String(const char*);
79     String(const char*, unsigned length);
80     String(StringImpl* i) : m_impl(i) { }
81     String(PassRefPtr<StringImpl> i) : m_impl(i) { }
82     String(RefPtr<StringImpl> i) : m_impl(i) { }
83
84     void swap(String& o) { m_impl.swap(o.m_impl); }
85
86     // Hash table deleted values, which are only constructed and never copied or destroyed.
87     String(WTF::HashTableDeletedValueType) : m_impl(WTF::HashTableDeletedValue) { }
88     bool isHashTableDeletedValue() const { return m_impl.isHashTableDeletedValue(); }
89
90     static String adopt(StringBuffer& buffer) { return StringImpl::adopt(buffer); }
91     static String adopt(Vector<UChar>& vector) { return StringImpl::adopt(vector); }
92
93 #if USE(JSC)
94     operator JSC::UString() const;
95 #endif
96
97     unsigned length() const;
98     const UChar* characters() const;
99     const UChar* charactersWithNullTermination();
100     
101     UChar operator[](unsigned i) const; // if i >= length(), returns 0    
102     UChar32 characterStartingAt(unsigned) const; // Ditto.
103     
104     bool contains(UChar c) const { return find(c) != -1; }
105     bool contains(const char* str, bool caseSensitive = true) const { return find(str, 0, caseSensitive) != -1; }
106     bool contains(const String& str, bool caseSensitive = true) const { return find(str, 0, caseSensitive) != -1; }
107
108     int find(UChar c, int start = 0) const
109         { return m_impl ? m_impl->find(c, start) : -1; }
110     int find(CharacterMatchFunctionPtr matchFunction, int start = 0) const
111         { return m_impl ? m_impl->find(matchFunction, start) : -1; }
112     int find(const char* str, int start = 0, bool caseSensitive = true) const
113         { return m_impl ? m_impl->find(str, start, caseSensitive) : -1; }
114     int find(const String& str, int start = 0, bool caseSensitive = true) const
115         { return m_impl ? m_impl->find(str.impl(), start, caseSensitive) : -1; }
116
117     int reverseFind(UChar c, int start = -1) const
118         { return m_impl ? m_impl->reverseFind(c, start) : -1; }
119     int reverseFind(const String& str, int start = -1, bool caseSensitive = true) const
120         { return m_impl ? m_impl->reverseFind(str.impl(), start, caseSensitive) : -1; }
121     
122     bool startsWith(const String& s, bool caseSensitive = true) const
123         { return m_impl ? m_impl->startsWith(s.impl(), caseSensitive) : s.isEmpty(); }
124     bool endsWith(const String& s, bool caseSensitive = true) const
125         { return m_impl ? m_impl->endsWith(s.impl(), caseSensitive) : s.isEmpty(); }
126
127     void append(const String&);
128     void append(char);
129     void append(UChar);
130     void append(const UChar*, unsigned length);
131     void insert(const String&, unsigned pos);
132     void insert(const UChar*, unsigned length, unsigned pos);
133
134     String& replace(UChar a, UChar b) { if (m_impl) m_impl = m_impl->replace(a, b); return *this; }
135     String& replace(UChar a, const String& b) { if (m_impl) m_impl = m_impl->replace(a, b.impl()); return *this; }
136     String& replace(const String& a, const String& b) { if (m_impl) m_impl = m_impl->replace(a.impl(), b.impl()); return *this; }
137     String& replace(unsigned index, unsigned len, const String& b) { if (m_impl) m_impl = m_impl->replace(index, len, b.impl()); return *this; }
138
139     void truncate(unsigned len);
140     void remove(unsigned pos, int len = 1);
141
142     String substring(unsigned pos, unsigned len = UINT_MAX) const;
143     String left(unsigned len) const { return substring(0, len); }
144     String right(unsigned len) const { return substring(length() - len, len); }
145
146     // Returns a lowercase/uppercase version of the string
147     String lower() const;
148     String upper() const;
149
150     String stripWhiteSpace() const;
151     String simplifyWhiteSpace() const;
152
153     String removeCharacters(CharacterMatchFunctionPtr) const;
154
155     // Return the string with case folded for case insensitive comparison.
156     String foldCase() const;
157
158     static String number(short);
159     static String number(unsigned short);
160     static String number(int);
161     static String number(unsigned);
162     static String number(long);
163     static String number(unsigned long);
164     static String number(long long);
165     static String number(unsigned long long);
166     static String number(double);
167     
168     static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
169
170     // Returns an uninitialized string. The characters needs to be written
171     // into the buffer returned in data before the returned string is used.
172     // Failure to do this will have unpredictable results.
173     static String createUninitialized(unsigned length, UChar*& data) { return StringImpl::createUninitialized(length, data); }
174
175     void split(const String& separator, Vector<String>& result) const;
176     void split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const;
177     void split(UChar separator, Vector<String>& result) const;
178     void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const;
179
180     int toIntStrict(bool* ok = 0, int base = 10) const;
181     unsigned toUIntStrict(bool* ok = 0, int base = 10) const;
182     int64_t toInt64Strict(bool* ok = 0, int base = 10) const;
183     uint64_t toUInt64Strict(bool* ok = 0, int base = 10) const;
184     intptr_t toIntPtrStrict(bool* ok = 0, int base = 10) const;
185
186     int toInt(bool* ok = 0) const;
187     unsigned toUInt(bool* ok = 0) const;
188     int64_t toInt64(bool* ok = 0) const;
189     uint64_t toUInt64(bool* ok = 0) const;
190     intptr_t toIntPtr(bool* ok = 0) const;
191     double toDouble(bool* ok = 0) const;
192     float toFloat(bool* ok = 0) const;
193
194     bool percentage(int& percentage) const;
195
196     // Returns a StringImpl suitable for use on another thread.
197     String crossThreadString() const;
198     // Makes a deep copy. Helpful only if you need to use a String on another thread
199     // (use crossThreadString if the method call doesn't need to be threadsafe).
200     // Since the underlying StringImpl objects are immutable, there's no other reason
201     // to ever prefer copy() over plain old assignment.
202     String threadsafeCopy() const;
203
204     bool isNull() const { return !m_impl; }
205     bool isEmpty() const;
206
207     StringImpl* impl() const { return m_impl.get(); }
208
209 #if PLATFORM(CF)
210     String(CFStringRef);
211     CFStringRef createCFString() const;
212 #endif
213
214 #ifdef __OBJC__
215     String(NSString*);
216     
217     // This conversion maps NULL to "", which loses the meaning of NULL, but we 
218     // need this mapping because AppKit crashes when passed nil NSStrings.
219     operator NSString*() const { if (!m_impl) return @""; return *m_impl; }
220 #endif
221
222 #if PLATFORM(QT)
223     String(const QString&);
224     String(const QStringRef&);
225     operator QString() const;
226 #endif
227
228 #if PLATFORM(WX)
229     String(const wxString&);
230     operator wxString() const;
231 #endif
232
233 #if PLATFORM(HAIKU)
234     String(const BString&);
235     operator BString() const;
236 #endif
237
238 #ifndef NDEBUG
239     Vector<char> ascii() const;
240 #endif
241
242     CString latin1() const;
243     CString utf8() const;
244
245     static String fromUTF8(const char*, size_t);
246     static String fromUTF8(const char*);
247
248     // Tries to convert the passed in string to UTF-8, but will fall back to Latin-1 if the string is not valid UTF-8.
249     static String fromUTF8WithLatin1Fallback(const char*, size_t);
250     
251     // Determines the writing direction using the Unicode Bidi Algorithm rules P2 and P3.
252     WTF::Unicode::Direction defaultWritingDirection() const { return m_impl ? m_impl->defaultWritingDirection() : WTF::Unicode::LeftToRight; }
253
254     // Counts the number of grapheme clusters. A surrogate pair or a sequence
255     // of a non-combining character and following combining characters is
256     // counted as 1 grapheme cluster.
257     unsigned numGraphemeClusters() const;
258     // Returns the number of characters which will be less than or equal to
259     // the specified grapheme cluster length.
260     unsigned numCharactersInGraphemeClusters(unsigned) const;
261
262 private:
263     RefPtr<StringImpl> m_impl;
264 };
265
266 #if PLATFORM(QT)
267 QDataStream& operator<<(QDataStream& stream, const String& str);
268 QDataStream& operator>>(QDataStream& stream, String& str);
269 #endif
270
271 String operator+(const String&, const String&);
272 String operator+(const String&, const char*);
273 String operator+(const char*, const String&);
274
275 inline String& operator+=(String& a, const String& b) { a.append(b); return a; }
276
277 inline bool operator==(const String& a, const String& b) { return equal(a.impl(), b.impl()); }
278 inline bool operator==(const String& a, const char* b) { return equal(a.impl(), b); }
279 inline bool operator==(const char* a, const String& b) { return equal(a, b.impl()); }
280
281 inline bool operator!=(const String& a, const String& b) { return !equal(a.impl(), b.impl()); }
282 inline bool operator!=(const String& a, const char* b) { return !equal(a.impl(), b); }
283 inline bool operator!=(const char* a, const String& b) { return !equal(a, b.impl()); }
284
285 inline bool equalIgnoringCase(const String& a, const String& b) { return equalIgnoringCase(a.impl(), b.impl()); }
286 inline bool equalIgnoringCase(const String& a, const char* b) { return equalIgnoringCase(a.impl(), b); }
287 inline bool equalIgnoringCase(const char* a, const String& b) { return equalIgnoringCase(a, b.impl()); }
288
289 inline bool equalPossiblyIgnoringCase(const String& a, const String& b, bool ignoreCase) 
290 {
291     return ignoreCase ? equalIgnoringCase(a, b) : (a == b);
292 }
293
294 inline bool equalIgnoringNullity(const String& a, const String& b) { return equalIgnoringNullity(a.impl(), b.impl()); }
295
296 inline bool operator!(const String& str) { return str.isNull(); }
297
298 inline void swap(String& a, String& b) { a.swap(b); }
299
300 // String Operations
301
302 bool charactersAreAllASCII(const UChar*, size_t);
303
304 int charactersToIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
305 unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
306 int64_t charactersToInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
307 uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
308 intptr_t charactersToIntPtrStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
309
310 int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
311 unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
312 int64_t charactersToInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
313 uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
314 intptr_t charactersToIntPtr(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
315
316 double charactersToDouble(const UChar*, size_t, bool* ok = 0);
317 float charactersToFloat(const UChar*, size_t, bool* ok = 0);
318
319 int find(const UChar*, size_t, UChar, int startPosition = 0);
320 int reverseFind(const UChar*, size_t, UChar, int startPosition = -1);
321
322 #ifdef __OBJC__
323 // This is for situations in WebKit where the long standing behavior has been
324 // "nil if empty", so we try to maintain longstanding behavior for the sake of
325 // entrenched clients
326 inline NSString* nsStringNilIfEmpty(const String& str) {  return str.isEmpty() ? nil : (NSString*)str; }
327 #endif
328
329 inline bool charactersAreAllASCII(const UChar* characters, size_t length)
330 {
331     UChar ored = 0;
332     for (size_t i = 0; i < length; ++i)
333         ored |= characters[i];
334     return !(ored & 0xFF80);
335 }
336
337 inline int find(const UChar* characters, size_t length, UChar character, int startPosition)
338 {
339     if (startPosition >= static_cast<int>(length))
340         return -1;
341     for (size_t i = startPosition; i < length; ++i) {
342         if (characters[i] == character)
343             return static_cast<int>(i);
344     }
345     return -1;
346 }
347
348 inline int find(const UChar* characters, size_t length, CharacterMatchFunctionPtr matchFunction, int startPosition)
349 {
350     if (startPosition >= static_cast<int>(length))
351         return -1;
352     for (size_t i = startPosition; i < length; ++i) {
353         if (matchFunction(characters[i]))
354             return static_cast<int>(i);
355     }
356     return -1;
357 }
358
359 inline int reverseFind(const UChar* characters, size_t length, UChar character, int startPosition)
360 {
361     if (startPosition >= static_cast<int>(length) || !length)
362         return -1;
363     if (startPosition < 0)
364         startPosition += static_cast<int>(length);
365     while (true) {
366         if (characters[startPosition] == character)
367             return startPosition;
368         if (!startPosition)
369             return -1;
370         startPosition--;
371     }
372     ASSERT_NOT_REACHED();
373     return -1;
374 }
375
376 inline void append(Vector<UChar>& vector, const String& string)
377 {
378     vector.append(string.characters(), string.length());
379 }
380
381 inline void appendNumber(Vector<UChar>& vector, unsigned char number)
382 {
383     int numberLength = number > 99 ? 3 : (number > 9 ? 2 : 1);
384     size_t vectorSize = vector.size();
385     vector.grow(vectorSize + numberLength);
386
387     switch (numberLength) {
388     case 3:
389         vector[vectorSize + 2] = number % 10 + '0';
390         number /= 10;
391
392     case 2:
393         vector[vectorSize + 1] = number % 10 + '0';
394         number /= 10;
395
396     case 1:
397         vector[vectorSize] = number % 10 + '0';
398     }
399 }
400
401
402
403 PassRefPtr<SharedBuffer> utf8Buffer(const String&);
404
405 } // namespace WebCore
406
407 namespace WTF {
408
409     // StringHash is the default hash for String
410     template<typename T> struct DefaultHash;
411     template<> struct DefaultHash<WebCore::String> {
412         typedef WebCore::StringHash Hash;
413     };
414
415 }
416
417 #endif