Windows build fix
[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 #include <wtf/PassRefPtr.h>
31
32 #if USE(JSC)
33 #include <kjs/identifier.h>
34 #endif
35
36 #if PLATFORM(CF)
37 typedef const struct __CFString * CFStringRef;
38 #endif
39
40 #if PLATFORM(QT)
41 QT_BEGIN_NAMESPACE
42 class QString;
43 QT_END_NAMESPACE
44 #endif
45
46 #if PLATFORM(WX)
47 class wxString;
48 #endif
49
50 namespace WebCore {
51
52 class CString;
53 class SharedBuffer;
54 struct StringHash;
55
56 class String {
57 public:
58     String() { } // gives null string, distinguishable from an empty string
59     String(const UChar*, unsigned length);
60     String(const UChar*); // Specifically for null terminated UTF-16
61 #if USE(JSC)
62     String(const KJS::Identifier&);
63     String(const KJS::UString&);
64 #endif
65     String(const char*);
66     String(const char*, unsigned length);
67     String(StringImpl* i) : m_impl(i) { }
68     String(PassRefPtr<StringImpl> i) : m_impl(i) { }
69     String(RefPtr<StringImpl> i) : m_impl(i) { }
70
71     void swap(String& o) { m_impl.swap(o.m_impl); }
72
73     // Hash table deleted values, which are only constructed and never copied or destroyed.
74     String(WTF::HashTableDeletedValueType) : m_impl(WTF::HashTableDeletedValue) { }
75     bool isHashTableDeletedValue() const { return m_impl.isHashTableDeletedValue(); }
76
77     static String adopt(StringBuffer& buffer) { return StringImpl::adopt(buffer); }
78     static String adopt(Vector<UChar>& vector) { return StringImpl::adopt(vector); }
79
80 #if USE(JSC)
81     operator KJS::UString() const;
82 #endif
83
84     unsigned length() const;
85     const UChar* characters() const;
86     const UChar* charactersWithNullTermination();
87     
88     UChar operator[](unsigned i) const; // if i >= length(), returns 0    
89     UChar32 characterStartingAt(unsigned) const; // Ditto.
90     
91     bool contains(UChar c) const { return find(c) != -1; }
92     bool contains(const char* str, bool caseSensitive = true) const { return find(str, 0, caseSensitive) != -1; }
93     bool contains(const String& str, bool caseSensitive = true) const { return find(str, 0, caseSensitive) != -1; }
94
95     int find(UChar c, int start = 0) const
96         { return m_impl ? m_impl->find(c, start) : -1; }
97     int find(const char* str, int start = 0, bool caseSensitive = true) const
98         { return m_impl ? m_impl->find(str, start, caseSensitive) : -1; }
99     int find(const String& str, int start = 0, bool caseSensitive = true) const
100         { return m_impl ? m_impl->find(str.impl(), start, caseSensitive) : -1; }
101
102     int reverseFind(UChar c, int start = -1) const
103         { return m_impl ? m_impl->reverseFind(c, start) : -1; }
104     int reverseFind(const String& str, int start = -1, bool caseSensitive = true) const
105         { return m_impl ? m_impl->reverseFind(str.impl(), start, caseSensitive) : -1; }
106     
107     bool startsWith(const String& s, bool caseSensitive = true) const
108         { return m_impl ? m_impl->startsWith(s.impl(), caseSensitive) : s.isEmpty(); }
109     bool endsWith(const String& s, bool caseSensitive = true) const
110         { return m_impl ? m_impl->endsWith(s.impl(), caseSensitive) : s.isEmpty(); }
111
112     void append(const String&);
113     void append(char);
114     void append(UChar);
115     void append(const UChar*, unsigned length);
116     void insert(const String&, unsigned pos);
117     void insert(const UChar*, unsigned length, unsigned pos);
118
119     String& replace(UChar a, UChar b) { if (m_impl) m_impl = m_impl->replace(a, b); return *this; }
120     String& replace(UChar a, const String& b) { if (m_impl) m_impl = m_impl->replace(a, b.impl()); return *this; }
121     String& replace(const String& a, const String& b) { if (m_impl) m_impl = m_impl->replace(a.impl(), b.impl()); return *this; }
122     String& replace(unsigned index, unsigned len, const String& b) { if (m_impl) m_impl = m_impl->replace(index, len, b.impl()); return *this; }
123
124     void truncate(unsigned len);
125     void remove(unsigned pos, int len = 1);
126
127     String substring(unsigned pos, unsigned len = UINT_MAX) const;
128     String left(unsigned len) const { return substring(0, len); }
129     String right(unsigned len) const { return substring(length() - len, len); }
130
131     // Returns a lowercase/uppercase version of the string
132     String lower() const;
133     String upper() const;
134
135     String stripWhiteSpace() const;
136     String simplifyWhiteSpace() const;
137     
138     // Return the string with case folded for case insensitive comparison.
139     String foldCase() const;
140
141     static String number(int);
142     static String number(unsigned);
143     static String number(long);
144     static String number(unsigned long);
145     static String number(long long);
146     static String number(unsigned long long);
147     static String number(double);
148     
149     static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
150
151     void split(const String& separator, Vector<String>& result) const;
152     void split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const;
153     void split(UChar separator, Vector<String>& result) const;
154     void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const;
155
156     int toIntStrict(bool* ok = 0, int base = 10) const;
157     unsigned toUIntStrict(bool* ok = 0, int base = 10) const;
158     int64_t toInt64Strict(bool* ok = 0, int base = 10) const;
159     uint64_t toUInt64Strict(bool* ok = 0, int base = 10) const;
160
161     int toInt(bool* ok = 0) const;
162     unsigned toUInt(bool* ok = 0) const;
163     int64_t toInt64(bool* ok = 0) const;
164     uint64_t toUInt64(bool* ok = 0) const;
165     double toDouble(bool* ok = 0) const;
166     float toFloat(bool* ok = 0) const;
167     Length* toLengthArray(int& len) const;
168     Length* toCoordsArray(int& len) const;
169     bool percentage(int& percentage) const;
170
171     // Makes a deep copy. Helpful only if you need to use a String on another thread.
172     // Since the underlying StringImpl objects are immutable, there's no other reason
173     // to ever prefer copy() over plain old assignment.
174     String copy() const;
175
176     bool isNull() const { return !m_impl; }
177     bool isEmpty() const;
178
179     StringImpl* impl() const { return m_impl.get(); }
180
181 #if PLATFORM(CF)
182     String(CFStringRef);
183     CFStringRef createCFString() const;
184 #endif
185
186 #ifdef __OBJC__
187     String(NSString*);
188     
189     // This conversion maps NULL to "", which loses the meaning of NULL, but we 
190     // need this mapping because AppKit crashes when passed nil NSStrings.
191     operator NSString*() const { if (!m_impl) return @""; return *m_impl; }
192 #endif
193
194 #if PLATFORM(QT)
195     String(const QString&);
196     String(const QStringRef&);
197     operator QString() const;
198 #endif
199
200 #if PLATFORM(SYMBIAN)
201     String(const TDesC&);
202     operator TPtrC() const { return des(); }
203     TPtrC des() const { if (!m_impl) return KNullDesC(); return m_impl->des(); }
204 #endif
205
206 #if PLATFORM(WX)
207     String(const wxString&);
208     operator wxString() const;
209 #endif
210
211 #ifndef NDEBUG
212     Vector<char> ascii() const;
213 #endif
214
215     CString latin1() const;
216     CString utf8() const;
217
218     static String fromUTF8(const char*, size_t);
219     static String fromUTF8(const char*);
220
221     // Determines the writing direction using the Unicode Bidi Algorithm rules P2 and P3.
222     WTF::Unicode::Direction defaultWritingDirection() const { return m_impl ? m_impl->defaultWritingDirection() : WTF::Unicode::LeftToRight; }
223
224 private:
225     RefPtr<StringImpl> m_impl;
226 };
227
228 String operator+(const String&, const String&);
229 String operator+(const String&, const char*);
230 String operator+(const char*, const String&);
231
232 inline String& operator+=(String& a, const String& b) { a.append(b); return a; }
233
234 inline bool operator==(const String& a, const String& b) { return equal(a.impl(), b.impl()); }
235 inline bool operator==(const String& a, const char* b) { return equal(a.impl(), b); }
236 inline bool operator==(const char* a, const String& b) { return equal(a, b.impl()); }
237
238 inline bool operator!=(const String& a, const String& b) { return !equal(a.impl(), b.impl()); }
239 inline bool operator!=(const String& a, const char* b) { return !equal(a.impl(), b); }
240 inline bool operator!=(const char* a, const String& b) { return !equal(a, b.impl()); }
241
242 inline bool equalIgnoringCase(const String& a, const String& b) { return equalIgnoringCase(a.impl(), b.impl()); }
243 inline bool equalIgnoringCase(const String& a, const char* b) { return equalIgnoringCase(a.impl(), b); }
244 inline bool equalIgnoringCase(const char* a, const String& b) { return equalIgnoringCase(a, b.impl()); }
245
246 inline bool operator!(const String& str) { return str.isNull(); }
247
248 inline void swap(String& a, String& b) { a.swap(b); }
249
250 // String Operations
251
252 bool charactersAreAllASCII(const UChar*, size_t);
253
254 int charactersToIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
255 unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
256 int64_t charactersToInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
257 uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
258
259 int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
260 unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
261 int64_t charactersToInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
262 uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
263
264 double charactersToDouble(const UChar*, size_t, bool* ok = 0);
265 float charactersToFloat(const UChar*, size_t, bool* ok = 0);
266
267 int find(const UChar*, size_t, UChar, int startPosition = 0);
268 int reverseFind(const UChar*, size_t, UChar, int startPosition = -1);
269
270 void append(Vector<UChar>&, const String&);
271
272 #ifdef __OBJC__
273 // This is for situations in WebKit where the long standing behavior has been
274 // "nil if empty", so we try to maintain longstanding behavior for the sake of
275 // entrenched clients
276 inline NSString* nsStringNilIfEmpty(const String& str) {  return str.isEmpty() ? nil : (NSString*)str; }
277 #endif
278
279 inline bool charactersAreAllASCII(const UChar* characters, size_t length)
280 {
281     UChar ored = 0;
282     for (size_t i = 0; i < length; ++i)
283         ored |= characters[i];
284     return !(ored & 0xFF80);
285 }
286
287 inline int find(const UChar* characters, size_t length, UChar character, int startPosition)
288 {
289     if (startPosition >= static_cast<int>(length))
290         return -1;
291     for (size_t i = startPosition; i < length; ++i) {
292         if (characters[i] == character)
293             return static_cast<int>(i);
294     }
295     return -1;
296 }
297
298 inline int reverseFind(const UChar* characters, size_t length, UChar character, int startPosition)
299 {
300     if (startPosition >= static_cast<int>(length) || !length)
301         return -1;
302     if (startPosition < 0)
303         startPosition += static_cast<int>(length);
304     while (true) {
305         if (characters[startPosition] == character)
306             return startPosition;
307         if (!startPosition)
308             return -1;
309         startPosition--;
310     }
311     ASSERT_NOT_REACHED();
312     return -1;
313 }
314
315 inline void append(Vector<UChar>& vector, const String& string)
316 {
317     vector.append(string.characters(), string.length());
318 }
319
320 PassRefPtr<SharedBuffer> utf8Buffer(const String&);
321
322 } // namespace WebCore
323
324 namespace WTF {
325
326     // StringHash is the default hash for String
327     template<typename T> struct DefaultHash;
328     template<> struct DefaultHash<WebCore::String> {
329         typedef WebCore::StringHash Hash;
330     };
331
332 }
333
334 #endif