third_party/WebKit/public/platform/WebString.h

   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 #include "WebPrivatePtr.h"
  36 #include <string>
  37
  38 #if INSIDE_BLINK
  39 #include "wtf/Forward.h"
  40 #else
  41 #include <base/strings/latin1_string_conversions.h>
  42 #include <base/strings/nullable_string16.h>
  43 #include <base/strings/string16.h>
  44 #endif
  45
  46 namespace WTF {
  47 class StringImpl;
  48 }
  49
  50 namespace blink {
  51
  52 // A UTF-16 string container.  It is inexpensive to copy a WebString
  53 // object.
  54 //
  55 // WARNING: It is not safe to pass a WebString across threads!!!
  56 //
  57 class WebString {
  58 public:
  59     ~WebString() { reset(); }
  60
  61     WebString() { }
  62
  63     WebString(const WebUChar* data, size_t len)
  64     {
  65         assign(data, len);
  66     }
  67
  68     WebString(const WebString& s) { assign(s); }
  69
  70     WebString& operator=(const WebString& s)
  71     {
  72         assign(s);
  73         return *this;
  74     }
  75
  76     BLINK_COMMON_EXPORT void reset();
  77     BLINK_COMMON_EXPORT void assign(const WebString&);
  78     BLINK_COMMON_EXPORT void assign(const WebUChar* data, size_t len);
  79
  80     BLINK_COMMON_EXPORT bool equals(const WebString&) const;
  81
  82     BLINK_COMMON_EXPORT size_t length() const;
  83
  84     // Caller must check bounds.
  85     BLINK_COMMON_EXPORT WebUChar at(unsigned) const;
  86
  87     bool isEmpty() const { return !length(); }
  88     bool isNull() const { return m_private.isNull(); }
  89
  90     BLINK_COMMON_EXPORT std::string utf8() const;
  91
  92     BLINK_COMMON_EXPORT static WebString fromUTF8(const char* data, size_t length);
  93     BLINK_COMMON_EXPORT static WebString fromUTF8(const char* data);
  94
  95     static WebString fromUTF8(const std::string& s)
  96     {
  97         return fromUTF8(s.data(), s.length());
  98     }
  99
 100     BLINK_COMMON_EXPORT std::string latin1() const;
 101
 102     BLINK_COMMON_EXPORT static WebString fromLatin1(const WebLChar* data, size_t length);
 103
 104     static WebString fromLatin1(const std::string& s)
 105     {
 106         return fromLatin1(reinterpret_cast<const WebLChar*>(s.data()), s.length());
 107     }
 108
 109     template <int N> WebString(const char (&data)[N])
 110     {
 111         assign(fromUTF8(data, N - 1));
 112     }
 113
 114     template <int N> WebString& operator=(const char (&data)[N])
 115     {
 116         assign(fromUTF8(data, N - 1));
 117         return *this;
 118     }
 119
 120 #if INSIDE_BLINK
 121     BLINK_COMMON_EXPORT WebString(const WTF::String&);
 122     BLINK_COMMON_EXPORT WebString& operator=(const WTF::String&);
 123     BLINK_COMMON_EXPORT operator WTF::String() const;
 124
 125     BLINK_COMMON_EXPORT WebString(const WTF::AtomicString&);
 126     BLINK_COMMON_EXPORT WebString& operator=(const WTF::AtomicString&);
 127     BLINK_COMMON_EXPORT operator WTF::AtomicString() const;
 128 #else
 129     WebString(const base::string16& s)
 130     {
 131         assign(s.data(), s.length());
 132     }
 133
 134     WebString& operator=(const base::string16& s)
 135     {
 136         assign(s.data(), s.length());
 137         return *this;
 138     }
 139
 140     operator base::string16() const
 141     {
 142         return base::Latin1OrUTF16ToUTF16(length(), data8(), data16());
 143     }
 144
 145     WebString(const base::NullableString16& s)
 146     {
 147         if (s.is_null())
 148             reset();
 149         else
 150             assign(s.string().data(), s.string().length());
 151     }
 152
 153     WebString& operator=(const base::NullableString16& s)
 154     {
 155         if (s.is_null())
 156             reset();
 157         else
 158             assign(s.string().data(), s.string().length());
 159         return *this;
 160     }
 161
 162     operator base::NullableString16() const
 163     {
 164         return base::NullableString16(operator base::string16(), m_private.isNull());
 165     }
 166 #endif
 167
 168 private:
 169     BLINK_COMMON_EXPORT bool is8Bit() const;
 170     BLINK_COMMON_EXPORT const WebLChar* data8() const;
 171     BLINK_COMMON_EXPORT const WebUChar* data16() const;
 172
 173     BLINK_COMMON_EXPORT void assign(WTF::StringImpl*);
 174
 175     WebPrivatePtr<WTF::StringImpl> m_private;
 176 };
 177
 178 inline bool operator==(const WebString& a, const WebString& b)
 179 {
 180     return a.equals(b);
 181 }
 182
 183 inline bool operator!=(const WebString& a, const WebString& b)
 184 {
 185     return !(a == b);
 186 }
 187
 188 } // namespace blink
 189
 190 #endif