Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/unicode/char16ptr.h @ 69:33d812a61356

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
author jpayne
date Tue, 18 Mar 2025 17:55:14 -0400
parents
children
comparison
equal deleted inserted replaced
67:0e9998148a16 69:33d812a61356
1 // © 2017 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3
4 // char16ptr.h
5 // created: 2017feb28 Markus W. Scherer
6
7 #ifndef __CHAR16PTR_H__
8 #define __CHAR16PTR_H__
9
10 #include "unicode/utypes.h"
11
12 #if U_SHOW_CPLUSPLUS_API
13
14 #include <cstddef>
15
16 /**
17 * \file
18 * \brief C++ API: char16_t pointer wrappers with
19 * implicit conversion from bit-compatible raw pointer types.
20 * Also conversion functions from char16_t * to UChar * and OldUChar *.
21 */
22
23 U_NAMESPACE_BEGIN
24
25 /**
26 * \def U_ALIASING_BARRIER
27 * Barrier for pointer anti-aliasing optimizations even across function boundaries.
28 * @internal
29 */
30 #ifdef U_ALIASING_BARRIER
31 // Use the predefined value.
32 #elif (defined(__clang__) || defined(__GNUC__)) && U_PLATFORM != U_PF_BROWSER_NATIVE_CLIENT
33 # define U_ALIASING_BARRIER(ptr) asm volatile("" : : "rm"(ptr) : "memory")
34 #elif defined(U_IN_DOXYGEN)
35 # define U_ALIASING_BARRIER(ptr)
36 #endif
37
38 /**
39 * char16_t * wrapper with implicit conversion from distinct but bit-compatible pointer types.
40 * @stable ICU 59
41 */
42 class U_COMMON_API Char16Ptr U_FINAL {
43 public:
44 /**
45 * Copies the pointer.
46 * @param p pointer
47 * @stable ICU 59
48 */
49 inline Char16Ptr(char16_t *p);
50 #if !U_CHAR16_IS_TYPEDEF
51 /**
52 * Converts the pointer to char16_t *.
53 * @param p pointer to be converted
54 * @stable ICU 59
55 */
56 inline Char16Ptr(uint16_t *p);
57 #endif
58 #if U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN)
59 /**
60 * Converts the pointer to char16_t *.
61 * (Only defined if U_SIZEOF_WCHAR_T==2.)
62 * @param p pointer to be converted
63 * @stable ICU 59
64 */
65 inline Char16Ptr(wchar_t *p);
66 #endif
67 /**
68 * nullptr constructor.
69 * @param p nullptr
70 * @stable ICU 59
71 */
72 inline Char16Ptr(std::nullptr_t p);
73 /**
74 * Destructor.
75 * @stable ICU 59
76 */
77 inline ~Char16Ptr();
78
79 /**
80 * Pointer access.
81 * @return the wrapped pointer
82 * @stable ICU 59
83 */
84 inline char16_t *get() const;
85 /**
86 * char16_t pointer access via type conversion (e.g., static_cast).
87 * @return the wrapped pointer
88 * @stable ICU 59
89 */
90 inline operator char16_t *() const { return get(); }
91
92 private:
93 Char16Ptr() = delete;
94
95 #ifdef U_ALIASING_BARRIER
96 template<typename T> static char16_t *cast(T *t) {
97 U_ALIASING_BARRIER(t);
98 return reinterpret_cast<char16_t *>(t);
99 }
100
101 char16_t *p_;
102 #else
103 union {
104 char16_t *cp;
105 uint16_t *up;
106 wchar_t *wp;
107 } u_;
108 #endif
109 };
110
111 /// \cond
112 #ifdef U_ALIASING_BARRIER
113
114 Char16Ptr::Char16Ptr(char16_t *p) : p_(p) {}
115 #if !U_CHAR16_IS_TYPEDEF
116 Char16Ptr::Char16Ptr(uint16_t *p) : p_(cast(p)) {}
117 #endif
118 #if U_SIZEOF_WCHAR_T==2
119 Char16Ptr::Char16Ptr(wchar_t *p) : p_(cast(p)) {}
120 #endif
121 Char16Ptr::Char16Ptr(std::nullptr_t p) : p_(p) {}
122 Char16Ptr::~Char16Ptr() {
123 U_ALIASING_BARRIER(p_);
124 }
125
126 char16_t *Char16Ptr::get() const { return p_; }
127
128 #else
129
130 Char16Ptr::Char16Ptr(char16_t *p) { u_.cp = p; }
131 #if !U_CHAR16_IS_TYPEDEF
132 Char16Ptr::Char16Ptr(uint16_t *p) { u_.up = p; }
133 #endif
134 #if U_SIZEOF_WCHAR_T==2
135 Char16Ptr::Char16Ptr(wchar_t *p) { u_.wp = p; }
136 #endif
137 Char16Ptr::Char16Ptr(std::nullptr_t p) { u_.cp = p; }
138 Char16Ptr::~Char16Ptr() {}
139
140 char16_t *Char16Ptr::get() const { return u_.cp; }
141
142 #endif
143 /// \endcond
144
145 /**
146 * const char16_t * wrapper with implicit conversion from distinct but bit-compatible pointer types.
147 * @stable ICU 59
148 */
149 class U_COMMON_API ConstChar16Ptr U_FINAL {
150 public:
151 /**
152 * Copies the pointer.
153 * @param p pointer
154 * @stable ICU 59
155 */
156 inline ConstChar16Ptr(const char16_t *p);
157 #if !U_CHAR16_IS_TYPEDEF
158 /**
159 * Converts the pointer to char16_t *.
160 * @param p pointer to be converted
161 * @stable ICU 59
162 */
163 inline ConstChar16Ptr(const uint16_t *p);
164 #endif
165 #if U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN)
166 /**
167 * Converts the pointer to char16_t *.
168 * (Only defined if U_SIZEOF_WCHAR_T==2.)
169 * @param p pointer to be converted
170 * @stable ICU 59
171 */
172 inline ConstChar16Ptr(const wchar_t *p);
173 #endif
174 /**
175 * nullptr constructor.
176 * @param p nullptr
177 * @stable ICU 59
178 */
179 inline ConstChar16Ptr(const std::nullptr_t p);
180
181 /**
182 * Destructor.
183 * @stable ICU 59
184 */
185 inline ~ConstChar16Ptr();
186
187 /**
188 * Pointer access.
189 * @return the wrapped pointer
190 * @stable ICU 59
191 */
192 inline const char16_t *get() const;
193 /**
194 * char16_t pointer access via type conversion (e.g., static_cast).
195 * @return the wrapped pointer
196 * @stable ICU 59
197 */
198 inline operator const char16_t *() const { return get(); }
199
200 private:
201 ConstChar16Ptr() = delete;
202
203 #ifdef U_ALIASING_BARRIER
204 template<typename T> static const char16_t *cast(const T *t) {
205 U_ALIASING_BARRIER(t);
206 return reinterpret_cast<const char16_t *>(t);
207 }
208
209 const char16_t *p_;
210 #else
211 union {
212 const char16_t *cp;
213 const uint16_t *up;
214 const wchar_t *wp;
215 } u_;
216 #endif
217 };
218
219 /// \cond
220 #ifdef U_ALIASING_BARRIER
221
222 ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) : p_(p) {}
223 #if !U_CHAR16_IS_TYPEDEF
224 ConstChar16Ptr::ConstChar16Ptr(const uint16_t *p) : p_(cast(p)) {}
225 #endif
226 #if U_SIZEOF_WCHAR_T==2
227 ConstChar16Ptr::ConstChar16Ptr(const wchar_t *p) : p_(cast(p)) {}
228 #endif
229 ConstChar16Ptr::ConstChar16Ptr(const std::nullptr_t p) : p_(p) {}
230 ConstChar16Ptr::~ConstChar16Ptr() {
231 U_ALIASING_BARRIER(p_);
232 }
233
234 const char16_t *ConstChar16Ptr::get() const { return p_; }
235
236 #else
237
238 ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) { u_.cp = p; }
239 #if !U_CHAR16_IS_TYPEDEF
240 ConstChar16Ptr::ConstChar16Ptr(const uint16_t *p) { u_.up = p; }
241 #endif
242 #if U_SIZEOF_WCHAR_T==2
243 ConstChar16Ptr::ConstChar16Ptr(const wchar_t *p) { u_.wp = p; }
244 #endif
245 ConstChar16Ptr::ConstChar16Ptr(const std::nullptr_t p) { u_.cp = p; }
246 ConstChar16Ptr::~ConstChar16Ptr() {}
247
248 const char16_t *ConstChar16Ptr::get() const { return u_.cp; }
249
250 #endif
251 /// \endcond
252
253 /**
254 * Converts from const char16_t * to const UChar *.
255 * Includes an aliasing barrier if available.
256 * @param p pointer
257 * @return p as const UChar *
258 * @stable ICU 59
259 */
260 inline const UChar *toUCharPtr(const char16_t *p) {
261 #ifdef U_ALIASING_BARRIER
262 U_ALIASING_BARRIER(p);
263 #endif
264 return reinterpret_cast<const UChar *>(p);
265 }
266
267 /**
268 * Converts from char16_t * to UChar *.
269 * Includes an aliasing barrier if available.
270 * @param p pointer
271 * @return p as UChar *
272 * @stable ICU 59
273 */
274 inline UChar *toUCharPtr(char16_t *p) {
275 #ifdef U_ALIASING_BARRIER
276 U_ALIASING_BARRIER(p);
277 #endif
278 return reinterpret_cast<UChar *>(p);
279 }
280
281 /**
282 * Converts from const char16_t * to const OldUChar *.
283 * Includes an aliasing barrier if available.
284 * @param p pointer
285 * @return p as const OldUChar *
286 * @stable ICU 59
287 */
288 inline const OldUChar *toOldUCharPtr(const char16_t *p) {
289 #ifdef U_ALIASING_BARRIER
290 U_ALIASING_BARRIER(p);
291 #endif
292 return reinterpret_cast<const OldUChar *>(p);
293 }
294
295 /**
296 * Converts from char16_t * to OldUChar *.
297 * Includes an aliasing barrier if available.
298 * @param p pointer
299 * @return p as OldUChar *
300 * @stable ICU 59
301 */
302 inline OldUChar *toOldUCharPtr(char16_t *p) {
303 #ifdef U_ALIASING_BARRIER
304 U_ALIASING_BARRIER(p);
305 #endif
306 return reinterpret_cast<OldUChar *>(p);
307 }
308
309 U_NAMESPACE_END
310
311 #endif /* U_SHOW_CPLUSPLUS_API */
312
313 #endif // __CHAR16PTR_H__