xpcom/string/nsString.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef nsString_h___
   8 #define nsString_h___
   9
  10 #include "mozilla/Attributes.h"
  11
  12 #include "nsSubstring.h"
  13 #include "nsDependentSubstring.h"
  14 #include "nsReadableUtils.h"
  15
  16 #include <new>
  17
  18 // enable support for the obsolete string API if not explicitly disabled
  19 #ifndef MOZ_STRING_WITH_OBSOLETE_API
  20 #define MOZ_STRING_WITH_OBSOLETE_API 1
  21 #endif
  22
  23 #if MOZ_STRING_WITH_OBSOLETE_API
  24 // radix values for ToInteger/AppendInt
  25 #define kRadix10        (10)
  26 #define kRadix16        (16)
  27 #define kAutoDetect     (100)
  28 #define kRadixUnknown   (kAutoDetect+1)
  29 #define IGNORE_CASE     (true)
  30 #endif
  31
  32
  33 // declare nsString, et. al.
  34 #include "string-template-def-unichar.h"
  35 #include "nsTString.h"
  36 #include "string-template-undef.h"
  37
  38 // declare nsCString, et. al.
  39 #include "string-template-def-char.h"
  40 #include "nsTString.h"
  41 #include "string-template-undef.h"
  42
  43 static_assert(sizeof(char16_t) == 2, "size of char16_t must be 2");
  44 static_assert(sizeof(nsString::char_type) == 2,
  45               "size of nsString::char_type must be 2");
  46 static_assert(nsString::char_type(-1) > nsString::char_type(0),
  47               "nsString::char_type must be unsigned");
  48 static_assert(sizeof(nsCString::char_type) == 1,
  49               "size of nsCString::char_type must be 1");
  50
  51
  52 /**
  53  * A helper class that converts a UTF-16 string to ASCII in a lossy manner
  54  */
  55 class NS_LossyConvertUTF16toASCII : public nsAutoCString
  56 {
  57 public:
  58   explicit NS_LossyConvertUTF16toASCII(const char16_t* aString)
  59   {
  60     LossyAppendUTF16toASCII(aString, *this);
  61   }
  62
  63   NS_LossyConvertUTF16toASCII(const char16_t* aString, uint32_t aLength)
  64   {
  65     LossyAppendUTF16toASCII(Substring(aString, aLength), *this);
  66   }
  67
  68 #ifdef MOZ_USE_CHAR16_WRAPPER
  69   explicit NS_LossyConvertUTF16toASCII(char16ptr_t aString)
  70     : NS_LossyConvertUTF16toASCII(static_cast<const char16_t*>(aString))
  71   {
  72   }
  73
  74   NS_LossyConvertUTF16toASCII(char16ptr_t aString, uint32_t aLength)
  75     : NS_LossyConvertUTF16toASCII(static_cast<const char16_t*>(aString), aLength)
  76   {
  77   }
  78 #endif
  79
  80   explicit NS_LossyConvertUTF16toASCII(const nsAString& aString)
  81   {
  82     LossyAppendUTF16toASCII(aString, *this);
  83   }
  84
  85 private:
  86   // NOT TO BE IMPLEMENTED
  87   NS_LossyConvertUTF16toASCII(char) MOZ_DELETE;
  88 };
  89
  90
  91 class NS_ConvertASCIItoUTF16 : public nsAutoString
  92 {
  93 public:
  94   explicit NS_ConvertASCIItoUTF16(const char* aCString)
  95   {
  96     AppendASCIItoUTF16(aCString, *this);
  97   }
  98
  99   NS_ConvertASCIItoUTF16(const char* aCString, uint32_t aLength)
 100   {
 101     AppendASCIItoUTF16(Substring(aCString, aLength), *this);
 102   }
 103
 104   explicit NS_ConvertASCIItoUTF16(const nsACString& aCString)
 105   {
 106     AppendASCIItoUTF16(aCString, *this);
 107   }
 108
 109 private:
 110   // NOT TO BE IMPLEMENTED
 111   NS_ConvertASCIItoUTF16(char16_t) MOZ_DELETE;
 112 };
 113
 114
 115 /**
 116  * A helper class that converts a UTF-16 string to UTF-8
 117  */
 118 class NS_ConvertUTF16toUTF8 : public nsAutoCString
 119 {
 120 public:
 121   explicit NS_ConvertUTF16toUTF8(const char16_t* aString)
 122   {
 123     AppendUTF16toUTF8(aString, *this);
 124   }
 125
 126   NS_ConvertUTF16toUTF8(const char16_t* aString, uint32_t aLength)
 127   {
 128     AppendUTF16toUTF8(Substring(aString, aLength), *this);
 129   }
 130
 131 #ifdef MOZ_USE_CHAR16_WRAPPER
 132   NS_ConvertUTF16toUTF8(char16ptr_t aString)
 133     : NS_ConvertUTF16toUTF8(static_cast<const char16_t*>(aString))
 134   {
 135   }
 136
 137   NS_ConvertUTF16toUTF8(char16ptr_t aString, uint32_t aLength)
 138     : NS_ConvertUTF16toUTF8(static_cast<const char16_t*>(aString), aLength)
 139   {
 140   }
 141 #endif
 142
 143   explicit NS_ConvertUTF16toUTF8(const nsAString& aString)
 144   {
 145     AppendUTF16toUTF8(aString, *this);
 146   }
 147
 148 private:
 149   // NOT TO BE IMPLEMENTED
 150   NS_ConvertUTF16toUTF8(char) MOZ_DELETE;
 151 };
 152
 153
 154 class NS_ConvertUTF8toUTF16 : public nsAutoString
 155 {
 156 public:
 157   explicit NS_ConvertUTF8toUTF16(const char* aCString)
 158   {
 159     AppendUTF8toUTF16(aCString, *this);
 160   }
 161
 162   NS_ConvertUTF8toUTF16(const char* aCString, uint32_t aLength)
 163   {
 164     AppendUTF8toUTF16(Substring(aCString, aLength), *this);
 165   }
 166
 167   explicit NS_ConvertUTF8toUTF16(const nsACString& aCString)
 168   {
 169     AppendUTF8toUTF16(aCString, *this);
 170   }
 171
 172 private:
 173   // NOT TO BE IMPLEMENTED
 174   NS_ConvertUTF8toUTF16(char16_t) MOZ_DELETE;
 175 };
 176
 177
 178 #ifdef MOZ_USE_CHAR16_WRAPPER
 179
 180 inline char16_t*
 181 wwc(wchar_t* aStr)
 182 {
 183   return reinterpret_cast<char16_t*>(aStr);
 184 }
 185
 186 inline wchar_t*
 187 wwc(char16_t* aStr)
 188 {
 189   return reinterpret_cast<wchar_t*>(aStr);
 190 }
 191
 192 #else
 193
 194 inline char16_t*
 195 wwc(char16_t* aStr)
 196 {
 197   return aStr;
 198 }
 199
 200 #endif
 201
 202 // the following are included/declared for backwards compatibility
 203 typedef nsAutoString nsVoidableString;
 204
 205 #include "nsDependentString.h"
 206 #include "nsLiteralString.h"
 207 #include "nsPromiseFlatString.h"
 208
 209 // need to include these for backwards compatibility
 210 #include "nsMemory.h"
 211 #include <string.h>
 212 #include <stdio.h>
 213 #include "plhash.h"
 214
 215 #endif // !defined(nsString_h___)