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 #ifndef INCLUDED_RTL_CHARACTER_HXX
  21 #define INCLUDED_RTL_CHARACTER_HXX
  22
  23 #include <sal/config.h>
  24
  25 #include <cassert>
  26
  27 #include <sal/types.h>
  28
  29 namespace rtl
  30 {
  31
  32 /** Check for Unicode code point.
  33
  34     @param code  An integer.
  35
  36     @return  True if code is a Unicode code point.
  37
  38     @since LibreOffice 5.2
  39 */
  40 inline bool isUnicodeCodePoint(sal_uInt32 code)
  41 {
  42     return code <= 0x10FFFF;
  43 }
  44
  45 /** Check for ASCII character.
  46
  47     @param code  A Unicode code point.
  48
  49     @return  True if code is an ASCII character (0x00--0x7F).
  50
  51     @since LibreOffice 4.1
  52  */
  53 inline bool isAscii(sal_uInt32 code)
  54 {
  55     assert(isUnicodeCodePoint(code));
  56     return code <= 0x7F;
  57 }
  58
  59 /** Check for ASCII lower case character.
  60
  61     @param code  A Unicode code point.
  62
  63     @return  True if code is an ASCII lower case alphabetic character (ASCII
  64     'a'--'z').
  65
  66     @since LibreOffice 4.1
  67  */
  68 inline bool isAsciiLowerCase(sal_uInt32 code)
  69 {
  70     assert(isUnicodeCodePoint(code));
  71     return code >= 'a' && code <= 'z';
  72 }
  73
  74 /** Check for ASCII upper case character.
  75
  76     @param code  A Unicode code point.
  77
  78     @return  True if code is an ASCII upper case alphabetic character (ASCII
  79     'A'--'Z').
  80
  81     @since LibreOffice 4.1
  82  */
  83 inline bool isAsciiUpperCase(sal_uInt32 code)
  84 {
  85     assert(isUnicodeCodePoint(code));
  86     return code >= 'A' && code <= 'Z';
  87 }
  88
  89 /** Check for ASCII alphabetic character.
  90
  91     @param code  A Unicode code point.
  92
  93     @return  True if code is an ASCII alphabetic character (ASCII 'A'--'Z' or
  94     'a'--'z').
  95
  96     @since LibreOffice 4.1
  97  */
  98 inline bool isAsciiAlpha(sal_uInt32 code)
  99 {
 100     assert(isUnicodeCodePoint(code));
 101     return isAsciiLowerCase(code) || isAsciiUpperCase(code);
 102 }
 103
 104 /** Check for ASCII digit character.
 105
 106     @param code  A Unicode code point.
 107
 108     @return  True if code is an ASCII (decimal) digit character (ASCII
 109     '0'--'9').
 110
 111     @since LibreOffice 4.1
 112  */
 113 inline bool isAsciiDigit(sal_uInt32 code)
 114 {
 115     assert(isUnicodeCodePoint(code));
 116     return code >= '0' && code <= '9';
 117 }
 118
 119 /** Check for ASCII alphanumeric character.
 120
 121     @param code  A Unicode code point.
 122
 123     @return  True if code is an ASCII alphanumeric character (ASCII '0'--'9',
 124     'A'--'Z', or 'a'--'z').
 125
 126     @since LibreOffice 4.1
 127  */
 128 inline bool isAsciiAlphanumeric(sal_uInt32 code)
 129 {
 130     assert(isUnicodeCodePoint(code));
 131     return isAsciiDigit(code) || isAsciiAlpha(code);
 132 }
 133
 134 /** Check for ASCII canonic hexadecimal digit character.
 135
 136     @param code  A Unicode code point.
 137
 138     @return  True if code is an ASCII canonic (i.e., upper case) hexadecimal
 139     digit character (ASCII '0'--'9' or 'A'--'F').
 140
 141     @since LibreOffice 4.1
 142  */
 143 inline bool isAsciiCanonicHexDigit(sal_uInt32 code)
 144 {
 145     assert(isUnicodeCodePoint(code));
 146     return isAsciiDigit(code) || (code >= 'A' && code <= 'F');
 147 }
 148
 149 /** Check for ASCII hexadecimal digit character.
 150
 151     @param code  A Unicode code point.
 152
 153     @return  True if code is an ASCII hexadecimal digit character (ASCII
 154     '0'--'9', 'A'--'F', or 'a'--'f').
 155
 156     @since LibreOffice 4.1
 157  */
 158 inline bool isAsciiHexDigit(sal_uInt32 code)
 159 {
 160     assert(isUnicodeCodePoint(code));
 161     return isAsciiCanonicHexDigit(code) || (code >= 'a' && code <= 'f');
 162 }
 163
 164 /** Check for ASCII octal digit character.
 165
 166     @param code  A Unicode code point.
 167
 168     @return  True if code is an ASCII octal digit character (ASCII '0'--'7').
 169
 170     @since LibreOffice 5.0
 171  */
 172 inline bool isAsciiOctalDigit(sal_uInt32 code)
 173 {
 174     assert(isUnicodeCodePoint(code));
 175     return code >= '0' && code <= '7';
 176 }
 177
 178
 179 /** Convert a character, if ASCII, to upper case.
 180
 181     @param code  A Unicode code point.
 182
 183     @return  code converted to ASCII upper case.
 184
 185     @since LibreOffice 4.2
 186 */
 187 inline sal_uInt32 toAsciiUpperCase(sal_uInt32 code)
 188 {
 189     assert(isUnicodeCodePoint(code));
 190     return isAsciiLowerCase(code) ? code - 32 : code;
 191 }
 192
 193 /** Convert a character, if ASCII, to lower case.
 194
 195     @param code  A Unicode code point.
 196
 197     @return  code converted to ASCII lower case.
 198
 199     @since LibreOffice 4.2
 200 */
 201 inline sal_uInt32 toAsciiLowerCase(sal_uInt32 code)
 202 {
 203     assert(isUnicodeCodePoint(code));
 204     return isAsciiUpperCase(code) ? code + 32 : code;
 205 }
 206
 207 /** Compare two characters ignoring ASCII case.
 208
 209     @param code1  A Unicode code point.
 210
 211     @param code2  A unicode code point.
 212
 213     @return  0 if both code points are equal,
 214              < 0 if code1 is less than code2,
 215              > 0 if code1 is greater than code2.
 216
 217     @since LibreOffice 4.2
 218  */
 219 inline sal_Int32 compareIgnoreAsciiCase(sal_uInt32 code1, sal_uInt32 code2)
 220 {
 221     assert(isUnicodeCodePoint(code1));
 222     assert(isUnicodeCodePoint(code2));
 223     return static_cast<sal_Int32>(toAsciiLowerCase(code1))
 224         - static_cast<sal_Int32>(toAsciiLowerCase(code2));
 225 }
 226
 227 /// @cond INTERNAL
 228 namespace detail {
 229
 230 sal_uInt32 const surrogatesHighFirst = 0xD800;
 231 sal_uInt32 const surrogatesHighLast = 0xDBFF;
 232 sal_uInt32 const surrogatesLowFirst = 0xDC00;
 233 sal_uInt32 const surrogatesLowLast = 0xDFFF;
 234
 235 }
 236 /// @endcond
 237
 238 /** Check for high surrogate.
 239
 240     @param code  A Unicode code point.
 241
 242     @return  True if code is a high surrogate code point (0xD800--0xDBFF).
 243
 244     @since LibreOffice 5.0
 245 */
 246 inline bool isHighSurrogate(sal_uInt32 code) {
 247     assert(isUnicodeCodePoint(code));
 248     return code >= detail::surrogatesHighFirst
 249         && code <= detail::surrogatesHighLast;
 250 }
 251
 252 /** Check for low surrogate.
 253
 254     @param code  A Unicode code point.
 255
 256     @return  True if code is a low surrogate code point (0xDC00--0xDFFF).
 257
 258     @since LibreOffice 5.0
 259 */
 260 inline bool isLowSurrogate(sal_uInt32 code) {
 261     assert(isUnicodeCodePoint(code));
 262     return code >= detail::surrogatesLowFirst
 263         && code <= detail::surrogatesLowLast;
 264 }
 265
 266 /** Get high surrogate half of a non-BMP Unicode code point.
 267
 268     @param code  A non-BMP Unicode code point.
 269
 270     @return  The UTF-16 high surrogate half for the give code point.
 271
 272     @since LibreOffice 5.0
 273  */
 274 inline sal_Unicode getHighSurrogate(sal_uInt32 code) {
 275     assert(isUnicodeCodePoint(code));
 276     assert(code >= 0x10000);
 277     return static_cast<sal_Unicode>(((code - 0x10000) >> 10) | detail::surrogatesHighFirst);
 278 }
 279
 280 /** Get low surrogate half of a non-BMP Unicode code point.
 281
 282     @param code  A non-BMP Unicode code point.
 283
 284     @return  The UTF-16 low surrogate half for the give code point.
 285
 286     @since LibreOffice 5.0
 287  */
 288 inline sal_Unicode getLowSurrogate(sal_uInt32 code) {
 289     assert(isUnicodeCodePoint(code));
 290     assert(code >= 0x10000);
 291     return static_cast<sal_Unicode>(((code - 0x10000) & 0x3FF) | detail::surrogatesLowFirst);
 292 }
 293
 294 /** Combine surrogates to form a code point.
 295
 296     @param high  A high surrogate code point.
 297
 298     @param low  A low surrogate code point.
 299
 300     @return  The code point represented by the surrogate pair.
 301
 302     @since LibreOffice 5.0
 303 */
 304 inline sal_uInt32 combineSurrogates(sal_uInt32 high, sal_uInt32 low) {
 305     assert(isHighSurrogate(high));
 306     assert(isLowSurrogate(low));
 307     return ((high - detail::surrogatesHighFirst) << 10)
 308         + (low - detail::surrogatesLowFirst) + 0x10000;
 309 }
 310
 311 }
 312
 313 #endif
 314
 315 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */