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