include/rtl/character.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 /*
  21  * This file is part of LibreOffice published API.
  22  */
  23
  24 #ifndef INCLUDED_RTL_CHARACTER_HXX
  25 #define INCLUDED_RTL_CHARACTER_HXX
  26
  27 #include "sal/config.h"
  28
  29 #include <cassert>
  30 #include <cstddef>
  31
  32 #include "sal/types.h"
  33
  34 namespace rtl
  35 {
  36 /** Check for Unicode code point.
  37
  38     @param code  An integer.
  39
  40     @return  True if code is a Unicode code point.
  41
  42     @since LibreOffice 5.2
  43 */
  44 inline SAL_CONSTEXPR bool isUnicodeCodePoint(sal_uInt32 code) { return code <= 0x10FFFF; }
  45
  46 /** Check for ASCII character.
  47
  48     @param code  A Unicode code point.
  49
  50     @return  True if code is an ASCII character (0x00--0x7F).
  51
  52     @since LibreOffice 4.1
  53  */
  54 inline SAL_CONSTEXPR bool isAscii(sal_uInt32 code)
  55 {
  56     assert(isUnicodeCodePoint(code));
  57     return code <= 0x7F;
  58 }
  59
  60 #if defined LIBO_INTERNAL_ONLY
  61 bool isAscii(char) = delete;
  62 bool isAscii(signed char) = delete;
  63 template <typename T> inline constexpr bool isAscii(T code) { return isAscii(sal_uInt32(code)); }
  64 #endif
  65
  66 /** Check for ASCII lower case character.
  67
  68     @param code  A Unicode code point.
  69
  70     @return  True if code is an ASCII lower case alphabetic character (ASCII
  71     'a'--'z').
  72
  73     @since LibreOffice 4.1
  74  */
  75 inline SAL_CONSTEXPR bool isAsciiLowerCase(sal_uInt32 code)
  76 {
  77     assert(isUnicodeCodePoint(code));
  78     return code >= 'a' && code <= 'z';
  79 }
  80
  81 #if defined LIBO_INTERNAL_ONLY
  82 bool isAsciiLowerCase(char) = delete;
  83 bool isAsciiLowerCase(signed char) = delete;
  84 template <typename T> inline constexpr bool isAsciiLowerCase(T code)
  85 {
  86     return isAsciiLowerCase(sal_uInt32(code));
  87 }
  88 #endif
  89
  90 /** Check for ASCII upper case character.
  91
  92     @param code  A Unicode code point.
  93
  94     @return  True if code is an ASCII upper case alphabetic character (ASCII
  95     'A'--'Z').
  96
  97     @since LibreOffice 4.1
  98  */
  99 inline SAL_CONSTEXPR bool isAsciiUpperCase(sal_uInt32 code)
 100 {
 101     assert(isUnicodeCodePoint(code));
 102     return code >= 'A' && code <= 'Z';
 103 }
 104
 105 #if defined LIBO_INTERNAL_ONLY
 106 bool isAsciiUpperCase(char) = delete;
 107 bool isAsciiUpperCase(signed char) = delete;
 108 template <typename T> inline constexpr bool isAsciiUpperCase(T code)
 109 {
 110     return isAsciiUpperCase(sal_uInt32(code));
 111 }
 112 #endif
 113
 114 /** Check for ASCII alphabetic character.
 115
 116     @param code  A Unicode code point.
 117
 118     @return  True if code is an ASCII alphabetic character (ASCII 'A'--'Z' or
 119     'a'--'z').
 120
 121     @since LibreOffice 4.1
 122  */
 123 inline SAL_CONSTEXPR bool isAsciiAlpha(sal_uInt32 code)
 124 {
 125     assert(isUnicodeCodePoint(code));
 126     return isAsciiLowerCase(code) || isAsciiUpperCase(code);
 127 }
 128
 129 #if defined LIBO_INTERNAL_ONLY
 130 bool isAsciiAlpha(char) = delete;
 131 bool isAsciiAlpha(signed char) = delete;
 132 template <typename T> inline constexpr bool isAsciiAlpha(T code)
 133 {
 134     return isAsciiAlpha(sal_uInt32(code));
 135 }
 136 #endif
 137
 138 /** Check for ASCII digit character.
 139
 140     @param code  A Unicode code point.
 141
 142     @return  True if code is an ASCII (decimal) digit character (ASCII
 143     '0'--'9').
 144
 145     @since LibreOffice 4.1
 146  */
 147 inline SAL_CONSTEXPR bool isAsciiDigit(sal_uInt32 code)
 148 {
 149     assert(isUnicodeCodePoint(code));
 150     return code >= '0' && code <= '9';
 151 }
 152
 153 #if defined LIBO_INTERNAL_ONLY
 154 bool isAsciiDigit(char) = delete;
 155 bool isAsciiDigit(signed char) = delete;
 156 template <typename T> inline constexpr bool isAsciiDigit(T code)
 157 {
 158     return isAsciiDigit(sal_uInt32(code));
 159 }
 160 #endif
 161
 162 /** Check for ASCII alphanumeric character.
 163
 164     @param code  A Unicode code point.
 165
 166     @return  True if code is an ASCII alphanumeric character (ASCII '0'--'9',
 167     'A'--'Z', or 'a'--'z').
 168
 169     @since LibreOffice 4.1
 170  */
 171 inline SAL_CONSTEXPR bool isAsciiAlphanumeric(sal_uInt32 code)
 172 {
 173     assert(isUnicodeCodePoint(code));
 174     return isAsciiDigit(code) || isAsciiAlpha(code);
 175 }
 176
 177 #if defined LIBO_INTERNAL_ONLY
 178 bool isAsciiAlphanumeric(char) = delete;
 179 bool isAsciiAlphanumeric(signed char) = delete;
 180 template <typename T> inline constexpr bool isAsciiAlphanumeric(T code)
 181 {
 182     return isAsciiAlphanumeric(sal_uInt32(code));
 183 }
 184 #endif
 185
 186 /** Check for ASCII canonic hexadecimal digit character.
 187
 188     @param code  A Unicode code point.
 189
 190     @return  True if code is an ASCII canonic (i.e., upper case) hexadecimal
 191     digit character (ASCII '0'--'9' or 'A'--'F').
 192
 193     @since LibreOffice 4.1
 194  */
 195 inline SAL_CONSTEXPR bool isAsciiCanonicHexDigit(sal_uInt32 code)
 196 {
 197     assert(isUnicodeCodePoint(code));
 198     return isAsciiDigit(code) || (code >= 'A' && code <= 'F');
 199 }
 200
 201 #if defined LIBO_INTERNAL_ONLY
 202 bool isAsciiCanonicHexDigit(char) = delete;
 203 bool isAsciiCanonicHexDigit(signed char) = delete;
 204 template <typename T> inline constexpr bool isAsciiCanonicHexDigit(T code)
 205 {
 206     return isAsciiCanonicHexDigit(sal_uInt32(code));
 207 }
 208 #endif
 209
 210 /** Check for ASCII hexadecimal digit character.
 211
 212     @param code  A Unicode code point.
 213
 214     @return  True if code is an ASCII hexadecimal digit character (ASCII
 215     '0'--'9', 'A'--'F', or 'a'--'f').
 216
 217     @since LibreOffice 4.1
 218  */
 219 inline SAL_CONSTEXPR bool isAsciiHexDigit(sal_uInt32 code)
 220 {
 221     assert(isUnicodeCodePoint(code));
 222     return isAsciiCanonicHexDigit(code) || (code >= 'a' && code <= 'f');
 223 }
 224
 225 #if defined LIBO_INTERNAL_ONLY
 226 bool isAsciiHexDigit(char) = delete;
 227 bool isAsciiHexDigit(signed char) = delete;
 228 template <typename T> inline constexpr bool isAsciiHexDigit(T code)
 229 {
 230     return isAsciiHexDigit(sal_uInt32(code));
 231 }
 232 #endif
 233
 234 /** Check for ASCII octal digit character.
 235
 236     @param code  A Unicode code point.
 237
 238     @return  True if code is an ASCII octal digit character (ASCII '0'--'7').
 239
 240     @since LibreOffice 5.0
 241  */
 242 inline SAL_CONSTEXPR bool isAsciiOctalDigit(sal_uInt32 code)
 243 {
 244     assert(isUnicodeCodePoint(code));
 245     return code >= '0' && code <= '7';
 246 }
 247
 248 #if defined LIBO_INTERNAL_ONLY
 249 bool isAsciiOctalDigit(char) = delete;
 250 bool isAsciiOctalDigit(signed char) = delete;
 251 template <typename T> inline constexpr bool isAsciiOctalDigit(T code)
 252 {
 253     return isAsciiOctalDigit(sal_uInt32(code));
 254 }
 255 #endif
 256
 257 /** Check for ASCII white space character.
 258
 259     @param code  A Unicode code point.
 260
 261     @return  True if code is an ASCII white space character as defined by C for
 262     isspace in the "C" locale (ASCII ' ', '\\f', '\\n', '\\r', '\\t' '\\v').
 263
 264     @since LibreOffice 5.4
 265 */
 266 inline SAL_CONSTEXPR bool isAsciiWhiteSpace(sal_uInt32 code)
 267 {
 268     assert(isUnicodeCodePoint(code));
 269     return code == ' ' || code == '\f' || code == '\n' || code == '\r' || code == '\t'
 270            || code == '\v';
 271 }
 272
 273 #if defined LIBO_INTERNAL_ONLY
 274 bool isAsciiWhiteSpace(char) = delete;
 275 bool isAsciiWhiteSpace(signed char) = delete;
 276 template <typename T> inline constexpr bool isAsciiWhiteSpace(T code)
 277 {
 278     return isAsciiWhiteSpace(sal_uInt32(code));
 279 }
 280 #endif
 281
 282 /** Convert a character, if ASCII, to upper case.
 283
 284     @param code  A Unicode code point.
 285
 286     @return  code converted to ASCII upper case.
 287
 288     @since LibreOffice 4.2
 289 */
 290 inline SAL_CONSTEXPR sal_uInt32 toAsciiUpperCase(sal_uInt32 code)
 291 {
 292     assert(isUnicodeCodePoint(code));
 293     return isAsciiLowerCase(code) ? code - 32 : code;
 294 }
 295
 296 #if defined LIBO_INTERNAL_ONLY
 297 sal_uInt32 toAsciiUpperCase(char) = delete;
 298 sal_uInt32 toAsciiUpperCase(signed char) = delete;
 299 template <typename T> inline constexpr sal_uInt32 toAsciiUpperCase(T code)
 300 {
 301     return toAsciiUpperCase(sal_uInt32(code));
 302 }
 303 #endif
 304
 305 /** Convert a character, if ASCII, to lower case.
 306
 307     @param code  A Unicode code point.
 308
 309     @return  code converted to ASCII lower case.
 310
 311     @since LibreOffice 4.2
 312 */
 313 inline SAL_CONSTEXPR sal_uInt32 toAsciiLowerCase(sal_uInt32 code)
 314 {
 315     assert(isUnicodeCodePoint(code));
 316     return isAsciiUpperCase(code) ? code + 32 : code;
 317 }
 318
 319 #if defined LIBO_INTERNAL_ONLY
 320 sal_uInt32 toAsciiLowerCase(char) = delete;
 321 sal_uInt32 toAsciiLowerCase(signed char) = delete;
 322 template <typename T> inline constexpr sal_uInt32 toAsciiLowerCase(T code)
 323 {
 324     return toAsciiLowerCase(sal_uInt32(code));
 325 }
 326 #endif
 327
 328 /** Compare two characters ignoring ASCII case.
 329
 330     @param code1  A Unicode code point.
 331
 332     @param code2  A unicode code point.
 333
 334     @return  0 if both code points are equal,
 335              < 0 if code1 is less than code2,
 336              > 0 if code1 is greater than code2.
 337
 338     @since LibreOffice 4.2
 339  */
 340 inline SAL_CONSTEXPR sal_Int32 compareIgnoreAsciiCase(sal_uInt32 code1, sal_uInt32 code2)
 341 {
 342     assert(isUnicodeCodePoint(code1));
 343     assert(isUnicodeCodePoint(code2));
 344     return static_cast<sal_Int32>(toAsciiLowerCase(code1))
 345            - static_cast<sal_Int32>(toAsciiLowerCase(code2));
 346 }
 347
 348 /// @cond INTERNAL
 349 namespace detail
 350 {
 351 sal_uInt32 const surrogatesHighFirst = 0xD800;
 352 sal_uInt32 const surrogatesHighLast = 0xDBFF;
 353 sal_uInt32 const surrogatesLowFirst = 0xDC00;
 354 sal_uInt32 const surrogatesLowLast = 0xDFFF;
 355 }
 356 /// @endcond
 357
 358 /** Check for surrogate.
 359
 360     @param code  A Unicode code point.
 361
 362     @return  True if code is a surrogate code point (0xD800--0xDFFF).
 363
 364     @since LibreOffice 6.0
 365 */
 366 inline SAL_CONSTEXPR bool isSurrogate(sal_uInt32 code)
 367 {
 368     assert(isUnicodeCodePoint(code));
 369     return code >= detail::surrogatesHighFirst && code <= detail::surrogatesLowLast;
 370 }
 371
 372 /** Check for high surrogate.
 373
 374     @param code  A Unicode code point.
 375
 376     @return  True if code is a high surrogate code point (0xD800--0xDBFF).
 377
 378     @since LibreOffice 5.0
 379 */
 380 inline SAL_CONSTEXPR bool isHighSurrogate(sal_uInt32 code)
 381 {
 382     assert(isUnicodeCodePoint(code));
 383     return code >= detail::surrogatesHighFirst && code <= detail::surrogatesHighLast;
 384 }
 385
 386 /** Check for low surrogate.
 387
 388     @param code  A Unicode code point.
 389
 390     @return  True if code is a low surrogate code point (0xDC00--0xDFFF).
 391
 392     @since LibreOffice 5.0
 393 */
 394 inline SAL_CONSTEXPR bool isLowSurrogate(sal_uInt32 code)
 395 {
 396     assert(isUnicodeCodePoint(code));
 397     return code >= detail::surrogatesLowFirst && code <= detail::surrogatesLowLast;
 398 }
 399
 400 /** Get high surrogate half of a non-BMP Unicode code point.
 401
 402     @param code  A non-BMP Unicode code point.
 403
 404     @return  The UTF-16 high surrogate half for the give code point.
 405
 406     @since LibreOffice 5.0
 407  */
 408 inline SAL_CONSTEXPR sal_Unicode getHighSurrogate(sal_uInt32 code)
 409 {
 410     assert(isUnicodeCodePoint(code));
 411     assert(code >= 0x10000);
 412     return static_cast<sal_Unicode>(((code - 0x10000) >> 10) | detail::surrogatesHighFirst);
 413 }
 414
 415 /** Get low surrogate half of a non-BMP Unicode code point.
 416
 417     @param code  A non-BMP Unicode code point.
 418
 419     @return  The UTF-16 low surrogate half for the give code point.
 420
 421     @since LibreOffice 5.0
 422  */
 423 inline SAL_CONSTEXPR sal_Unicode getLowSurrogate(sal_uInt32 code)
 424 {
 425     assert(isUnicodeCodePoint(code));
 426     assert(code >= 0x10000);
 427     return static_cast<sal_Unicode>(((code - 0x10000) & 0x3FF) | detail::surrogatesLowFirst);
 428 }
 429
 430 /** Combine surrogates to form a code point.
 431
 432     @param high  A high surrogate code point.
 433
 434     @param low  A low surrogate code point.
 435
 436     @return  The code point represented by the surrogate pair.
 437
 438     @since LibreOffice 5.0
 439 */
 440 inline SAL_CONSTEXPR sal_uInt32 combineSurrogates(sal_uInt32 high, sal_uInt32 low)
 441 {
 442     assert(isHighSurrogate(high));
 443     assert(isLowSurrogate(low));
 444     return ((high - detail::surrogatesHighFirst) << 10) + (low - detail::surrogatesLowFirst)
 445            + 0x10000;
 446 }
 447
 448 /** Split a Unicode code point into UTF-16 code units.
 449
 450     @param code  A Unicode code point.
 451
 452     @param output  A non-null pointer to an array with space for at least two
 453     sal_Unicode UTF-16 code units.
 454
 455     @return  The number of UTF-16 code units placed into the output (either one
 456     or two).
 457
 458     @since LibreOffice 5.3
 459 */
 460 inline SAL_CONSTEXPR std::size_t splitSurrogates(sal_uInt32 code, sal_Unicode* output)
 461 {
 462     assert(isUnicodeCodePoint(code));
 463     assert(output != NULL);
 464     if (code < 0x10000)
 465     {
 466         output[0] = code;
 467         return 1;
 468     }
 469     else
 470     {
 471         output[0] = getHighSurrogate(code);
 472         output[1] = getLowSurrogate(code);
 473         return 2;
 474     }
 475 }
 476
 477 /** Check for Unicode scalar value.
 478
 479     @param code  An integer.
 480
 481     @return  True if code is a Unicode scalar value.
 482
 483     @since LibreOffice 6.0
 484 */
 485 inline SAL_CONSTEXPR bool isUnicodeScalarValue(sal_uInt32 code)
 486 {
 487     return isUnicodeCodePoint(code) && !isSurrogate(code);
 488 }
 489 }
 490
 491 #endif
 492
 493 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */