Unify Number to StringImpl conversion
[WebKit-https.git] / Source / JavaScriptCore / runtime / UString.h
1 /*
2  * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
4  * Copyright (C) 2009 Google Inc. All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public License
17  * along with this library; see the file COPYING.LIB.  If not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  * Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef UString_h
24 #define UString_h
25
26 #include <wtf/text/IntegerToStringConversion.h>
27 #include <wtf/text/StringImpl.h>
28
29 namespace JSC {
30
31 class UString {
32 public:
33     // Construct a null string, distinguishable from an empty string.
34     UString() { }
35
36     // Construct a string with UTF-16 data.
37     JS_EXPORT_PRIVATE UString(const UChar* characters, unsigned length);
38
39     // Construct a string with UTF-16 data, from a null-terminated source.
40     JS_EXPORT_PRIVATE UString(const UChar*);
41
42     // Construct a string with latin1 data.
43     UString(const LChar* characters, unsigned length);
44     JS_EXPORT_PRIVATE UString(const char* characters, unsigned length);
45
46     // Construct a string with latin1 data, from a null-terminated source.
47     UString(const LChar* characters);
48     JS_EXPORT_PRIVATE UString(const char* characters);
49
50     // Construct a string referencing an existing StringImpl.
51     UString(StringImpl* impl) : m_impl(impl) { }
52     UString(PassRefPtr<StringImpl> impl) : m_impl(impl) { }
53     UString(RefPtr<StringImpl> impl) : m_impl(impl) { }
54
55     // Inline the destructor.
56     ALWAYS_INLINE ~UString() { }
57
58     void swap(UString& o) { m_impl.swap(o.m_impl); }
59
60     template<typename CharType, size_t inlineCapacity>
61     static UString adopt(Vector<CharType, inlineCapacity>& vector) { return StringImpl::adopt(vector); }
62
63     bool isNull() const { return !m_impl; }
64     bool isEmpty() const { return !m_impl || !m_impl->length(); }
65
66     StringImpl* impl() const { return m_impl.get(); }
67
68     unsigned length() const
69     {
70         if (!m_impl)
71             return 0;
72         return m_impl->length();
73     }
74
75     const UChar* characters() const
76     {
77         if (!m_impl)
78             return 0;
79         return m_impl->characters();
80     }
81
82     const LChar* characters8() const
83     {
84         if (!m_impl)
85             return 0;
86         ASSERT(m_impl->is8Bit());
87         return m_impl->characters8();
88     }
89
90     const UChar* characters16() const
91     {
92         if (!m_impl)
93             return 0;
94         ASSERT(!m_impl->is8Bit());
95         return m_impl->characters16();
96     }
97
98     template <typename CharType>
99     inline const CharType* getCharacters() const;
100
101     bool is8Bit() const { return m_impl->is8Bit(); }
102
103     JS_EXPORT_PRIVATE CString ascii() const;
104     CString latin1() const;
105     JS_EXPORT_PRIVATE CString utf8(bool strict = false) const;
106
107     UChar operator[](unsigned index) const
108     {
109         if (!m_impl || index >= m_impl->length())
110             return 0;
111         if (is8Bit())
112             return m_impl->characters8()[index];
113         return m_impl->characters16()[index];
114     }
115
116     static UString number(int i) { return WTF::numberToStringImpl(i); }
117     static UString number(unsigned u) { return WTF::numberToStringImpl(u); }
118     static UString number(long i) { return WTF::numberToStringImpl(i); }
119     static UString number(long long i) { return WTF::numberToStringImpl(i); }
120     JS_EXPORT_PRIVATE static UString number(double);
121
122     // Find a single character or string, also with match function & latin1 forms.
123     size_t find(UChar c, unsigned start = 0) const
124         { return m_impl ? m_impl->find(c, start) : notFound; }
125
126     size_t find(const UString& str) const
127         { return m_impl ? m_impl->find(str.impl()) : notFound; }
128     size_t find(const UString& str, unsigned start) const
129         { return m_impl ? m_impl->find(str.impl(), start) : notFound; }
130
131     size_t find(const LChar* str, unsigned start = 0) const
132         { return m_impl ? m_impl->find(str, start) : notFound; }
133
134     // Find the last instance of a single character or string.
135     size_t reverseFind(UChar c, unsigned start = UINT_MAX) const
136         { return m_impl ? m_impl->reverseFind(c, start) : notFound; }
137     size_t reverseFind(const UString& str, unsigned start = UINT_MAX) const
138         { return m_impl ? m_impl->reverseFind(str.impl(), start) : notFound; }
139
140     JS_EXPORT_PRIVATE UString substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
141
142 private:
143     RefPtr<StringImpl> m_impl;
144 };
145
146 template<>
147 inline const LChar* UString::getCharacters<LChar>() const { return characters8(); }
148
149 template<>
150 inline const UChar* UString::getCharacters<UChar>() const { return characters(); }
151
152 NEVER_INLINE bool equalSlowCase(const UString& s1, const UString& s2);
153
154 ALWAYS_INLINE bool operator==(const UString& s1, const UString& s2)
155 {
156     StringImpl* rep1 = s1.impl();
157     StringImpl* rep2 = s2.impl();
158
159     if (rep1 == rep2) // If they're the same rep, they're equal.
160         return true;
161
162     unsigned size1 = 0;
163     unsigned size2 = 0;
164
165     if (rep1)
166         size1 = rep1->length();
167
168     if (rep2)
169         size2 = rep2->length();
170
171     if (size1 != size2) // If the lengths are not the same, we're done.
172         return false;
173
174     if (!size1)
175         return true;
176
177     if (size1 == 1)
178         return (*rep1)[0u] == (*rep2)[0u];
179
180     return equalSlowCase(s1, s2);
181 }
182
183
184 inline bool operator!=(const UString& s1, const UString& s2)
185 {
186     return !JSC::operator==(s1, s2);
187 }
188
189 JS_EXPORT_PRIVATE bool operator<(const UString& s1, const UString& s2);
190 JS_EXPORT_PRIVATE bool operator>(const UString& s1, const UString& s2);
191
192 JS_EXPORT_PRIVATE bool operator==(const UString& s1, const char* s2);
193
194 inline bool operator!=(const UString& s1, const char* s2)
195 {
196     return !JSC::operator==(s1, s2);
197 }
198
199 inline bool operator==(const char *s1, const UString& s2)
200 {
201     return operator==(s2, s1);
202 }
203
204 inline bool operator!=(const char *s1, const UString& s2)
205 {
206     return !JSC::operator==(s1, s2);
207 }
208
209 inline int codePointCompare(const UString& s1, const UString& s2)
210 {
211     return codePointCompare(s1.impl(), s2.impl());
212 }
213
214 struct UStringHash {
215     static unsigned hash(StringImpl* key) { return key->hash(); }
216     static bool equal(const StringImpl* a, const StringImpl* b)
217     {
218         if (a == b)
219             return true;
220         if (!a || !b)
221             return false;
222
223         unsigned aLength = a->length();
224         unsigned bLength = b->length();
225         if (aLength != bLength)
226             return false;
227
228         // FIXME: perhaps we should have a more abstract macro that indicates when
229         // going 4 bytes at a time is unsafe
230 #if CPU(ARM) || CPU(SH4) || CPU(MIPS) || CPU(SPARC)
231         const UChar* aChars = a->characters();
232         const UChar* bChars = b->characters();
233         for (unsigned i = 0; i != aLength; ++i) {
234             if (*aChars++ != *bChars++)
235                 return false;
236         }
237         return true;
238 #else
239         /* Do it 4-bytes-at-a-time on architectures where it's safe */
240         const uint32_t* aChars = reinterpret_cast<const uint32_t*>(a->characters());
241         const uint32_t* bChars = reinterpret_cast<const uint32_t*>(b->characters());
242
243         unsigned halfLength = aLength >> 1;
244         for (unsigned i = 0; i != halfLength; ++i)
245             if (*aChars++ != *bChars++)
246                 return false;
247
248         if (aLength & 1 && *reinterpret_cast<const uint16_t*>(aChars) != *reinterpret_cast<const uint16_t*>(bChars))
249             return false;
250
251         return true;
252 #endif
253     }
254
255     static unsigned hash(const RefPtr<StringImpl>& key) { return key->hash(); }
256     static bool equal(const RefPtr<StringImpl>& a, const RefPtr<StringImpl>& b)
257     {
258         return equal(a.get(), b.get());
259     }
260
261     static unsigned hash(const UString& key) { return key.impl()->hash(); }
262     static bool equal(const UString& a, const UString& b)
263     {
264         return equal(a.impl(), b.impl());
265     }
266
267     static const bool safeToCompareToEmptyOrDeleted = false;
268 };
269
270 } // namespace JSC
271
272 namespace WTF {
273
274 // UStringHash is the default hash for UString
275 template<typename T> struct DefaultHash;
276 template<> struct DefaultHash<JSC::UString> {
277     typedef JSC::UStringHash Hash;
278 };
279
280 template <> struct VectorTraits<JSC::UString> : SimpleClassVectorTraits { };
281
282 } // namespace WTF
283
284 #endif
285