Home | History | Annotate | Download | only in public 
      1 /*
      2  * Copyright (C) 2009 Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #ifndef WebString_h
     32 #define WebString_h
     33 
     34 #include "WebCommon.h"
     35 
     36 #if WEBKIT_IMPLEMENTATION
     37 namespace WebCore {
     38 class String;
     39 class AtomicString;
     40 }
     41 #else
     42 #include <base/nullable_string16.h>
     43 #include <base/string16.h>
     44 #endif
     45 
     46 namespace WebKit {
     47 
     48 class WebCString;
     49 class WebStringPrivate;
     50 
     51 // A UTF-16 string container.  It is inexpensive to copy a WebString
     52 // object.
     53 //
     54 // WARNING: It is not safe to pass a WebString across threads!!!
     55 //
     56 class WebString {
     57 public:
     58     ~WebString() { reset(); }
     59 
     60     WebString() : m_private(0) { }
     61 
     62     WebString(const WebUChar* data, size_t len) : m_private(0)
     63     {
     64         assign(data, len);
     65     }
     66 
     67     WebString(const WebString& s) : m_private(0) { assign(s); }
     68 
     69     WebString& operator=(const WebString& s)
     70     {
     71         assign(s);
     72         return *this;
     73     }
     74 
     75     WEBKIT_API void reset();
     76     WEBKIT_API void assign(const WebString&);
     77     WEBKIT_API void assign(const WebUChar* data, size_t len);
     78 
     79     WEBKIT_API bool equals(const WebString& s) const;
     80 
     81     WEBKIT_API size_t length() const;
     82     WEBKIT_API const WebUChar* data() const;
     83 
     84     bool isEmpty() const { return !length(); }
     85     bool isNull() const { return !m_private; }
     86 
     87     WEBKIT_API WebCString utf8() const;
     88 
     89     WEBKIT_API static WebString fromUTF8(const char* data, size_t length);
     90     WEBKIT_API static WebString fromUTF8(const char* data);
     91 
     92     template <int N> WebString(const char (&data)[N])
     93         : m_private(0)
     94     {
     95         assign(fromUTF8(data, N - 1));
     96     }
     97 
     98     template <int N> WebString& operator=(const char (&data)[N])
     99     {
    100         assign(fromUTF8(data, N - 1));
    101         return *this;
    102     }
    103 
    104 #if WEBKIT_IMPLEMENTATION
    105     WebString(const WebCore::String&);
    106     WebString& operator=(const WebCore::String&);
    107     operator WebCore::String() const;
    108 
    109     WebString(const WebCore::AtomicString&);
    110     WebString& operator=(const WebCore::AtomicString&);
    111     operator WebCore::AtomicString() const;
    112 #else
    113 
    114     WebString(const string16& s) : m_private(0)
    115     {
    116         assign(s.data(), s.length());
    117     }
    118 
    119     WebString& operator=(const string16& s)
    120     {
    121         assign(s.data(), s.length());
    122         return *this;
    123     }
    124 
    125     operator string16() const
    126     {
    127         size_t len = length();
    128         return len ? string16(data(), len) : string16();
    129     }
    130 
    131     WebString(const NullableString16& s) : m_private(0)
    132     {
    133         if (s.is_null())
    134             assign(0);
    135         else
    136             assign(s.string().data(), s.string().length());
    137     }
    138 
    139     WebString& operator=(const NullableString16& s)
    140     {
    141         if (s.is_null())
    142             assign(0);
    143         else
    144             assign(s.string().data(), s.string().length());
    145         return *this;
    146     }
    147 
    148     operator NullableString16() const
    149     {
    150         if (!m_private)
    151             return NullableString16(string16(), true);
    152         size_t len = length();
    153         return NullableString16(len ? string16(data(), len) : string16(), false);
    154     }
    155 
    156     template <class UTF8String>
    157     static WebString fromUTF8(const UTF8String& s)
    158     {
    159         return fromUTF8(s.data(), s.length());
    160     }
    161 #endif
    162 
    163 private:
    164     void assign(WebStringPrivate*);
    165     WebStringPrivate* m_private;
    166 };
    167 
    168 inline bool operator==(const WebString& a, const WebString& b)
    169 {
    170     return a.equals(b);
    171 }
    172 
    173 inline bool operator!=(const WebString& a, const WebString& b)
    174 {
    175     return !(a == b);
    176 }
    177 
    178 } // namespace WebKit
    179 
    180 #endif
    181