include/o3tl/string_view.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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
  10 #pragma once
  11
  12 #include <sal/config.h>
  13
  14 #include <cassert>
  15 #include <cstddef>
  16 #include <string>
  17 #include <string_view>
  18 #include <type_traits>
  19
  20 #include <o3tl/intcmp.hxx>
  21 #include <rtl/character.hxx>
  22 #include <rtl/ustring.h>
  23 #include <rtl/math.h>
  24 #include <sal/types.h>
  25
  26 namespace o3tl
  27 {
  28 // Like OUString::equalsAscii/OUString::equalsAsciiL, but for std::u16string_view:
  29 inline bool equalsAscii(std::u16string_view s1, std::string_view s2)
  30 {
  31     return s1.size() == s2.size()
  32            && rtl_ustr_ascii_shortenedCompare_WithLength(s1.data(), s1.size(), s2.data(), s2.size())
  33                   == 0;
  34 }
  35
  36 // Like OUString::compareToAscii, but for std::u16string_view and std::string_view:
  37 inline int compareToAscii(std::u16string_view s1, std::string_view s2)
  38 {
  39     return rtl_ustr_asciil_reverseCompare_WithLength(s1.data(), s1.size(), s2.data(), s2.size());
  40 };
  41
  42 // Like OUString::equalsIgnoreAsciiCase, but for two std::u16string_view:
  43 inline bool equalsIgnoreAsciiCase(std::u16string_view s1, std::u16string_view s2)
  44 {
  45     if (s1.size() != s2.size())
  46         return false;
  47     if (s1.data() == s2.data())
  48         return true;
  49     return rtl_ustr_compareIgnoreAsciiCase_WithLength(s1.data(), s1.size(), s2.data(), s2.size())
  50            == 0;
  51 };
  52
  53 inline bool equalsIgnoreAsciiCase(std::u16string_view s1, std::string_view s2)
  54 {
  55     return s1.size() == s2.size()
  56            && (rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(s1.data(), s1.size(),
  57                                                                          s2.data(), s2.size())
  58                == 0);
  59 }
  60
  61 inline bool equalsIgnoreAsciiCase(std::string_view s1, std::string_view s2)
  62 {
  63     if (s1.size() != s2.size())
  64         return false;
  65     if (s1.data() == s2.data())
  66         return true;
  67     return rtl_str_compareIgnoreAsciiCase_WithLength(s1.data(), s1.size(), s2.data(), s2.size())
  68            == 0;
  69 };
  70
  71 // Like OUString::compareToIgnoreAsciiCase, but for two std::u16string_view:
  72 inline int compareToIgnoreAsciiCase(std::u16string_view s1, std::u16string_view s2)
  73 {
  74     return rtl_ustr_compareIgnoreAsciiCase_WithLength(s1.data(), s1.size(), s2.data(), s2.size());
  75 };
  76
  77 // Like OUString::matchIgnoreAsciiCase, but for two std::u16string_view:
  78 inline bool matchIgnoreAsciiCase(std::u16string_view s1, std::u16string_view s2,
  79                                  sal_Int32 fromIndex = 0)
  80 {
  81     return rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength(
  82                s1.data() + fromIndex, s1.size() - fromIndex, s2.data(), s2.size(), s2.size())
  83            == 0;
  84 }
  85
  86 // Like OUString::matchIgnoreAsciiCase, but for std::u16string_view and std::string_view:
  87 inline bool matchIgnoreAsciiCase(std::u16string_view s1, std::string_view s2,
  88                                  sal_Int32 fromIndex = 0)
  89 {
  90     return rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(
  91                s1.data() + fromIndex, s1.size() - fromIndex, s2.data(), s2.size())
  92            == 0;
  93 }
  94
  95 // Like OUString::endsWithIgnoreAsciiCase, but for std::u16string_view
  96 inline bool endsWithIgnoreAsciiCase(std::u16string_view s1, std::u16string_view s2,
  97                                     std::u16string_view* rest = nullptr)
  98 {
  99     auto const b = s2.size() <= s1.size() && matchIgnoreAsciiCase(s1, s2, s1.size() - s2.size());
 100     if (b && rest != nullptr)
 101     {
 102         *rest = s1.substr(0, s1.size() - s2.size());
 103     }
 104     return b;
 105 }
 106
 107 inline bool endsWithIgnoreAsciiCase(std::u16string_view s1, std::string_view s2,
 108                                     std::u16string_view* rest = nullptr)
 109 {
 110     auto const b = s2.size() <= s1.size()
 111                    && rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
 112                           s1.data() + s1.size() - s2.size(), s2.size(), s2.data(), s2.size())
 113                           == 0;
 114     if (b && rest != nullptr)
 115     {
 116         *rest = s1.substr(0, s1.size() - s2.size());
 117     }
 118     return b;
 119 }
 120
 121 // Similar to O[U]String::getToken, returning the first token of a std::[u16]string_view starting
 122 // at a given position.
 123 //
 124 // Attention:  There are two sets of o3tl::getToken overloads here.  This first set has an interface
 125 // based on std::size_t length parameters, and its semantics don't match those of
 126 // O[U]String::getToken exactly (buf if needed, it can be extended to return the n'th token instead
 127 // of just the first, and/or support an initial position of npos, to make the semantics match).
 128 template <typename charT, typename traits = std::char_traits<charT>>
 129 inline std::basic_string_view<charT, traits> getToken(std::basic_string_view<charT, traits> sv,
 130                                                       charT delimiter, std::size_t& position)
 131 {
 132     assert(position <= sv.size());
 133     auto const n = sv.find(delimiter, position);
 134     std::basic_string_view<charT, traits> t;
 135     if (n == std::string_view::npos)
 136     {
 137         t = sv.substr(position);
 138         position = std::string_view::npos;
 139     }
 140     else
 141     {
 142         t = sv.substr(position, n - position);
 143         position = n + 1;
 144     }
 145     return t;
 146 }
 147 // The following two overloads prevent overload resolution mistakes that would occur with their
 148 // template counterpart, when sv is of a type that is implicitly convertible to basic_string_view
 149 // (like OString or OUString), in which case overload resolution would erroneously choose the
 150 // three-argument overloads (taking sv, nToken, cTok) from the second set of
 151 // o3tl::getToken overloads below:
 152 inline std::string_view getToken(std::string_view sv, char delimiter, std::size_t& position)
 153 {
 154     return getToken<char>(sv, delimiter, position);
 155 }
 156 inline std::u16string_view getToken(std::u16string_view sv, char16_t delimiter,
 157                                     std::size_t& position)
 158 {
 159     return getToken<char16_t>(sv, delimiter, position);
 160 }
 161
 162 // Similar to O[U]String::getToken.
 163 //
 164 // Attention:  There are two sets of o3tl::getToken overloads here.  This second set has an
 165 // interface based on sal_Int32 length parameters, and is meant to be a drop-in replacement for
 166 // O[U]String::getToken.
 167 template <typename charT, typename traits = std::char_traits<charT>>
 168 inline std::basic_string_view<charT, traits> getToken(std::basic_string_view<charT, traits> pStr,
 169                                                       sal_Int32 nToken, charT cTok,
 170                                                       sal_Int32& rnIndex)
 171 {
 172     assert(o3tl::IntCmp(rnIndex) <= o3tl::IntCmp(pStr.size()));
 173
 174     // Return an empty string and set rnIndex to -1 if either nToken or rnIndex is
 175     // negative:
 176     if (rnIndex >= 0 && nToken >= 0)
 177     {
 178         const charT* pOrgCharStr = pStr.data();
 179         const charT* pCharStr = pOrgCharStr + rnIndex;
 180         sal_Int32 nLen = pStr.size() - rnIndex;
 181         sal_Int32 nTokCount = 0;
 182         const charT* pCharStrStart = pCharStr;
 183         while (nLen > 0)
 184         {
 185             if (*pCharStr == cTok)
 186             {
 187                 nTokCount++;
 188
 189                 if (nTokCount > nToken)
 190                     break;
 191                 if (nTokCount == nToken)
 192                     pCharStrStart = pCharStr + 1;
 193             }
 194
 195             pCharStr++;
 196             nLen--;
 197         }
 198         if (nTokCount >= nToken)
 199         {
 200             if (nLen > 0)
 201                 rnIndex = pCharStr - pOrgCharStr + 1;
 202             else
 203                 rnIndex = -1;
 204             return std::basic_string_view<charT, traits>(pCharStrStart, pCharStr - pCharStrStart);
 205         }
 206     }
 207
 208     rnIndex = -1;
 209     return std::basic_string_view<charT, traits>();
 210 }
 211 // The following two overloads prevent deduction failures that would occur with their template
 212 // counterpart, when sv is of a type that is implicitly convertible to basic_string_view (like
 213 // OString or OUString):
 214 inline std::string_view getToken(std::string_view sv, sal_Int32 nToken, char cTok,
 215                                  sal_Int32& rnIndex)
 216 {
 217     return getToken<char>(sv, nToken, cTok, rnIndex);
 218 }
 219 inline std::u16string_view getToken(std::u16string_view sv, sal_Int32 nToken, char16_t cTok,
 220                                     sal_Int32& rnIndex)
 221 {
 222     return getToken<char16_t>(sv, nToken, cTok, rnIndex);
 223 }
 224 inline std::string_view getToken(std::string_view sv, sal_Int32 nToken, char cTok)
 225 {
 226     sal_Int32 nIndex = 0;
 227     return getToken<char>(sv, nToken, cTok, nIndex);
 228 }
 229 inline std::u16string_view getToken(std::u16string_view sv, sal_Int32 nToken, char16_t cTok)
 230 {
 231     sal_Int32 nIndex = 0;
 232     return getToken<char16_t>(sv, nToken, cTok, nIndex);
 233 }
 234
 235 // Implementations of C++20 std::basic_string_view::starts_with and
 236 // std::basic_string_view::ends_with, until we can use those directly on all platforms:
 237 template <typename charT, typename traits = std::char_traits<charT>>
 238 constexpr bool starts_with(std::basic_string_view<charT, traits> sv,
 239                            std::basic_string_view<charT, traits> x) noexcept
 240 {
 241 #if defined __cpp_lib_starts_ends_with
 242     return sv.starts_with(x);
 243 #else
 244     return sv.substr(0, x.size()) == x;
 245 #endif
 246 }
 247 template <typename charT, typename traits = std::char_traits<charT>>
 248 constexpr bool starts_with(std::basic_string_view<charT, traits> sv, charT x) noexcept
 249 {
 250 #if defined __cpp_lib_starts_ends_with
 251     return sv.starts_with(x);
 252 #else
 253     return !sv.empty() && traits::eq(sv.front(), x);
 254 #endif
 255 }
 256 template <typename charT, typename traits = std::char_traits<charT>>
 257 constexpr bool starts_with(std::basic_string_view<charT, traits> sv, charT const* x)
 258 {
 259 #if defined __cpp_lib_starts_ends_with
 260     return sv.starts_with(x);
 261 #else
 262     return starts_with(sv, std::basic_string_view<charT, traits>(x));
 263 #endif
 264 }
 265 template <typename charT, typename traits = std::char_traits<charT>>
 266 constexpr bool ends_with(std::basic_string_view<charT, traits> sv,
 267                          std::basic_string_view<charT, traits> x) noexcept
 268 {
 269 #if defined __cpp_lib_starts_ends_with
 270     return sv.ends_with(x);
 271 #else
 272     return sv.size() >= x.size()
 273            && sv.compare(sv.size() - x.size(), std::basic_string_view<charT, traits>::npos, x) == 0;
 274 #endif
 275 }
 276 template <typename charT, typename traits = std::char_traits<charT>>
 277 constexpr bool ends_with(std::basic_string_view<charT, traits> sv, charT x) noexcept
 278 {
 279 #if defined __cpp_lib_starts_ends_with
 280     return sv.ends_with(x);
 281 #else
 282     return !sv.empty() && traits::eq(sv.back(), x);
 283 #endif
 284 }
 285 template <typename charT, typename traits = std::char_traits<charT>>
 286 constexpr bool ends_with(std::basic_string_view<charT, traits> sv, charT const* x)
 287 {
 288 #if defined __cpp_lib_starts_ends_with
 289     return sv.ends_with(x);
 290 #else
 291     return ends_with(sv, std::basic_string_view<charT, traits>(x));
 292 #endif
 293 }
 294 // The following overloads prevent deduction failures that would occur with their template
 295 // counterparts, when x is of a type that is implicitly convertible to basic_string_view (like
 296 // OString or OUString, and we only bother to provide overloads for the char and char16_t cases, not
 297 // also for char32_t and wchar_t, nor for C++20 char8_t):
 298 constexpr bool starts_with(std::string_view sv, std::string_view x) noexcept
 299 {
 300     return starts_with<char>(sv, x);
 301 }
 302 constexpr bool starts_with(std::u16string_view sv, std::u16string_view x) noexcept
 303 {
 304     return starts_with<char16_t>(sv, x);
 305 }
 306 constexpr bool ends_with(std::string_view sv, std::string_view x) noexcept
 307 {
 308     return ends_with<char>(sv, x);
 309 }
 310 constexpr bool ends_with(std::u16string_view sv, std::u16string_view x) noexcept
 311 {
 312     return ends_with<char16_t>(sv, x);
 313 }
 314
 315 // Variants of C++20 std::basic_string_view::starts_with and
 316 // std::basic_string_view::ends_with that have a rest out parameter, similar to our OString and
 317 // OUString startsWith and endsWith member functions:
 318 template <typename charT, typename traits = std::char_traits<charT>>
 319 constexpr bool starts_with(std::basic_string_view<charT, traits> sv,
 320                            std::basic_string_view<charT, traits> x,
 321                            std::basic_string_view<charT, traits>* rest) noexcept
 322 {
 323     assert(rest != nullptr);
 324     auto const found = starts_with(sv, x);
 325     if (found)
 326     {
 327         *rest = sv.substr(x.length());
 328     }
 329     return found;
 330 }
 331 template <typename charT, typename traits = std::char_traits<charT>>
 332 constexpr bool starts_with(std::basic_string_view<charT, traits> sv, charT x,
 333                            std::basic_string_view<charT, traits>* rest) noexcept
 334 {
 335     assert(rest != nullptr);
 336     auto const found = starts_with(sv, x);
 337     if (found)
 338     {
 339         *rest = sv.substr(1);
 340     }
 341     return found;
 342 }
 343 template <typename charT, typename traits = std::char_traits<charT>>
 344 constexpr bool starts_with(std::basic_string_view<charT, traits> sv, charT const* x,
 345                            std::basic_string_view<charT, traits>* rest)
 346 {
 347     assert(rest != nullptr);
 348     auto const found = starts_with(sv, x);
 349     if (found)
 350     {
 351         *rest = sv.substr(traits::length(x));
 352     }
 353     return found;
 354 }
 355 template <typename charT, typename traits = std::char_traits<charT>>
 356 constexpr bool ends_with(std::basic_string_view<charT, traits> sv,
 357                          std::basic_string_view<charT, traits> x,
 358                          std::basic_string_view<charT, traits>* rest) noexcept
 359 {
 360     assert(rest != nullptr);
 361     auto const found = ends_with(sv, x);
 362     if (found)
 363     {
 364         *rest = sv.substr(0, sv.length() - x.length());
 365     }
 366     return found;
 367 }
 368 template <typename charT, typename traits = std::char_traits<charT>>
 369 constexpr bool ends_with(std::basic_string_view<charT, traits> sv, charT x,
 370                          std::basic_string_view<charT, traits>* rest) noexcept
 371 {
 372     assert(rest != nullptr);
 373     auto const found = ends_with(sv, x);
 374     if (found)
 375     {
 376         *rest = sv.substr(0, sv.length() - 1);
 377     }
 378     return found;
 379 }
 380 template <typename charT, typename traits = std::char_traits<charT>>
 381 constexpr bool ends_with(std::basic_string_view<charT, traits> sv, charT const* x,
 382                          std::basic_string_view<charT, traits>* rest)
 383 {
 384     assert(rest != nullptr);
 385     auto const found = ends_with(sv, x);
 386     if (found)
 387     {
 388         *rest = sv.substr(0, sv.length() - traits::length(x));
 389     }
 390     return found;
 391 }
 392 // The following overloads prevent deduction failures that would occur with their template
 393 // counterparts, when x is of a type that is implicitly convertible to basic_string_view (like
 394 // OString or OUString, and we only bother to provide overloads for the char and char16_t cases, not
 395 // also for char32_t and wchar_t, nor for C++20 char8_t):
 396 constexpr bool starts_with(std::string_view sv, std::string_view x, std::string_view* rest) noexcept
 397 {
 398     return starts_with<char>(sv, x, rest);
 399 }
 400 constexpr bool starts_with(std::u16string_view sv, std::u16string_view x,
 401                            std::u16string_view* rest) noexcept
 402 {
 403     return starts_with<char16_t>(sv, x, rest);
 404 }
 405 constexpr bool ends_with(std::string_view sv, std::string_view x, std::string_view* rest) noexcept
 406 {
 407     return ends_with<char>(sv, x, rest);
 408 }
 409 constexpr bool ends_with(std::u16string_view sv, std::u16string_view x,
 410                          std::u16string_view* rest) noexcept
 411 {
 412     return ends_with<char16_t>(sv, x, rest);
 413 }
 414
 415 namespace internal
 416 {
 417 inline bool implIsWhitespace(sal_Unicode c)
 418 {
 419     /* Space or Control character? */
 420     if ((c <= 32) && c)
 421         return true;
 422
 423     /* Only in the General Punctuation area Space or Control characters are included? */
 424     if ((c < 0x2000) || (c > 0x2029))
 425         return false;
 426
 427     if ((c <= 0x200B) || /* U+2000 - U+200B All Spaces */
 428         (c >= 0x2028)) /* U+2028 LINE SEPARATOR, U+2029 PARAGRAPH SEPARATOR */
 429         return true;
 430
 431     return false;
 432 }
 433 } // namespace internal
 434
 435 // Like OUString::trim, but for std::[u16]string_view:
 436 template <typename charT, typename traits = std::char_traits<charT>>
 437 std::basic_string_view<charT, traits> trim(std::basic_string_view<charT, traits> str)
 438 {
 439     auto pFirst = str.data();
 440     auto pLast = pFirst + str.size();
 441
 442     while ((pFirst < pLast) && internal::implIsWhitespace(*pFirst))
 443         ++pFirst;
 444
 445     if (pFirst == pLast)
 446         return {};
 447
 448     do
 449         --pLast;
 450     while (internal::implIsWhitespace(*pLast));
 451
 452     return std::basic_string_view<charT, traits>(pFirst, pLast - pFirst + 1);
 453 }
 454
 455 // "deduction guides"
 456
 457 inline auto trim(std::string_view str) { return trim<>(str); }
 458 inline auto trim(std::u16string_view str) { return trim<>(str); }
 459
 460 // Like OString::toInt32, but for std::string_view:
 461 inline sal_Int32 toInt32(std::u16string_view str, sal_Int16 radix = 10)
 462 {
 463     sal_Int64 n = rtl_ustr_toInt64_WithLength(str.data(), radix, str.size());
 464     if (n < SAL_MIN_INT32 || n > SAL_MAX_INT32)
 465         n = 0;
 466     return n;
 467 }
 468 inline sal_Int32 toInt32(std::string_view str, sal_Int16 radix = 10)
 469 {
 470     sal_Int64 n = rtl_str_toInt64_WithLength(str.data(), radix, str.size());
 471     if (n < SAL_MIN_INT32 || n > SAL_MAX_INT32)
 472         n = 0;
 473     return n;
 474 }
 475
 476 // Like OString::toUInt32, but for std::string_view:
 477 inline sal_uInt32 toUInt32(std::u16string_view str, sal_Int16 radix = 10)
 478 {
 479     sal_Int64 n = rtl_ustr_toInt64_WithLength(str.data(), radix, str.size());
 480     if (n < 0 || n > SAL_MAX_UINT32)
 481         n = 0;
 482     return n;
 483 }
 484 inline sal_uInt32 toUInt32(std::string_view str, sal_Int16 radix = 10)
 485 {
 486     sal_Int64 n = rtl_str_toInt64_WithLength(str.data(), radix, str.size());
 487     if (n < 0 || n > SAL_MAX_UINT32)
 488         n = 0;
 489     return n;
 490 }
 491
 492 // Like OString::toInt64, but for std::string_view:
 493 inline sal_Int64 toInt64(std::u16string_view str, sal_Int16 radix = 10)
 494 {
 495     return rtl_ustr_toInt64_WithLength(str.data(), radix, str.size());
 496 }
 497 inline sal_Int64 toInt64(std::string_view str, sal_Int16 radix = 10)
 498 {
 499     return rtl_str_toInt64_WithLength(str.data(), radix, str.size());
 500 }
 501
 502 // Like OString::toDouble, but for std::string_view:
 503 inline double toDouble(std::u16string_view str)
 504 {
 505     return rtl_math_uStringToDouble(str.data(), str.data() + str.size(), '.', 0, nullptr, nullptr);
 506 }
 507 inline double toDouble(std::string_view str)
 508 {
 509     return rtl_math_stringToDouble(str.data(), str.data() + str.size(), '.', 0, nullptr, nullptr);
 510 }
 511
 512 // Like OUString::iterateCodePoints, but for std::string_view:
 513 template <typename T>
 514 requires(std::is_same_v<T, sal_Int32> || std::is_same_v<T, std::size_t>) sal_uInt32
 515     iterateCodePoints(std::u16string_view string, T* indexUtf16, sal_Int32 incrementCodePoints = 1)
 516 {
 517     std::size_t n;
 518     char16_t cu;
 519     sal_uInt32 cp;
 520     assert(indexUtf16 != nullptr);
 521     n = *indexUtf16;
 522     assert(n <= string.length());
 523     while (incrementCodePoints < 0)
 524     {
 525         assert(n > 0);
 526         cu = string[--n];
 527         if (rtl::isLowSurrogate(cu) && n != 0 && rtl::isHighSurrogate(string[n - 1]))
 528         {
 529             --n;
 530         }
 531         ++incrementCodePoints;
 532     }
 533     assert(n < string.length());
 534     cu = string[n];
 535     if (rtl::isHighSurrogate(cu) && string.length() - n >= 2 && rtl::isLowSurrogate(string[n + 1]))
 536     {
 537         cp = rtl::combineSurrogates(cu, string[n + 1]);
 538     }
 539     else
 540     {
 541         cp = cu;
 542     }
 543     while (incrementCodePoints > 0)
 544     {
 545         assert(n < string.length());
 546         cu = string[n++];
 547         if (rtl::isHighSurrogate(cu) && n != string.length() && rtl::isLowSurrogate(string[n]))
 548         {
 549             ++n;
 550         }
 551         --incrementCodePoints;
 552     }
 553     assert(n <= string.length());
 554     *indexUtf16 = n;
 555     return cp;
 556 }
 557
 558 } // namespace
 559
 560 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */