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